, "format"

import Effect.Class as EC

import Effect.Class.Console (log)

import Aftok.Types (System)

import Effect.Class.Console (log)

  .  EC.MonadEffect m 
  => Capability m 

  .  Monad m
  => System m
  -> Capability m 

component caps = H.mkComponent

component system caps = H.mkComponent

        EC.liftEffect $ WE.preventDefault ev

        lift $ system.preventDefault ev

import Data.UUID (UUID, parseUUID)

import Data.UUID (UUID, parseUUID, toString)

import Aftok.Types (APIError(..), parseDate)

import Aftok.Types (APIError(..), System, parseDate)

import Effect.Class.Console (log, error)

derive instance newtypeProjectId :: Newtype ProjectId _

derive instance projectIdNewtype :: Newtype ProjectId _

pidStr (ProjectId uuid) = show uuid

pidStr (ProjectId uuid) = toString uuid

  .  EC.MonadEffect m
  => Capability m 

  .  Monad m
  => System m
  -> Capability m 

projectListComponent caps = H.mkComponent

projectListComponent console caps = H.mkComponent

            Left _ -> error "Could not retrieve project list."

            Left _ -> lift <<< console.error $ "Could not retrieve project list."

        log $ "Selected project index " <> show i

        lift <<< console.log $ "Selected project index " <> show i

import Control.Monad.Except.Trans (except, withExceptT, runExceptT)

import Control.Monad.Except.Trans (withExceptT, runExceptT)

import Data.Array (cons)

import Data.Array (reverse, filter)

import Data.DateTime (DateTime(..), adjust)
import Data.DateTime.Instant (Instant, unInstant, fromDateTime)

import Data.Date (Date, year, month, day)
import Data.DateTime (DateTime(..), adjust, date)
import Data.DateTime.Instant (Instant, unInstant, fromDateTime, toDateTime)

import Data.Foldable (class Foldable, any, foldMapDefaultR)

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

import Data.Newtype (unwrap)

import Data.Newtype (class Newtype, unwrap)

import Data.Tuple (Tuple(..), fst)

import Type.Proxy (Proxy(..))
-- import Text.Format as F -- (format, zeroFill, width)

import Effect.Now (now, nowDateTime)

import Effect.Now (now)

import Affjax (post, printError)
import Affjax.StatusCode (StatusCode(..))

import Affjax (get, post)

import CSS (backgroundColor, border, rgb, solid, borderRadius, left)

import CSS (backgroundColor, clear, clearBoth, border, rgb, solid, borderRadius, left)

