nuttycom/aftok - Change RSF6UAJKG7CEKILSVXI6C4YZXY7PIYZM2EMA2IXKQ7SADKNVSH7QC

Break out api module for timeline.

Created by Kris Nuttycombe on August 22, 2020

RSF6UAJKG7CEKILSVXI6C4YZXY7PIYZM2EMA2IXKQ7SADKNVSH7QC

Dependencies

In channels

main

Change contents

File addition: Api (d--x------)
[3.1]

File addition: Timeline.purs (----------)

[0.1]

module Aftok.Api.Timeline where
import Prelude
import Control.Alt ((<|>))
import Control.Monad.Error.Class (throwError)
import Control.Monad.Except.Trans (withExceptT, runExceptT)
import Data.Argonaut.Decode (class DecodeJson, decodeJson, (.:), (.:?))
import Data.DateTime (DateTime)
import Data.DateTime.Instant (Instant)
import Data.Either (Either, note)
import Data.Foldable (class Foldable, foldMapDefaultR, intercalate, foldr, foldl)
import Data.JSDate as JD
import Data.Maybe (Maybe(..))
import Data.Newtype (class Newtype)
import Data.Traversable (class Traversable, traverse)
import Data.UUID as UUID
import Type.Proxy (Proxy(..))
-- import Text.Format as F -- (format, zeroFill, width)
import Effect.Aff (Aff)
import Effect.Class (liftEffect)
import Affjax (get, post)
import Affjax.RequestBody as RB
import Affjax.ResponseFormat as RF
import Data.Argonaut.Encode (encodeJson)
import Aftok.Project (ProjectId(..), pidStr)
import Aftok.Types (APIError, JsonCompose, decompose, parseDatedResponse)
data TimelineError
  = LogFailure (APIError)
  | Unexpected String
instance showTimelineError :: Show TimelineError where
  show = case _ of
    LogFailure e -> show e
    Unexpected t -> t
data Event' i
  = StartEvent i
  | StopEvent i
type Event = Event' Instant
derive instance eventFunctor :: Functor Event'
instance eventFoldable :: Foldable Event' where
  foldr f b = case _ of
    StartEvent a -> f a b
    StopEvent a -> f a b
  foldl f b = case _ of
    StartEvent a -> f b a
    StopEvent a -> f b a
  foldMap = foldMapDefaultR
instance eventTraversable :: Traversable Event' where
  traverse f = case _ of
    StartEvent a -> StartEvent <$> f a 
    StopEvent a -> StopEvent <$> f a 
  sequence = traverse identity
