Finish ConfirmedController

Sample/ECommerce.Equinox/ECommerce.Api/Controllers/ConfirmedCartsController.fs

@@ -4,54 +4,56 @@ open Microsoft.AspNetCore.Mvc
 
 open ECommerce.Domain
 
-type TicketsTranchesDto = { activeEpochs : TrancheReferenceDto[] }
- and TrancheReferenceDto = { fc : FcId; epochId : ConfirmedEpochId }
+type TranchesDto = { activeEpochs : TrancheReferenceDto[] }
+ and TrancheReferenceDto = { seriesId : ConfirmedSeriesId; epochId : ConfirmedEpochId }
 
-type SliceDto = { closed : bool; tickets : ItemDto[]; position : TicketsCheckpoint; checkpoint : TicketsCheckpoint }
- and ItemDto = { id : TicketId; payload : string }
-module ItemDto =
+module TranchesDto =
 
-    let ofDto (x : TicketsEpoch.Events.Item) : ItemDto =
-        { id = x.id; payload = x.payload }
+    let ofEpochId epochId =
+        { activeEpochs = [| { seriesId = ConfirmedSeriesId.wellKnownId; epochId = epochId } |]}
+
+type SliceDto = { closed : bool; carts : CartDto[]; position : ConfirmedCheckpoint; checkpoint : ConfirmedCheckpoint }
+ and CartDto = { id : CartId; items : ItemDto[] }
+ and ItemDto = { productId : ProductId; unitPrice : decimal; quantity : int }
+
+module CartDto =
+
+    let ofDto (x : ConfirmedEpoch.Events.Cart) : CartDto =
+        {  id = x.cartId
+           items = [| for x in x.items -> { productId = x.productId; unitPrice = x.unitPrice; quantity = x.quantity } |] }
 
 module Checkpoint =
 
-    let ofEpochAndOffset (epoch : TicketsEpochId) (offset : int) =
-        TicketsCheckpoint.ofEpochAndOffset epoch offset
+    let ofEpochAndOffset (epoch : ConfirmedEpochId) (offset : int) =
+        ConfirmedCheckpoint.ofEpochAndOffset epoch offset
 
-    let ofState (epochId : TicketsEpochId) (s : TicketsEpoch.Reader.StateDto) =
-        TicketsCheckpoint.ofEpochContent epochId s.closed s.tickets.Length
+    let ofState (epochId : ConfirmedEpochId) (s : ConfirmedEpoch.Reader.StateDto) =
+        ConfirmedCheckpoint.ofEpochContent epochId s.closed s.carts.Length
 
 [<Route("api/[controller]")>]
-type TicketsController(tickets : TicketsIngester.Service, series : TicketsSeries.Service, epochs : TicketsEpoch.Reader.Service) =
+type ConfirmedController(series : ConfirmedSeries.Service, epochs : ConfirmedEpoch.Reader.Service) =
     inherit ControllerBase()
 
-    [<HttpPost; Route "{fc}/{ticket}">]
-    member _.Post(fc : FcId, ticket : TicketId, [<FromBody>] payload) = async {
-        let! _added = tickets.ForFc(fc).TryIngest({ id = ticket; payload = payload})
-        ()
-    }
-
     [<HttpGet>]