import Aftok.Project (Project, Project'(..), ProjectId(..))
import Aftok.Types (APIError(..), parseDate)

import Aftok.Project (Project, Project'(..), ProjectId(..), pidStr)
import Aftok.Types (APIError, System, JsonCompose, decompose, parseDatedResponse)

import Effect.Class.Console as C

data Event' i
  = StartEvent i
  | StopEvent i

type Interval =
  { start :: Instant
  , end :: Instant

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

  { start   :: Instant

  { bounds  :: Interval

  , end     :: Instant

  , history :: Array Interval

  , history :: M.Map Date (Array Interval)

  | Unexpected String

    Unexpected t -> t

  { logStart :: ProjectId -> m (Either TimelineError Instant)

  { timer :: EventSource m TimelineAction
  , logStart :: ProjectId -> m (Either TimelineError Instant)

  , listIntervals :: ProjectId -> TimeSpan -> m (Either TimelineError (Array Interval))

  :: forall query input output
  .  Capability Aff
  -> Project.Capability Aff
  -> H.Component HH.HTML query input output Aff
component caps pcaps = H.mkComponent

  :: forall query input output m
  .  Monad m
  => System m
  -> Capability m
  -> Project.Capability m
  -> H.Component HH.HTML query input output m
component system caps pcaps = H.mkComponent

      { limits: { start: bottom, current: bottom, end: bottom }
      , history: []

      { limits: { bounds: interval bottom bottom, current: bottom }
      , history: M.empty

    render :: TimelineState -> H.ComponentHTML TimelineAction Slots Aff

    render :: TimelineState -> H.ComponentHTML TimelineAction Slots m

            [HH.text "Today's project timeline"]

            [HH.text "Your project timeline"]

            [HH.slot _projectList unit (Project.projectListComponent pcaps) unit (Just <<< ProjectSelected)]
          ]

            [HH.slot _projectList unit (Project.projectListComponent system pcaps) unit (Just <<< ProjectSelected)]

            [lineHtml (intervalHtml st.limits <$> st.history <> fromMaybe st.active)
            ,HH.div_

            ([HH.div_

                [P.classes (ClassName <$> ["btn", "btn-primary", "float-left"])

                [P.classes (ClassName <$> ["btn", "btn-primary", "float-left", "my-2"])

                [P.classes (ClassName <$> ["btn", "btn-primary", "float-right"])

                [P.classes (ClassName <$> ["btn", "btn-primary", "float-right", "my-2"])

            ]

            , lineHtml $ intervalHtml st.limits.bounds <$> currentHistory st
            ] <> ((\(Tuple d xs) -> dateLine st d xs) <$> priorHistory st))
          ]

    eval :: TimelineAction -> H.HalogenM TimelineState TimelineAction Slots output Aff Unit

    eval :: TimelineAction -> H.HalogenM TimelineState TimelineAction Slots output m Unit

        dt@(DateTime date t) <- liftEffect nowDateTime
        let startOfDay = DateTime date bottom
            endOfDay = adjust (Days 1.0) startOfDay
            startInstant = fromDateTime startOfDay
            limits =
              { start: startInstant
              , current: fromDateTime dt
              , end: maybe startInstant fromDateTime endOfDay
              }
            llen = ilen limits.start limits.end
            clen = ilen limits.start limits.current
        H.put $ { limits : limits
                , history : []

        dt@(DateTime today t) <- lift system.nowDateTime
        H.put $ { limits : { bounds: dateBounds today
                           , current: fromDateTime dt
                           }
                , history : M.empty 

        _ <- H.subscribe timer

        _ <- H.subscribe caps.timer

        H.modify_ (_ { selectedProject = Just p, history = [] })

        timeSpan <- Before <$> lift system.nowDateTime -- FIXME, should come from a form control
        intervals' <- lift $ caps.listIntervals (unwrap p).projectId timeSpan
        let intervals = case intervals' of
             Left err -> [] -- FIXME
             Right ivals -> ivals
        H.modify_ (_ { selectedProject = Just p, history = toHistory intervals })

        t <- liftEffect now

        t <- lift $ system.now

    logStart :: Project -> H.HalogenM TimelineState TimelineAction Slots output Aff Unit

    logStart :: Project -> H.HalogenM TimelineState TimelineAction Slots output m Unit

        Left err -> C.log $ "Failed to start timer: " <> show err

        Left err -> lift <<< system.log $ "Failed to start timer: " <> show err

    logEnd :: Project -> H.HalogenM TimelineState TimelineAction Slots output Aff Unit

    logEnd :: Project -> H.HalogenM TimelineState TimelineAction Slots output m Unit

        Left err -> C.log $ "Failed to stop timer: " <> show err

        Left err -> lift <<< system.log $ "Failed to stop timer: " <> show err

dateBounds :: Date -> Interval
dateBounds date =
  let startOfDay = DateTime date bottom
      endOfDay = adjust (Days 1.0) startOfDay
      startInstant = fromDateTime startOfDay
   in interval startInstant (maybe startInstant fromDateTime endOfDay)
currentHistory 
  :: TimelineState
  -> Array Interval
currentHistory st =
  let currentDate = date $ toDateTime st.limits.current
   in maybe [] identity (M.lookup currentDate st.history) <> fromMaybe st.active
priorHistory 
  :: TimelineState
  -> Array (Tuple Date (Array Interval))
priorHistory st = 
  let currentDate = date $ toDateTime st.limits.current
   in reverse <<< filter (not <<< (currentDate == _) <<< fst) $ M.toUnfoldable st.history
dateLine 
  :: forall action slots m
  .  TimelineState
  -> Date
  -> Array Interval
  -> H.ComponentHTML action slots m
dateLine st d xs =
  HH.div
    []
    [ HH.text $ dateStr d <> ": " <> show (length xs :: Int)
    , lineHtml (intervalHtml (dateBounds d) <$> xs)
    ]
dateStr :: Date -> String
dateStr d = (show <<< fromEnum $ year d) <> "-" 
         <> (show <<< fromEnum $ month d) <> "-" 
         <> (show <<< fromEnum $ day d)

        clear clearBoth

  .  TimelineLimits

  .  Interval

intervalHtml limits i =

intervalHtml (Interval limits) (Interval i) =

data Event i
  = StartEvent i
  | StopEvent i
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')

  s { active = s.active <|> Just { start: t, end: t }

  s { active = s.active <|> Just (interval t t)

  s { history = maybe s.history (\st -> cons { start: st.start, end: t } s.history) s.active

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

    , active = map (_ { end = t }) s.active

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

  result <- post RF.json ("/api/projects/" <> UUID.toString pid <> "/logStart") requestBody
  liftEffect <<< runExceptT $ case result of
    Left err -> throwError <<< LogFailure $ Error { status: Nothing, message: printError err }
    Right r -> case r.status of
      StatusCode 403 -> 
        throwError $ LogFailure Forbidden
      StatusCode 200 -> 
        withExceptT (LogFailure <<< ParseFailure r.body) $ do
          event <- except $ decodeJson r.body
          timeEvent <- traverse parseDate event
          case timeEvent of 
              StartEvent t -> pure $ fromDateTime t
              StopEvent  _ -> throwError $ "Expected start event, got stop."
      other -> 
        throwError <<< LogFailure $ Error { status: Just other, message: r.statusText }

  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."

  result <- post RF.json ("/api/projects/" <> UUID.toString pid <> "/logEnd") requestBody
  liftEffect <<< runExceptT $ case result of
    Left err -> throwError <<< LogFailure $ Error { status: Nothing, message: printError err }
    Right r -> case r.status of
      StatusCode 403 -> 
        throwError $ LogFailure Forbidden
      StatusCode 200 -> 
        withExceptT (LogFailure <<< ParseFailure r.body) $ do
          event <- except $ decodeJson r.body
          timeEvent <- traverse parseDate event
          case timeEvent of 
              StartEvent _ -> throwError $ "Expected stop event, got start."
              StopEvent  t -> pure $ fromDateTime t
      other -> 
        throwError <<< LogFailure $ Error { status: Just other, message: r.statusText }

  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

apiCapability = { logStart: apiLogStart, logEnd: apiLogEnd }

apiCapability = 
  { timer: timer
  , logStart: apiLogStart
  , logEnd: apiLogEnd 
  , listIntervals: apiListIntervals
  }

  { logStart: \_ -> Right <$> liftEffect now

  { timer: timer
  , logStart: \_ -> Right <$> liftEffect now

  , listIntervals: \_ _ -> Right <$> pure []

intervalDate :: Interval -> Date
intervalDate = date <<< toDateTime <<< (_.end) <<< unwrap
toHistory :: Array Interval -> M.Map Date (Array Interval)
toHistory = M.fromFoldableWith (<>) <<< map (\i -> Tuple (intervalDate i) [i])

import Control.Monad.Error.Class (throwError)
import Control.Monad.Except.Trans (ExceptT, except, withExceptT)

import Control.Monad.Except.Trans (ExceptT, except)

import Data.Argonaut.Decode (decodeJson)

import Data.Argonaut.Decode (class DecodeJson, decodeJson)

import Data.Either (note)

import Data.DateTime.Instant (Instant, fromDateTime)
import Data.Functor.Compose (Compose(..))
import Data.Either (Either(..), note)
import Data.Foldable (class Foldable, foldr, foldl, foldMap)

import Data.Maybe (Maybe)

import Data.Maybe (Maybe(..))
import Data.Newtype (class Newtype, unwrap, over)
import Data.Traversable (class Traversable, traverse)

import Affjax.StatusCode (StatusCode)

import Effect.Aff (Aff)
import Effect.Class (liftEffect)
import Effect.Now (now, nowDateTime)
import Affjax as AJAX
import Affjax (Response, printError)
import Affjax.StatusCode (StatusCode(..))
import Effect.Class.Console as C
import Web.Event.Event as WE

type System m =
  { log :: String -> m Unit
  , error :: String -> m Unit
  , now :: m Instant
  , nowDateTime :: m DateTime
  , preventDefault :: WE.Event -> m Unit
  }
liveSystem :: System Aff
liveSystem = 
  { log: liftEffect <<< C.log
  , error: liftEffect <<< C.error
  , now: liftEffect now
  , nowDateTime: liftEffect nowDateTime
  , preventDefault: liftEffect <<< WE.preventDefault
  }

newtype JsonCompose f g a = JsonCompose (Compose f g a)
derive instance jsonComposeNewtype :: Newtype (JsonCompose f g a) _
instance jsonComposeFunctor :: (Functor f, Functor g) => Functor (JsonCompose f g) where
  map f = over JsonCompose (map f)

instance jsonComposeFoldable :: (Foldable f, Foldable g) => Foldable (JsonCompose f g) where
  foldr f b = foldr f b <<< unwrap
  foldl f b = foldl f b <<< unwrap
  foldMap f = foldMap f <<< unwrap
instance jsonComposeTraversable :: (Traversable f, Traversable g) => Traversable (JsonCompose f g) where
  traverse f = map JsonCompose <<< traverse f <<< unwrap
  sequence = traverse identity
instance jsonComposeDecodeJson :: (DecodeJson (f (g a))) => DecodeJson (JsonCompose f g a) where
  decodeJson json = JsonCompose <<< Compose <$> decodeJson json
decompose :: forall f g a. JsonCompose f g a -> f (g a)
decompose (JsonCompose (Compose fga)) = fga

decodeDatedJson :: forall t. Traversable t => DecodeJson (t String) => Json -> ExceptT String Effect (t DateTime)
decodeDatedJson json = do
  decoded <- except $ decodeJson json
  traverse parseDate decoded

parseDatedResponse 
  :: forall t
  .  Traversable t
  => DecodeJson (t String) 
  => Either AJAX.Error (Response Json) 
  -> ExceptT APIError Effect (t Instant)
parseDatedResponse = case _ of
  Left err -> 
    throwError $ Error { status: Nothing, message: printError err }
  Right r -> case r.status of
    StatusCode 403 -> 
      throwError $ Forbidden
    StatusCode 200 -> 
      withExceptT (ParseFailure r.body) $ map fromDateTime <$> decodeDatedJson r.body
    other -> 
      throwError $ Error { status: Just other, message: r.statusText }

import Effect.Aff (Aff)

import Aftok.Types (System, liveSystem)

      mainComponent = component login timeline project

      mainComponent = component liveSystem login timeline project

  :: forall query input output
  .  Login.Capability Aff
  -> Timeline.Capability Aff
  -> Project.Capability Aff
  -> H.Component HH.HTML query input output Aff
component loginCap tlCap pCap = H.mkComponent 

  :: forall query input output m
  .  Monad m
  => System m
  -> Login.Capability m
  -> Timeline.Capability m
  -> Project.Capability m
  -> H.Component HH.HTML query input output m
component system loginCap tlCap pCap = H.mkComponent 

    render :: MainState -> H.ComponentHTML MainAction Slots Aff

    render :: MainState -> H.ComponentHTML MainAction Slots m

          [ HH.slot _login unit (Login.component loginCap) unit (Just <<< LoginComplete) ]

          [ HH.slot _login unit (Login.component system loginCap) unit (Just <<< LoginComplete) ]

          [ HH.slot _timeline unit (Timeline.component tlCap pCap) unit absurd ]

          [ HH.slot _timeline unit (Timeline.component system tlCap pCap) unit absurd ]

    eval :: MainAction -> H.HalogenM MainState MainAction Slots output Aff Unit

    eval :: MainAction -> H.HalogenM MainState MainAction Slots output m Unit

#!/bin/bash
if [ -f ".env" ]; then
  source .env
fi
if [ -z "${AFTOK_HOST}" ]; then 
  AFTOK_HOST="aftok.com"
fi
if [ -z "${USER}" ]; then 
  read -p "Username: " USER
  echo
fi
if [ -z "${PID}" ]; then
  read -p "Project UUID: " PID
  echo
fi
curl --verbose --insecure --user $USER \
  --request GET \
  "https://$AFTOK_HOST/api/projects/$PID/intervals"

  "https://$AFTOK_HOST/api/projects/$PID/logEnd" 

  "https://$AFTOK_HOST/api/user/projects/$PID/logEnd" 

  "https://$AFTOK_HOST/api/projects/$PID/logStart"

  "https://$AFTOK_HOST/api/user/projects/$PID/logStart"

loggedIntervalsHandler :: S.Handler App App (WorkIndex (NetworkId, Address))
loggedIntervalsHandler = do

projectWorkIndex :: S.Handler App App (WorkIndex (NetworkId, Address))
projectWorkIndex = do

logEntriesHandler :: S.Handler App App [LogEntry (NetworkId, Address)]
logEntriesHandler = do

userLogEntries :: S.Handler App App [LogEntry (NetworkId, Address)]
userLogEntries = do

      "You must at least one of the \"after\" or \"before\" query parameter"

      "You must specify at least one of the \"after\" or \"before\" query parameters"

userWorkIndex :: S.Handler App App (WorkIndex (NetworkId, Address))
userWorkIndex =
  workIndex <$> userLogEntries

    projectRoute = serveJSON projectJSON $ method GET projectGetHandler
    logEntriesRoute =
      serveJSON (fmap $ logEntryJSON nmode) $ method GET logEntriesHandler
    logIntervalsRoute =
      serveJSON (workIndexJSON nmode) $ method GET loggedIntervalsHandler

    projectRoute =
      serveJSON projectJSON $ method GET projectGetHandler
    projectWorkIndexRoute =
      serveJSON (workIndexJSON nmode) $ method GET projectWorkIndex

    payoutsRoute = serveJSON (payoutsJSON nmode) $ method GET payoutsHandler

    projectPayoutsRoute = serveJSON (payoutsJSON nmode) $ method GET payoutsHandler

    logWorkBTCRoute f =
      serveJSON eventIdJSON $ method POST (logWorkBTCHandler f)
    amendEventRoute = serveJSON amendmentIdJSON $ method PUT amendEventHandler

    -- logWorkBTCRoute f =
    --   serveJSON eventIdJSON $ method POST (logWorkBTCHandler f)
    amendEventRoute =
      serveJSON amendmentIdJSON $ method PUT amendEventHandler
    userLogEntriesRoute =
      serveJSON (fmap $ logEntryJSON nmode) $ method GET userLogEntries
    userWorkIndexRoute =
      serveJSON (workIndexJSON nmode) $ method GET userWorkIndex

    , ("projects/:projectId/logStart/:btcAddr", logWorkBTCRoute StartWork)
    , ("projects/:projectId/logEnd/:btcAddr", logWorkBTCRoute StopWork)
    , ("projects/:projectId/logStart"       , logWorkRoute StartWork)
    , ("projects/:projectId/logEnd"         , logWorkRoute StopWork)
    , ("projects/:projectId/logEntries"     , logEntriesRoute)
    , ("projects/:projectId/intervals"      , logIntervalsRoute)
    , ( "projects/:projectId/auctions"
      , auctionCreateRoute
      ) -- <|> auctionListRoute
    , ( "projects/:projectId/billables"
      , billableCreateRoute <|> billableListRoute
      )
    , ("projects/:projectId/payouts", payoutsRoute)
    , ("projects/:projectId/invite" , inviteRoute)
    , ("projects/:projectId"        , projectRoute)
    , ("projects"                   , projectCreateRoute <|> projectListRoute)

    -- , ("projects/:projectId/logStart/:btcAddr" , logWorkBTCRoute StartWork)
    -- , ("projects/:projectId/logEnd/:btcAddr"   , logWorkBTCRoute StopWork)
    , ("user/projects/:projectId/logStart"     , logWorkRoute StartWork)
    , ("user/projects/:projectId/logEnd"       , logWorkRoute StopWork)
    , ("user/projects/:projectId/logEntries"   , userLogEntriesRoute)
    , ("user/projects/:projectId/workIndex"    , userWorkIndexRoute)
    , ("projects/:projectId/workIndex"         , projectWorkIndexRoute)
    , ("projects/:projectId/auctions"  , auctionCreateRoute) -- <|> auctionListRoute)
    , ("projects/:projectId/billables" , billableCreateRoute <|> billableListRoute)
    , ("projects/:projectId/payouts"   , projectPayoutsRoute)
    , ("projects/:projectId/invite"    , inviteRoute)
    , ("projects/:projectId"           , projectRoute)
    , ("projects"                      , projectCreateRoute <|> projectListRoute)