instance decodeJsonEvent :: DecodeJson (Event' String) where
  decodeJson json = do
    obj <- decodeJson json
    event <- obj .: "event"
    start' <- traverse (_ .: "eventTime") =<< event .:? "start"
    stop' <-  traverse (_ .: "eventTime") =<< event .:? "stop"
    note "Only 'stop' and 'start' events are supported." $ (StartEvent <$> start') <|> (StopEvent <$> stop')
newtype Interval' i = Interval
  { start :: i
  , end :: i
  }
derive instance intervalEq :: (Eq i) => Eq (Interval' i)
derive instance intervalNewtype :: Newtype (Interval' i) _
type Interval = Interval' Instant
derive instance intervalFunctor :: Functor Interval'
instance intervalFoldable :: Foldable Interval' where
  foldr f b (Interval i) = f i.start (f i.end b) 
  foldl f b (Interval i) = f (f b i.start) i.end 
  foldMap = foldMapDefaultR
instance intervalTraversable :: Traversable Interval' where
  traverse f (Interval i) = interval <$> f i.start <*> f i.end 
  sequence = traverse identity
instance decodeJsonInterval :: DecodeJson (Interval' String) where
  decodeJson json = do
    obj <- decodeJson json
    interval <$> obj .: "start" <*> obj .: "end"
interval :: forall i. i -> i -> Interval' i
interval s e = Interval { start: s, end: e }
data TimeSpan' t
  = Before t
  | During (Interval' t)
  | After t
type TimeSpan = TimeSpan' DateTime
derive instance timeSpanFunctor :: Functor TimeSpan'
instance timeSpanFoldable :: Foldable TimeSpan' where
  foldr f b = case _ of
    Before a -> f a b
    During x -> foldr f b x
    After  a -> f a b
  foldl f b = case _ of
    Before a -> f b a
    During x -> foldl f b x
    After  a -> f b a
  foldMap = foldMapDefaultR
instance timeSpanTraversable :: Traversable TimeSpan' where
  traverse f = case _ of
    Before a -> Before <$> f a
    During x -> During <$> traverse f x
    After  a -> After <$> f a
  sequence = traverse identity
apiLogStart :: ProjectId -> Aff (Either TimelineError Instant)
apiLogStart (ProjectId pid) = do
  let requestBody = Just <<< RB.Json <<< encodeJson $ { schemaVersion: "2.0" }
  response <- post RF.json ("/api/user/projects/" <> UUID.toString pid <> "/logStart") requestBody
  liftEffect <<< runExceptT $ do
    event <- withExceptT LogFailure $ parseDatedResponse response
    case event of 
      StartEvent t -> pure t
      StopEvent  _ -> throwError <<< Unexpected $ "Expected start event, got stop."
apiLogEnd :: ProjectId -> Aff (Either TimelineError Instant)
apiLogEnd (ProjectId pid) = do
  let requestBody = Just <<< RB.Json <<< encodeJson $ { schemaVersion: "2.0" }
  response <- post RF.json ("/api/user/projects/" <> UUID.toString pid <> "/logEnd") requestBody
  liftEffect <<< runExceptT $ do
    event <- withExceptT LogFailure $ parseDatedResponse response
    case event of
      StartEvent _ -> throwError <<< Unexpected $ "Expected stop event, got start."
      StopEvent  t -> pure t
newtype ListIntervalsResponse a = ListIntervalsResponse
  { workIndex :: Array ({ intervals :: Array a }) 
  }
derive instance listIntervalsResponseNewtype :: Newtype (ListIntervalsResponse a) _
derive instance listIntervalsResponseFunctor :: Functor ListIntervalsResponse
instance listIntervalsResponseFoldable :: Foldable ListIntervalsResponse where
  foldr f b (ListIntervalsResponse r) = foldr f b (r.workIndex >>= _.intervals)
  foldl f b (ListIntervalsResponse r) = foldl f b (r.workIndex >>= _.intervals)
  foldMap = foldMapDefaultR
instance listIntervalsResponseTraversable :: Traversable ListIntervalsResponse where
  traverse f (ListIntervalsResponse r) = 
    let traverseCreditRow r' = ({ intervals: _ }) <$> traverse f r'.intervals
     in (ListIntervalsResponse <<< ({ workIndex: _ })) <$> traverse traverseCreditRow r.workIndex
  sequence = traverse identity
instance listIntervalsResponseDecodeJson :: DecodeJson a => DecodeJson (ListIntervalsResponse a) where
  decodeJson = map ListIntervalsResponse <<< decodeJson
_ListIntervalsResponse :: Proxy (JsonCompose ListIntervalsResponse Interval' String)
_ListIntervalsResponse = Proxy
apiListIntervals :: ProjectId -> TimeSpan -> Aff (Either TimelineError (Array Interval))
apiListIntervals pid ts = do
  ts' <- liftEffect $ traverse (JD.toISOString <<< JD.fromDateTime) ts
  let queryElements = case ts' of
        Before t -> ["before=" <> t]
        During (Interval x) -> ["after=" <> x.start, "before=" <> x.end]
        After  t -> ["after=" <> t]
  response <- get RF.json ("/api/user/projects/" <> pidStr pid <> "/workIndex?" <> intercalate "&" queryElements)
  liftEffect 
    <<< runExceptT 
    <<< map (\(ListIntervalsResponse r) -> r.workIndex >>= (_.intervals))
    <<< map decompose
    <<< withExceptT LogFailure 
      $ parseDatedResponse response

Deletion in client/src/Aftok/Timeline.purs at line 6 [4.2287]
B:BD[4.2520] → [5.201:247]
B:BD[5.247] → [2.662:722]
```
import Control.Monad.Error.Class (throwError)
import Control.Monad.Except.Trans (withExceptT, runExceptT)
```
Deletion in client/src/Aftok/Timeline.purs at line 10 [4.2287]
∅:D[2.759] → [5.316:388]
B:BD[4.2546] → [5.316:388]
```
import Data.Argonaut.Decode (class DecodeJson, decodeJson, (.:), (.:?))
```
Replacement in client/src/Aftok/Timeline.purs at line 13 [4.2287]
∅:D[2.928] → [5.389:427]
B:BD[4.2739] → [5.389:427]
```
import Data.Either (Either(..), note)
```
[2.928]
[2.929]
```
import Data.Either (Either(..))
```

Replacement in client/src/Aftok/Timeline.purs at line 15 [4.2287]

B:BD[2.957] → [2.957:1077]

import Data.Foldable (class Foldable, any, foldMapDefaultR, intercalate, foldr, foldl, length)
import Data.JSDate as JD

[2.957]

[2.1077]

import Data.Foldable (any, length)

Replacement in client/src/Aftok/Timeline.purs at line 18 [4.2287]
B:BD[6.1054] → [2.1099:1143]
```
import Data.Newtype (class Newtype, unwrap)
```
[6.1054]
[7.2539]
```
import Data.Newtype (unwrap)
```
Replacement in client/src/Aftok/Timeline.purs at line 21 [4.2287]
B:BD[7.2626] → [5.488:553]
```
import Data.Traversable (class Traversable, traverse_, traverse)
```
[7.2626]
[2.1144]
```
import Data.Traversable (traverse_)
```
Deletion in client/src/Aftok/Timeline.purs at line 24 [4.2287]
B:BD[8.80] → [7.2663:2688]
```
import Data.UUID as UUID
```
Deletion in client/src/Aftok/Timeline.purs at line 25 [4.2287]
B:BD[4.2922] → [2.1180:1210]
```
import Type.Proxy (Proxy(..))
```
Deletion in client/src/Aftok/Timeline.purs at line 32 [4.2287]
∅:D[2.1291] → [4.3035:3036]
∅:D[9.301530] → [4.3035:3036]
B:BD[4.3035] → [4.3035:3036]
B:BD[4.3036] → [2.1292:1318]
∅:D[2.1318] → [7.2764:2873]
B:BD[7.2764] → [7.2764:2873]
```
import Affjax (get, post)
import Affjax.RequestBody as RB
import Affjax.ResponseFormat as RF
import Data.Argonaut.Encode (encodeJson)
```

Insertion in client/src/Aftok/Timeline.purs at line 48 [4.2287]

[9.301880]

[7.2875]

import Aftok.Api.Timeline as TL
import Aftok.Api.Timeline (TimelineError, Interval'(..), Interval, TimeSpan)

Replacement in client/src/Aftok/Timeline.purs at line 51 [4.2287]

B:BD[7.2907] → [2.1407:1557]

∅:D[5.599] → [7.3001:3002]

∅:D[2.1557] → [7.3001:3002]

B:BD[7.3001] → [7.3001:3002]

B:BD[7.3002] → [2.1558:1605]

∅:D[5.633] → [4.3220:3221]

∅:D[2.1605] → [4.3220:3221]

∅:D[7.3036] → [4.3220:3221]

∅:D[9.301927] → [4.3220:3221]

B:BD[4.3220] → [4.3220:3221]

B:BD[4.3221] → [2.1606:2534]

∅:D[2.2534] → [4.3278:3282]

B:BD[4.3278] → [4.3278:3282]

B:BD[4.3282] → [2.2535:3080]

import Aftok.Project (Project, Project'(..), ProjectId(..), pidStr)
import Aftok.Types (APIError, System, JsonCompose, decompose, parseDatedResponse)
data Event' i
  = StartEvent i
  | StopEvent i
type Event = Event' Instant
derive instance eventFunctor :: Functor Event'
instance eventFoldable :: Foldable Event' where
  foldr f b = case _ of
    StartEvent a -> f a b
    StopEvent a -> f a b
  foldl f b = case _ of
    StartEvent a -> f b a
    StopEvent a -> f b a
  foldMap = foldMapDefaultR
instance eventTraversable :: Traversable Event' where
  traverse f = case _ of
    StartEvent a -> StartEvent <$> f a 
    StopEvent a -> StopEvent <$> f a 
  sequence = traverse identity
instance decodeJsonEvent :: DecodeJson (Event' String) where
  decodeJson json = do
    obj <- decodeJson json
    event <- obj .: "event"
    start' <- traverse (_ .: "eventTime") =<< event .:? "start"
    stop' <-  traverse (_ .: "eventTime") =<< event .:? "stop"
    note "Only 'stop' and 'start' events are supported." $ (StartEvent <$> start') <|> (StopEvent <$> stop')
newtype Interval' i = Interval
  { start :: i
  , end :: i
  }
derive instance intervalEq :: (Eq i) => Eq (Interval' i)
derive instance intervalNewtype :: Newtype (Interval' i) _
type Interval = Interval' Instant
derive instance intervalFunctor :: Functor Interval'
instance intervalFoldable :: Foldable Interval' where
  foldr f b (Interval i) = f i.start (f i.end b) 
  foldl f b (Interval i) = f (f b i.start) i.end 
  foldMap = foldMapDefaultR
instance intervalTraversable :: Traversable Interval' where
  traverse f (Interval i) = interval <$> f i.start <*> f i.end 
  sequence = traverse identity

[7.2907]

[2.3080]

import Aftok.Project (Project, Project'(..), ProjectId)
import Aftok.Types (System)

Deletion in client/src/Aftok/Timeline.purs at line 54 [4.2287]

B:BD[2.3081] → [2.3081:3987]

∅:D[2.3987] → [4.3282:3283]

B:BD[4.3282] → [4.3282:3283]

instance decodeJsonInterval :: DecodeJson (Interval' String) where
  decodeJson json = do
    obj <- decodeJson json
    interval <$> obj .: "start" <*> obj .: "end"
interval :: forall i. i -> i -> Interval' i
interval s e = Interval { start: s, end: e }
data TimeSpan' t
  = Before t
  | During (Interval' t)
  | After t
type TimeSpan = TimeSpan' DateTime
derive instance timeSpanFunctor :: Functor TimeSpan'
instance timeSpanFoldable :: Foldable TimeSpan' where
  foldr f b = case _ of
    Before a -> f a b
    During x -> foldr f b x
    After  a -> f a b
  foldl f b = case _ of
    Before a -> f b a
    During x -> foldl f b x
    After  a -> f b a
  foldMap = foldMapDefaultR
instance timeSpanTraversable :: Traversable TimeSpan' where
  traverse f = case _ of
    Before a -> Before <$> f a
    During x -> During <$> traverse f x
    After  a -> After <$> f a
  sequence = traverse identity

Deletion in client/src/Aftok/Timeline.purs at line 73 [4.2287]
B:BD[4.3626] → [7.3112:3157]
B:BD[7.3157] → [2.4057:4079]
∅:D[2.4079] → [5.634:736]
B:BD[7.3157] → [5.634:736]
B:BD[5.736] → [2.4080:4102]
∅:D[5.736] → [7.3157:3158]
∅:D[2.4102] → [7.3157:3158]
B:BD[7.3157] → [7.3157:3158]
```
data TimelineError
  = LogFailure (APIError)
  | Unexpected String
instance showTimelineError :: Show TimelineError where
  show = case _ of
    LogFailure e -> show e
    Unexpected t -> t
```

Replacement in client/src/Aftok/Timeline.purs at line 105 [4.2287]

B:BD[6.1336] → [2.4492:4560]

      { limits: { bounds: interval bottom bottom, current: bottom }

[6.1336]

[2.4560]

      { limits: { bounds: TL.interval bottom bottom, current: bottom }

Replacement in client/src/Aftok/Timeline.purs at line 165 [4.2287]

B:BD[6.2652] → [2.5549:5646]

        timeSpan <- Before <$> lift system.nowDateTime -- FIXME, should come from a form control

[6.2652]

[2.5646]

        timeSpan <- TL.Before <$> lift system.nowDateTime -- FIXME, should come from a form control

Replacement in client/src/Aftok/Timeline.purs at line 203 [4.2287]

B:BD[2.6469] → [2.6469:6540]

   in interval startInstant (maybe startInstant fromDateTime endOfDay)

[2.6469]

[2.6540]

   in TL.interval startInstant (maybe startInstant fromDateTime endOfDay)

Replacement in client/src/Aftok/Timeline.purs at line 287 [4.2287]
B:BD[6.3520] → [2.7524:7572]
```
  s { active = s.active <|> Just (interval t t)
```
[6.3520]
[9.305818]
```
  s { active = s.active <|> Just (TL.interval t t)
```

Replacement in client/src/Aftok/Timeline.purs at line 294 [4.2287]

B:BD[2.7615] → [2.7615:7701]

        (\i -> M.unionWith (<>) (toHistory [interval (unwrap i).start t]) s.history)

[2.7615]

[2.7701]

        (\i -> M.unionWith (<>) (toHistory [TL.interval (unwrap i).start t]) s.history)

Replacement in client/src/Aftok/Timeline.purs at line 302 [4.2287]

B:BD[8.1387] → [2.7719:7785]

    , active = map (\(Interval i) -> interval i.start t) s.active

[8.1387]

[9.306012]

    , active = map (\(Interval i) -> TL.interval i.start t) s.active

Deletion in client/src/Aftok/Timeline.purs at line 310 [4.2287]

B:BD[4.6890] → [6.3613:3709]

∅:D[6.3709] → [7.6092:6171]

B:BD[7.6092] → [7.6092:6171]

B:BD[7.6171] → [2.7786:8116]

∅:D[5.2588] → [7.6622:6623]

∅:D[2.8116] → [7.6622:6623]

B:BD[7.6622] → [7.6622:6623]

B:BD[7.6623] → [6.3710:3802]

∅:D[6.3802] → [7.6709:6788]

B:BD[7.6709] → [7.6709:6788]

B:BD[7.6788] → [2.8117:10282]

∅:D[5.3240] → [7.7237:7238]

∅:D[2.10282] → [7.7237:7238]

B:BD[7.7237] → [7.7237:7238]

apiLogStart :: ProjectId -> Aff (Either TimelineError Instant)
apiLogStart (ProjectId pid) = do
  let requestBody = Just <<< RB.Json <<< encodeJson $ { schemaVersion: "2.0" }
  response <- post RF.json ("/api/user/projects/" <> UUID.toString pid <> "/logStart") requestBody
  liftEffect <<< runExceptT $ do
    event <- withExceptT LogFailure $ parseDatedResponse response
    case event of 
      StartEvent t -> pure t
      StopEvent  _ -> throwError <<< Unexpected $ "Expected start event, got stop."
apiLogEnd :: ProjectId -> Aff (Either TimelineError Instant)
apiLogEnd (ProjectId pid) = do
  let requestBody = Just <<< RB.Json <<< encodeJson $ { schemaVersion: "2.0" }
  response <- post RF.json ("/api/user/projects/" <> UUID.toString pid <> "/logEnd") requestBody
  liftEffect <<< runExceptT $ do
    event <- withExceptT LogFailure $ parseDatedResponse response
    case event of
      StartEvent _ -> throwError <<< Unexpected $ "Expected stop event, got start."
      StopEvent  t -> pure t
newtype ListIntervalsResponse a = ListIntervalsResponse
  { workIndex :: Array ({ intervals :: Array a }) 
  }
derive instance listIntervalsResponseNewtype :: Newtype (ListIntervalsResponse a) _
derive instance listIntervalsResponseFunctor :: Functor ListIntervalsResponse
instance listIntervalsResponseFoldable :: Foldable ListIntervalsResponse where
  foldr f b (ListIntervalsResponse r) = foldr f b (r.workIndex >>= _.intervals)
  foldl f b (ListIntervalsResponse r) = foldl f b (r.workIndex >>= _.intervals)
  foldMap = foldMapDefaultR
instance listIntervalsResponseTraversable :: Traversable ListIntervalsResponse where
  traverse f (ListIntervalsResponse r) = 
    let traverseCreditRow r' = ({ intervals: _ }) <$> traverse f r'.intervals
     in (ListIntervalsResponse <<< ({ workIndex: _ })) <$> traverse traverseCreditRow r.workIndex
  sequence = traverse identity
instance listIntervalsResponseDecodeJson :: DecodeJson a => DecodeJson (ListIntervalsResponse a) where
  decodeJson = map ListIntervalsResponse <<< decodeJson
_ListIntervalsResponse :: Proxy (JsonCompose ListIntervalsResponse Interval' String)
_ListIntervalsResponse = Proxy
apiListIntervals :: ProjectId -> TimeSpan -> Aff (Either TimelineError (Array Interval))
apiListIntervals pid ts = do
  ts' <- liftEffect $ traverse (JD.toISOString <<< JD.fromDateTime) ts
  let queryElements = case ts' of
        Before t -> ["before=" <> t]
        During (Interval x) -> ["after=" <> x.start, "before=" <> x.end]
        After  t -> ["after=" <> t]
  response <- get RF.json ("/api/user/projects/" <> pidStr pid <> "/workIndex?" <> intercalate "&" queryElements)
  liftEffect 
    <<< runExceptT 
    <<< map (\(ListIntervalsResponse r) -> r.workIndex >>= (_.intervals))
    <<< map decompose
    <<< withExceptT LogFailure 
      $ parseDatedResponse response

Replacement in client/src/Aftok/Timeline.purs at line 313 [4.2287]

B:BD[2.10317] → [2.10317:10402]

  , logStart: apiLogStart
  , logEnd: apiLogEnd 
  , listIntervals: apiListIntervals

[2.10317]

[2.10402]

  , logStart: TL.apiLogStart
  , logEnd: TL.apiLogEnd 
  , listIntervals: TL.apiListIntervals

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 400 [11.456]

B:BD[10.1002] → [10.1002:1102]

∅:D[10.1102] → [12.11913:12004]

∅:D[13.20358] → [12.11913:12004]

B:BD[12.11913] → [12.11913:12004]

∅:D[12.12004] → [14.16287:16361]

B:BD[14.16287] → [14.16287:16361]

                     credit_to_network, credit_to_address, credit_to_user_id, credit_to_project_id,
                     event_type, event_time, event_metadata
              FROM work_events
              WHERE project_id = ? AND user_id = ? AND event_time >= ? |]

[10.1002]

[13.20359]

                   credit_to_network, credit_to_address, credit_to_user_id, credit_to_project_id,
                   event_type, event_time, event_metadata
            FROM work_events
            WHERE project_id = ? AND user_id = ? AND event_time >= ? |]

Insertion in lib/Aftok/Database/PostgreSQL.hs at line 406 [11.456]

[12.12014]

[15.1951]


pgEval (FindLatestEvents (ProjectId pid) (UserId uid) i) = do
  mode <- askNetworkMode
  pquery
    (logEntryParser mode)
    [sql| SELECT credit_to_type,
                 credit_to_network, credit_to_address, credit_to_user_id, credit_to_project_id,
                 event_type, event_time, event_metadata
          FROM work_events
          WHERE project_id = ?
          AND user_id = ?
          ORDER BY event_time DESC
          LIMIT ?|]
    (pid, uid, i)

Insertion in lib/Aftok/Database.hs at line 61 [16.4936]

[13.27304]

  FindLatestEvents ::ProjectId -> UserId -> Int -> DBOp [LogEntry BTCNet]

Insertion in lib/Aftok/Database.hs at line 224 [16.4936]

[17.8899]

[18.1303]


findLatestEvents :: (MonadDB m) => ProjectId -> UserId -> Int -> m [LogEntry BTCNet]
findLatestEvents p u i = liftdb $ FindLatestEvents p u i

Deletion in server/Aftok/Snaplet/Util.hs at line 2 [20.4207]
∅:D[19.2709] → [20.4243:4244]
B:BD[20.4243] → [20.4243:4244]

Insertion in server/Aftok/Snaplet/Util.hs at line 3 [20.4207]

[20.4267]

[21.5709]

import           Data.Attoparsec.ByteString     (parseOnly)
import           Data.Attoparsec.ByteString.Char8     (decimal)

Insertion in server/Aftok/Snaplet/Util.hs at line 19 [20.4207]

[20.4619]

decimalParam :: (Integral i, MonadSnap m) => ByteString -> m (Maybe i)
decimalParam k = runMaybeT $ do
  bs <- MaybeT $ getParam k
  MaybeT . pure . either (const Nothing) Just $ parseOnly decimal bs

Insertion in server/Aftok/Snaplet/WorkLog.hs at line 101 [22.5424]

[20.5386]

[2.15051]

userLatestEntries :: S.Handler App App [LogEntry (NetworkId, Address)]
userLatestEntries = do
  uid       <- requireUserId
  pid       <- requireProjectId
  limit     <- fromMaybe 1 <$> decimalParam "limit"
  snapEval $ findLatestEvents pid uid limit

Insertion in server/Main.hs at line 75 [24.5188]

[2.15343]

[23.2549]

    projectPayoutsRoute =
      serveJSON (payoutsJSON nmode) $ method GET payoutsHandler

Deletion in server/Main.hs at line 78 [24.5188]
B:BD[23.2550] → [2.15344:15428]
∅:D[23.2613] → [18.2569:2570]
∅:D[25.2979] → [18.2569:2570]
∅:D[20.3485] → [18.2569:2570]
∅:D[26.7960] → [18.2569:2570]
∅:D[2.15428] → [18.2569:2570]
∅:D[27.26983] → [18.2569:2570]
∅:D[14.39611] → [18.2569:2570]
∅:D[13.63767] → [18.2569:2570]
B:BD[18.2569] → [18.2569:2570]
```
    projectPayoutsRoute = serveJSON (payoutsJSON nmode) $ method GET payoutsHandler
```

Replacement in server/Main.hs at line 91 [24.5188]

B:BD[13.64102] → [13.64102:64251]

    auctionRoute    = serveJSON auctionJSON $ method GET auctionGetHandler
    auctionBidRoute = serveJSON bidIdJSON $ method POST auctionBidHandler

[13.64102]

[28.321]

    auctionRoute    =
      serveJSON auctionJSON $ method GET auctionGetHandler
    auctionBidRoute =
      serveJSON bidIdJSON $ method POST auctionBidHandler

Break out api module for timeline.

Dependencies

In channels

Change contents

File addition: Api (d--x------)

File addition: Timeline.purs (----------)

Deletion in client/src/Aftok/Timeline.purs at line 6 [4.2287]

Deletion in client/src/Aftok/Timeline.purs at line 10 [4.2287]

Replacement in client/src/Aftok/Timeline.purs at line 13 [4.2287]

Replacement in client/src/Aftok/Timeline.purs at line 15 [4.2287]

Replacement in client/src/Aftok/Timeline.purs at line 18 [4.2287]

Replacement in client/src/Aftok/Timeline.purs at line 21 [4.2287]

Deletion in client/src/Aftok/Timeline.purs at line 24 [4.2287]

Deletion in client/src/Aftok/Timeline.purs at line 25 [4.2287]

Deletion in client/src/Aftok/Timeline.purs at line 32 [4.2287]