-    member _.ListTranches() : Async<TicketsTranchesDto> = async {
-        let! active = series.ReadIngestionEpochs()
-        return { activeEpochs = [| for x in active -> { fc = x.fc; epochId = x.ingestionEpochId } |]}
+    member _.ListTranches() : Async<TranchesDto> = async {
+        let! active = series.ReadIngestionEpochId()
+        return TranchesDto.ofEpochId active
     }
 
-    [<HttpGet; Route("{fcId}/{epoch}")>]
-    member _.ReadTranche(fcId : FcId, epoch : TicketsEpochId) : Async<SliceDto> = async {
-        let! state = epochs.Read(fcId, epoch)
+    [<HttpGet; Route("{epoch}")>]
+    member _.ReadTranche(epoch : ConfirmedEpochId) : Async<SliceDto> = async {
+        let! state = epochs.Read(epoch)
         // TOCONSIDER closed should control cache header
         let pos, checkpoint = Checkpoint.ofEpochAndOffset epoch 0, Checkpoint.ofState epoch state
-        return { closed = state.closed; tickets = Array.map ItemDto.ofDto state.tickets; position = pos; checkpoint = checkpoint }
+        return { closed = state.closed; carts = Array.map CartDto.ofDto state.carts; position = pos; checkpoint = checkpoint }
     }
 
-    [<HttpGet; Route("{fcId}/slice/{token?}")>]
-    member _.Poll(fcId : FcId, token : System.Nullable<TicketsCheckpoint>) : Async<SliceDto> = async {
-        let pos = if token.HasValue then token.Value else TicketsCheckpoint.initial
-        let epochId, offset = TicketsCheckpoint.toEpochAndOffset pos
-        let! state = epochs.Read(fcId, epochId)
+    [<HttpGet; Route("slice/{token?}")>]
+    member _.Poll(token : System.Nullable<ConfirmedCheckpoint>) : Async<SliceDto> = async {
+        let pos = if token.HasValue then token.Value else ConfirmedCheckpoint.initial
+        let epochId, offset = ConfirmedCheckpoint.toEpochAndOffset pos
+        let! state = epochs.Read(epochId)
         // TOCONSIDER closed should control cache header
         let pos, checkpoint = Checkpoint.ofEpochAndOffset epochId offset, Checkpoint.ofState epochId state
-        return { closed = state.closed; tickets = Array.skip offset state.tickets |> Array.map ItemDto.ofDto; position = pos; checkpoint = checkpoint }
+        return { closed = state.closed; carts = Array.skip offset state.carts |> Array.map CartDto.ofDto; position = pos; checkpoint = checkpoint }
     }

Sample/ECommerce.Equinox/ECommerce.Domain/ConfirmedEpoch.fs

@@ -68,12 +68,12 @@ type Service internal
 
     /// Ingest the supplied items. Yields relevant elements of the post-state to enable generation of stats
     /// and facilitate deduplication of incoming items in order to avoid null store round-trips where possible
-    member _.Ingest(epochId, items) =
+    member _.Ingest(epochId, carts) =
         let decider = resolveStale epochId
         /// NOTE decider which will initially transact against potentially stale cached state, which will trigger a
         /// resync if another writer has gotten in before us. This is a conscious decision in this instance; the bulk
         /// of writes are presumed to be coming from within this same process
-        decider.Transact(decide shouldClose items)
+        decider.Transact(decide shouldClose carts)
 
     /// Returns all the items currently held in the stream (Not using AllowStale on the assumption this needs to see updates from other apps)
     member _.Read epochId : Async<Fold.State> =

Sample/ECommerce.Equinox/ECommerce.Domain/Types.fs

@@ -47,6 +47,27 @@ type [<Measure>] confirmedEpochId
 type ConfirmedEpochId = int<confirmedEpochId>
 module ConfirmedEpochId =
     let initial = 0<confirmedEpochId>
-//    let value (value : ConfirmedEpochId) : int = %value
+    let value (value : ConfirmedEpochId) : int = %value
+    let parse (value : int) : ConfirmedEpochId = %value
     let next (value : ConfirmedEpochId) : ConfirmedEpochId = % (%value + 1)
     let toString (value : ConfirmedEpochId) : string = string %value
+
+type [<Measure>] confirmedCheckpoint
+type ConfirmedCheckpoint = int64<confirmedCheckpoint>
+module ConfirmedCheckpoint =
+
+    let initial : ConfirmedCheckpoint = %0L
+    let factor = 1_000_000L
+
+    let ofEpochAndOffset (epoch : ConfirmedEpochId) offset : ConfirmedCheckpoint =
+        int64 (ConfirmedEpochId.value epoch) * factor + int64 offset |> UMX.tag
+
+    let ofEpochContent (epoch : ConfirmedEpochId) isClosed count : ConfirmedCheckpoint =
+        let epoch, offset =
+            if isClosed then ConfirmedEpochId.next epoch, 0
+            else epoch, count
+        ofEpochAndOffset epoch offset
+
+    let toEpochAndOffset (value : ConfirmedCheckpoint) : ConfirmedEpochId * int =
+        let d, r = Math.DivRem(%value, factor)
+        (ConfirmedEpochId.parse (int d)), int r