nuttycom/aftok - Change 73NDXDEZRMK672GHSTC3CI6YHXFZ2GGJI5IKQGHKFDZKTNSQXLLQC

Begin implementation of billing event persistence.

Created by Kris Nuttycombe on January 19, 2017

73NDXDEZRMK672GHSTC3CI6YHXFZ2GGJI5IKQGHKFDZKTNSQXLLQC

Dependencies

In channels

main

Change contents

Replacement in lib/Aftok/Billables.hs at line 7 [3.760]

B:BD[3.857] → [3.857:914]

import           Control.Lens               (makeLenses)

[3.857]

[3.914]

import           Control.Lens               (makeLenses, makePrisms)

Insertion in lib/Aftok/Billables.hs at line 11 [3.760]

[3.981]

import           Aftok.Project (ProjectId)
import           Aftok (UserId)
import           Aftok.Types (Satoshi)

Replacement in lib/Aftok/Billables.hs at line 16 [3.760]
B:BD[3.1039] → [3.1039:1040]
[3.1039]
[3.1040]
```
makePrisms ''BillableId
```
Replacement in lib/Aftok/Billables.hs at line 18 [3.760]
B:BD[3.1041] → [3.1041:1064]
```
data BillingFrequency 
```
[3.1041]
[3.1064]
```
data Recurrence
```

Deletion in lib/Aftok/Billables.hs at line 23 [3.760]

B:BD[3.1124] → [3.1124:1221]

makeLenses ''BillingFrequency
data Recurrence
  = Recurring { _frequency :: BillingFrequency }

Replacement in lib/Aftok/Billables.hs at line 26 [3.760]

B:BD[3.1261] → [3.1261:1304]

data Billable (p :: *) (c :: *) = Billable

[3.1261]

[3.1304]

recurrenceName :: Recurrence -> Text
recurrenceName Annually  = "annually"
recurrenceName (Monthly _) = "monthly"
recurrenceName SemiMonthly = "semimonthly"
recurrenceName (Weekly _)  = "weekly"
recurrenceName OneTime   = "onetime"
recurrenceCount :: Recurrence -> Maybe Int
recurrenceCount Annually = Nothing
recurrenceCount (Monthly i) = Just i
recurrenceCount SemiMonthly = Nothing
recurrenceCount (Weekly i)  = Just i
recurrenceCount OneTime  = Nothing
data Billable' (p :: *) (u :: *) (c :: *) = Billable

Insertion in lib/Aftok/Billables.hs at line 42 [3.760]
[3.1322]
[3.1322]
```
  , _creator :: u
```
Replacement in lib/Aftok/Billables.hs at line 49 [3.760]
B:BD[3.1441] → [3.1441:1463]
```
makeLenses ''Billable
```
[3.1441]
[3.1463]
```
makeLenses ''Billable'
type Billable = Billable' ProjectId UserId Satoshi
```
Replacement in lib/Aftok/Billables.hs at line 53 [3.760]
B:BD[3.1464] → [3.1464:1492]
```
monthly :: BillingFrequency
```
[3.1464]
[3.1492]
```
monthly :: Recurrence
```
Replacement in lib/Aftok/Billables.hs at line 56 [3.760]
B:BD[3.1513] → [3.1513:1543]
```
bimonthly :: BillingFrequency
```
[3.1513]
[3.1543]
```
bimonthly :: Recurrence
```
Replacement in lib/Aftok/Billables.hs at line 59 [3.760]
B:BD[3.1566] → [3.1566:1596]
```
quarterly :: BillingFrequency
```
[3.1566]
[3.1596]
```
quarterly :: Recurrence
```
Replacement in lib/Aftok/Billables.hs at line 62 [3.760]
B:BD[3.1619] → [3.1619:1653]
```
seminannually :: BillingFrequency
```
[3.1619]
[3.1653]
```
seminannually :: Recurrence
```
Replacement in lib/Aftok/Billables.hs at line 65 [3.760]
B:BD[3.1680] → [3.1680:1709]
```
annually :: BillingFrequency
```
[3.1680]
[3.1709]
```
annually :: Recurrence
```

Insertion in lib/Aftok/Billables.hs at line 68 [3.760]

[3.1730]

newtype SubscriptionId = SubscriptionId UUID deriving (Show, Eq)

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 17 [5.456]
B:BD[4.1453] → [3.1772:1827]
```
import           Database.PostgreSQL.Simple.FromField 
```
[4.1453]
[4.1507]
```
import           Database.PostgreSQL.Simple.FromField
```

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 24 [5.456]

B:BD[4.1583] → [6.476:535]

import           Aftok.Auction                        as A

[4.1583]

[4.1614]

import qualified Aftok.Auction                        as A
import qualified Aftok.Billables                      as BI

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 28 [5.456]

B:BD[4.1678] → [6.536:595]

import           Aftok.Project                        as P

[4.1678]

import qualified Aftok.Project                        as P
import           Aftok.Time                           (Days(..), _Days)

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 45 [5.456]

B:BD[5.1290] → [7.4:83]

pidParser :: FieldParser ProjectId
pidParser f v = ProjectId <$> fromField f v

[5.1290]

[7.83]

pidParser :: FieldParser P.ProjectId
pidParser f v = P.ProjectId <$> fromField f v

Insertion in lib/Aftok/Database/PostgreSQL.hs at line 77 [5.456]

[8.114]

recurrenceParser :: RowParser BI.Recurrence
recurrenceParser =
  let prec :: Text -> RowParser BI.Recurrence
      prec "annually" = nullField *> pure BI.Annually
      prec "monthly"  = BI.Monthly <$> field
      prec "semimonthly" = nullField *> pure BI.SemiMonthly
      prec "weekly"   = BI.Weekly <$> field
      prec "onetime"  = nullField *> pure BI.OneTime
      prec _ = empty
  in  field >>= prec

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 91 [5.456]

B:BD[8.213] → [8.213:243]

B:BD[8.243] → [3.2364:2765]

∅:D[3.2765] → [8.533:607]

B:BD[8.533] → [8.533:607]

B:BD[8.607] → [3.2766:3131]

∅:D[3.3131] → [8.863:892]

B:BD[8.863] → [8.863:892]

  case tn of
    "event_t" ->
      let err = UnexpectedNull { errSQLType = B.unpack tn
                               , errSQLTableOid = tableOid f
                               , errSQLField = maybe "" B.unpack (name f)
                               , errHaskellType = "UTCTime -> LogEvent"
                               , errMessage = "columns of type event_t should not contain null values"
                               }
      in  maybe (conversionError err) (nameEvent . decodeUtf8) v
    _ ->
      let err = Incompatible { errSQLType = B.unpack tn
                             , errSQLTableOid = tableOid f
                             , errSQLField = maybe "" B.unpack (name f)
                             , errHaskellType = "UTCTime -> LogEvent"
                             , errMessage = "column was not of type event_t"
                             }
      in conversionError err

[8.213]

[9.271]

  if tn /= "event_t"
    then returnError Incompatible f "column was not of type event_t"
    else maybe (returnError UnexpectedNull f "event type may not be null") (nameEvent . decodeUtf8) v

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 96 [5.456]

B:BD[8.944] → [8.944:1043]

B:BD[8.1043] → [6.596:638]

∅:D[6.638] → [8.1086:1409]

B:BD[8.1086] → [8.1086:1409]

creditToParser f v = do
  tn <- typename f
  let parser :: Text -> Conversion (RowParser CreditTo)
      parser tname = pure $ case tname of
        "credit_to_btc_addr" -> CreditToAddress <$> (fieldWith btcAddrParser <* nullField <* nullField)
        "credit_to_user"     -> CreditToUser    <$> (nullField *> fieldWith uidParser <* nullField)
        "credit_to_project"  -> CreditToProject <$> (nullField *> nullField *> fieldWith pidParser)
        _ -> empty

[8.944]

[8.1409]

creditToParser f v =   
  let parser :: Text -> RowParser CreditTo
      parser "credit_to_btc_addr" = CreditToAddress <$> (fieldWith btcAddrParser <* nullField <* nullField)
      parser "credit_to_user"     = CreditToUser    <$> (nullField *> fieldWith uidParser <* nullField)
      parser "credit_to_project"  = CreditToProject <$> (nullField *> nullField *> fieldWith pidParser)
      parser _ = empty
  in do
    tn <- typename f
    if tn /= "credit_to_t" 
      then returnError Incompatible f "column was not of type credit_to_t"
      else maybe empty (pure . parser . decodeUtf8) v

Deletion in lib/Aftok/Database/PostgreSQL.hs at line 108 [5.456]

B:BD[8.1410] → [8.1410:1480]

B:BD[8.1480] → [6.639:685]

∅:D[6.685] → [8.1528:1679]

B:BD[8.1528] → [8.1528:1679]

B:BD[8.1679] → [6.686:687]

∅:D[6.687] → [8.1682:1683]

B:BD[8.1682] → [8.1682:1683]

  case tn of
    "credit_to_t" -> maybe empty (parser . decodeUtf8) v
    _ -> conversionError $
      Incompatible
        (B.unpack tn)
        (tableOid f)
        (maybe "" B.unpack (name f))
        "RowParser CreditTo"
        "column was not of type event_t"

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 120 [5.456]
∅:D[4.2022] → [10.617:652]
B:BD[10.617] → [10.617:652]
```
auctionParser :: RowParser Auction
```
[4.2022]
[4.2023]
```
auctionParser :: RowParser A.Auction
```

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 122 [5.456]

B:BD[4.2039] → [11.109:177]

B:BD[11.177] → [2.187:221]

∅:D[11.177] → [12.275:309]

∅:D[2.221] → [12.275:309]

B:BD[12.275] → [12.275:309]

B:BD[12.309] → [2.222:256]

∅:D[13.47] → [14.2144:2178]

∅:D[15.156] → [14.2144:2178]

∅:D[2.256] → [14.2144:2178]

∅:D[12.309] → [14.2144:2178]

∅:D[16.662] → [14.2144:2178]

B:BD[14.2144] → [14.2144:2178]

  Auction <$> fieldWith pidParser
          <*> fieldWith uidParser
          <*> fieldWith utcParser
          <*> fieldWith btcParser
          <*> fieldWith utcParser
          <*> fieldWith utcParser

[4.2039]

[5.2729]

  A.Auction <$> fieldWith pidParser
            <*> fieldWith uidParser
            <*> fieldWith utcParser
            <*> fieldWith btcParser
            <*> fieldWith utcParser
            <*> fieldWith utcParser

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 129 [5.456]
B:BD[5.2730] → [10.725:752]
```
bidParser :: RowParser Bid
```
[5.2730]
[4.2040]
```
bidParser :: RowParser A.Bid
```

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 131 [5.456]

B:BD[4.2052] → [4.2052:2146]

∅:D[4.2146] → [14.2179:2209]

B:BD[10.862] → [14.2179:2209]

  Bid <$> fieldWith uidParser
      <*> fieldWith secondsParser
      <*> fieldWith btcParser
      <*> fieldWith utcParser

[4.2052]

[5.2828]

  A.Bid <$> fieldWith uidParser
        <*> fieldWith secondsParser
        <*> fieldWith btcParser
        <*> fieldWith utcParser

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 147 [5.456]
B:BD[5.3062] → [10.1116:1151]
```
projectParser :: RowParser Project
```
[5.3062]
[4.2208]
```
projectParser :: RowParser P.Project
```

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 149 [5.456]

B:BD[4.2224] → [4.2224:2278]

∅:D[14.2275] → [10.1210:1244]

∅:D[4.2278] → [10.1210:1244]

B:BD[10.1210] → [10.1210:1244]

B:BD[10.1244] → [17.422:460]

  Project <$> field
          <*> fieldWith utcParser
          <*> fieldWith uidParser
          <*> fieldWith fromJSONField

[4.2224]

[18.313]

  P.Project <$> field
            <*> fieldWith utcParser
            <*> fieldWith uidParser
            <*> fieldWith fromJSONField

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 154 [5.456]
B:BD[18.314] → [14.2276:2317]
```
invitationParser :: RowParser Invitation
```
[18.314]
[4.2279]
```
invitationParser :: RowParser P.Invitation
```

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 156 [5.456]

∅:D[4.2298] → [14.2337:2530]

B:BD[14.2337] → [14.2337:2530]

  Invitation <$> fieldWith pidParser
             <*> fieldWith uidParser
             <*> fieldWith emailParser
             <*> fieldWith utcParser
             <*> fmap (fmap toThyme) field

[4.2298]

[14.2530]

  P.Invitation <$> fieldWith pidParser
               <*> fieldWith uidParser
               <*> fieldWith emailParser
               <*> fieldWith utcParser
               <*> fmap (fmap toThyme) field

Insertion in lib/Aftok/Database/PostgreSQL.hs at line 166 [5.456]

[10.1361]

[19.293]


billableParser :: RowParser BI.Billable
billableParser =
  BI.Billable <$> fieldWith pidParser
              <*> fieldWith uidParser
              <*> field
              <*> field
              <*> recurrenceParser
              <*> fieldWith btcParser
              <*> (Days <$> field)

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 198 [5.456]

B:BD[20.1362] → [17.581:608]

B:BD[17.608] → [21.4:75]

B:BD[21.75] → [6.688:732]

∅:D[6.732] → [21.121:182]

B:BD[21.121] → [21.121:182]

B:BD[21.182] → [8.1732:1885]

∅:D[8.1885] → [21.316:341]

B:BD[21.316] → [21.316:341]

B:BD[21.341] → [3.3184:3302]

instance DBEval QDBM where
  dbEval (CreateEvent (ProjectId pid) (UserId uid) (LogEntry c e m)) =
    case c of
      CreditToAddress addr ->
        pinsert EventId
          "INSERT INTO work_events \
          \(project_id, user_id, credit_to_type, credit_to_btc_addr, event_type, event_time, event_metadata) \
          \VALUES (?, ?, ?, ?, ?, ?, ?) \
          \RETURNING id"
          ( pid, uid, creditToName c, addr ^. _BtcAddr . to addrToBase58, eventName e, fromThyme $ e ^. eventTime, m)

[20.1362]

[21.425]

storeEvent :: DBOp a -> Maybe (QDBM EventId)
storeEvent (CreateBillable _) = error "Not implemented"
storeEvent (CreateSubscription _ _) = error "Not implemented"
storeEvent (CreatePaymentRequest _) = error "Not implemented"
storeEvent (CreatePayment _) = error "Not implemented"
storeEvent _ = Nothing

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 205 [5.456]

B:BD[21.426] → [8.1987:2017]

∅:D[8.2017] → [21.455:516]

B:BD[21.455] → [21.455:516]

B:BD[21.516] → [8.2018:2173]

∅:D[8.2173] → [21.652:677]

B:BD[21.652] → [21.652:677]

B:BD[21.677] → [8.2174:2276]

      CreditToProject pid' ->
        pinsert EventId
          "INSERT INTO work_events \
          \(project_id, user_id, credit_to_type, credit_to_project_id, event_type, event_time, event_metadata) \
          \VALUES (?, ?, ?, ?, ?, ?, ?) \
          \RETURNING id"
          ( pid, uid, creditToName c, pid' ^. _ProjectId, eventName e, fromThyme $ e ^. eventTime, m)

[21.426]

[21.762]

updateCache :: DBOp a -> QDBM a
updateCache (CreateEvent (P.ProjectId pid) (UserId uid) (LogEntry c e m)) =
  case c of
    CreditToAddress addr ->
      pinsert EventId
        "INSERT INTO work_events \
        \(project_id, user_id, credit_to_type, credit_to_btc_addr, event_type, event_time, event_metadata) \
        \VALUES (?, ?, ?, ?, ?, ?, ?) \
        \RETURNING id"
        ( pid, uid, creditToName c, addr ^. _BtcAddr . to addrToBase58, eventName e, fromThyme $ e ^. eventTime, m)

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 216 [5.456]

B:BD[21.763] → [8.2277:2304]

∅:D[8.2304] → [21.789:850]

B:BD[21.789] → [21.789:850]

B:BD[21.850] → [8.2305:2457]

∅:D[8.2457] → [21.983:1008]

B:BD[21.983] → [21.983:1008]

B:BD[21.1008] → [8.2458:2557]

      CreditToUser uid' ->
        pinsert EventId
          "INSERT INTO work_events \
          \(project_id, user_id, credit_to_type, credit_to_user_id, event_type, event_time, event_metadata) \
          \VALUES (?, ?, ?, ?, ?, ?, ?) \
          \RETURNING id"
          ( pid, uid, creditToName c, uid' ^. _UserId, eventName e, fromThyme $ e ^. eventTime, m)

[21.763]

[10.1807]

    CreditToProject pid' ->
      pinsert EventId
        "INSERT INTO work_events \
        \(project_id, user_id, credit_to_type, credit_to_project_id, event_type, event_time, event_metadata) \
        \VALUES (?, ?, ?, ?, ?, ?, ?) \
        \RETURNING id"
        ( pid, uid, creditToName c, pid' ^. P._ProjectId, eventName e, fromThyme $ e ^. eventTime, m)

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 224 [5.456]

B:BD[10.1808] → [4.2552:2589]

∅:D[4.2589] → [22.236:277]

B:BD[22.236] → [22.236:277]

B:BD[22.277] → [8.2558:2746]

∅:D[8.2746] → [17.1162:1200]

B:BD[17.1162] → [17.1162:1200]

  dbEval (FindEvent (EventId eid)) =
    headMay <$> pquery qdbLogEntryParser
      "SELECT project_id, user_id, \
      \credit_to_type, credit_to_btc_addr, credit_to_user_id, credit_to_project_id, \
      \event_type, event_time, event_metadata FROM work_events \
      \WHERE id = ?"
      (Only eid)

[10.1808]

[5.3405]

    CreditToUser uid' ->
      pinsert EventId
        "INSERT INTO work_events \
        \(project_id, user_id, credit_to_type, credit_to_user_id, event_type, event_time, event_metadata) \
        \VALUES (?, ?, ?, ?, ?, ?, ?) \
        \RETURNING id"
        ( pid, uid, creditToName c, uid' ^. _UserId, eventName e, fromThyme $ e ^. eventTime, m)

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 232 [5.456]

B:BD[5.3406] → [17.1231:1289]

B:BD[17.1289] → [22.278:323]

∅:D[22.323] → [17.1323:1409]

B:BD[17.1323] → [17.1323:1409]

B:BD[17.1409] → [4.2590:2659]

∅:D[4.2659] → [14.2802:2836]

B:BD[17.1479] → [14.2802:2836]

B:BD[14.2836] → [22.324:371]

∅:D[22.371] → [17.1548:1684]

B:BD[17.1548] → [17.1548:1684]

B:BD[17.1684] → [4.2660:2712]

∅:D[4.2712] → [14.2837:2884]

B:BD[17.1737] → [14.2837:2884]

B:BD[14.2884] → [22.372:416]

∅:D[22.416] → [17.1815:1901]

B:BD[17.1815] → [17.1815:1901]

B:BD[17.1901] → [4.2713:2782]

∅:D[4.2782] → [14.2885:2919]

B:BD[17.1971] → [14.2885:2919]

B:BD[14.2919] → [22.417:432]

  dbEval (FindEvents (ProjectId pid) (UserId uid) ival) =
    let q (Before e) = pquery logEntryParser
          "SELECT btc_addr, event_type, event_time, event_metadata FROM work_events \
          \WHERE project_id = ? AND user_id = ? AND event_time <= ?"
          (pid, uid, fromThyme e)
        q (During s e) = pquery logEntryParser
          "SELECT btc_addr, event_type, event_time, event_metadata FROM work_events \
          \WHERE project_id = ? AND user_id = ? \
          \AND event_time >= ? AND event_time <= ?"
          (pid, uid, fromThyme s, fromThyme e)
        q (After s) = pquery logEntryParser
          "SELECT btc_addr, event_type, event_time, event_metadata FROM work_events \
          \WHERE project_id = ? AND user_id = ? AND event_time >= ?"
          (pid, uid, fromThyme s)
    in  q ival

[5.3406]

[23.1083]

updateCache (FindEvent (EventId eid)) =
  headMay <$> pquery qdbLogEntryParser
    "SELECT project_id, user_id, \
    \credit_to_type, credit_to_btc_addr, credit_to_user_id, credit_to_project_id, \
    \event_type, event_time, event_metadata FROM work_events \
    \WHERE id = ?"
    (Only eid)

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 240 [5.456]

B:BD[23.1084] → [4.2783:2839]

∅:D[4.2839] → [17.2092:2116]

B:BD[17.2092] → [17.2092:2116]

B:BD[17.2116] → [21.1091:1216]

∅:D[21.1216] → [17.2221:2276]

B:BD[17.2221] → [17.2221:2276]

  dbEval (AmendEvent (EventId eid) (TimeChange mt t)) =
    pinsert AmendmentId
      "INSERT INTO event_time_amendments \
      \(event_id, amended_at, event_time) \
      \VALUES (?, ?, ?) RETURNING id"
      ( eid, fromThyme $ mt ^. _ModTime, fromThyme t )

[23.1084]

[20.1951]

updateCache (FindEvents (P.ProjectId pid) (UserId uid) ival) =
  let q (Before e) = pquery logEntryParser
        "SELECT btc_addr, event_type, event_time, event_metadata FROM work_events \
        \WHERE project_id = ? AND user_id = ? AND event_time <= ?"
        (pid, uid, fromThyme e)
      q (During s e) = pquery logEntryParser
        "SELECT btc_addr, event_type, event_time, event_metadata FROM work_events \
        \WHERE project_id = ? AND user_id = ? \
        \AND event_time >= ? AND event_time <= ?"
        (pid, uid, fromThyme s, fromThyme e)
      q (After s) = pquery logEntryParser
        "SELECT btc_addr, event_type, event_time, event_metadata FROM work_events \
        \WHERE project_id = ? AND user_id = ? AND event_time >= ?"
        (pid, uid, fromThyme s)
  in  q ival

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 256 [5.456]

B:BD[20.1952] → [8.2747:2821]

∅:D[8.2821] → [21.1305:1532]

B:BD[21.1305] → [21.1305:1532]

B:BD[21.1532] → [3.3303:3401]

  dbEval (AmendEvent (EventId eid) (CreditToChange mt c)) =
    case c of
      CreditToAddress addr ->
        pinsert AmendmentId
          "INSERT INTO event_credit_to_amendments \
          \(event_id, amended_at, credit_to_type, credit_to_btc_addr) \
          \VALUES (?, ?, ?, ?) RETURNING id"
          ( eid, fromThyme $ mt ^. _ModTime, creditToName c, addr ^. _BtcAddr . to addrToBase58 )

[20.1952]

[4.2903]

updateCache (AmendEvent (EventId eid) (TimeChange mt t)) =
  pinsert AmendmentId
    "INSERT INTO event_time_amendments \
    \(event_id, amended_at, event_time) \
    \VALUES (?, ?, ?) RETURNING id"
    ( eid, fromThyme $ mt ^. _ModTime, fromThyme t )

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 263 [5.456]

B:BD[4.2904] → [21.1618:1846]

B:BD[21.1846] → [8.2903:2984]

      CreditToProject pid ->
        pinsert AmendmentId
          "INSERT INTO event_credit_to_amendments \
          \(event_id, amended_at, credit_to_type, credit_to_project_id) \
          \VALUES (?, ?, ?, ?) RETURNING id"
          ( eid, fromThyme $ mt ^. _ModTime, creditToName c, pid ^. _ProjectId )

[4.2904]

[21.1932]

updateCache (AmendEvent (EventId eid) (CreditToChange mt c)) =
  case c of
    CreditToAddress addr ->
      pinsert AmendmentId
        "INSERT INTO event_credit_to_amendments \
        \(event_id, amended_at, credit_to_type, credit_to_btc_addr) \
        \VALUES (?, ?, ?, ?) RETURNING id"
        ( eid, fromThyme $ mt ^. _ModTime, creditToName c, addr ^. _BtcAddr . to addrToBase58 )

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 272 [5.456]

B:BD[21.1933] → [6.733:759]

∅:D[6.759] → [8.2985:3013]

B:BD[21.1960] → [8.2985:3013]

∅:D[8.3013] → [21.1960:2128]

B:BD[21.1960] → [21.1960:2128]

B:BD[21.2128] → [8.3014:3092]

      CreditToUser uid ->
        pinsert AmendmentId
          "INSERT INTO event_credit_to_amendments \
          \(event_id, amended_at, credit_to_type, credit_to_user_id) \
          \VALUES (?, ?, ?, ?) RETURNING id"
          ( eid, fromThyme $ mt ^. _ModTime, creditToName c, uid ^. _UserId )

[21.1933]

[21.2208]

    CreditToProject pid ->
      pinsert AmendmentId
        "INSERT INTO event_credit_to_amendments \
        \(event_id, amended_at, credit_to_type, credit_to_project_id) \
        \VALUES (?, ?, ?, ?) RETURNING id"
        ( eid, fromThyme $ mt ^. _ModTime, creditToName c, pid ^. P._ProjectId )

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 279 [5.456]

∅:D[21.2209] → [4.2904:2964]

B:BD[4.2904] → [4.2904:2964]

∅:D[4.2964] → [17.2589:2613]

B:BD[17.2589] → [17.2589:2613]

B:BD[17.2613] → [21.2210:2343]

∅:D[21.2343] → [17.2720:2764]

B:BD[17.2720] → [17.2720:2764]

  dbEval (AmendEvent (EventId eid) (MetadataChange mt v)) =
    pinsert AmendmentId
      "INSERT INTO event_metadata_amendments \
      \(event_id, amended_at, event_metadata) \
      \VALUES (?, ?, ?) RETURNING id"
      ( eid, fromThyme $ mt ^. _ModTime, v)

[21.2209]

[5.4597]

    CreditToUser uid ->
      pinsert AmendmentId
        "INSERT INTO event_credit_to_amendments \
        \(event_id, amended_at, credit_to_type, credit_to_user_id) \
        \VALUES (?, ?, ?, ?) RETURNING id"
        ( eid, fromThyme $ mt ^. _ModTime, creditToName c, uid ^. _UserId )

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 286 [5.456]

B:BD[5.4598] → [14.2920:2966]

∅:D[14.2966] → [17.2799:2839]

B:BD[17.2799] → [17.2799:2839]

B:BD[17.2839] → [4.2965:3067]

∅:D[4.3067] → [22.433:450]

B:BD[17.2942] → [22.433:450]

∅:D[22.450] → [17.2966:2998]

∅:D[14.2986] → [17.2966:2998]

B:BD[17.2966] → [17.2966:2998]

  dbEval (ReadWorkIndex (ProjectId pid)) = do
    logEntries <- pquery logEntryParser
      "SELECT btc_addr, event_type, event_time, event_metadata FROM work_events WHERE project_id = ?"
      (Only pid)
    pure $ workIndex logEntries

[5.4598]

[5.4861]

updateCache (AmendEvent (EventId eid) (MetadataChange mt v)) =
  pinsert AmendmentId
    "INSERT INTO event_metadata_amendments \
    \(event_id, amended_at, event_metadata) \
    \VALUES (?, ?, ?) RETURNING id"
    ( eid, fromThyme $ mt ^. _ModTime, v)

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 293 [5.456]

B:BD[5.4862] → [11.178:209]

∅:D[11.209] → [17.3035:3057]

∅:D[4.3103] → [17.3035:3057]

B:BD[17.3035] → [17.3035:3057]

B:BD[17.3057] → [12.310:427]

B:BD[12.427] → [11.210:252]

∅:D[11.252] → [12.453:492]

B:BD[12.453] → [12.453:492]

B:BD[12.492] → [3.3402:3441]

∅:D[3.3441] → [12.536:585]

B:BD[12.536] → [12.536:585]

  dbEval (CreateAuction auc) =
    pinsert AuctionId
      "INSERT INTO auctions (project_id, user_id, raise_amount, end_time) \
      \VALUES (?, ?, ?, ?) RETURNING id"
      ( auc ^. (A.projectId . _ProjectId)
      , auc ^. (A.initiator . _UserId)
      , auc ^. (raiseAmount . satoshi)
      , auc ^. (auctionEnd.to fromThyme)
      )

[5.4862]

[5.5182]

updateCache (ReadWorkIndex (P.ProjectId pid)) = do
  logEntries <- pquery logEntryParser
    "SELECT btc_addr, event_type, event_time, event_metadata FROM work_events WHERE project_id = ?"
    (Only pid)
  pure $ workIndex logEntries

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 299 [5.456]

B:BD[5.5183] → [4.3104:3135]

∅:D[4.3135] → [22.574:611]

B:BD[22.574] → [22.574:611]

B:BD[22.611] → [2.257:372]

∅:D[2.372] → [17.3377:3412]

∅:D[4.3201] → [17.3377:3412]

B:BD[17.3377] → [17.3377:3412]

  dbEval (FindAuction aucId) =
    headMay <$> pquery auctionParser
      "SELECT project_id, initiator_id, created_at, raise_amount, start_time, end_time FROM auctions WHERE id = ?"
      (Only (aucId ^. _AuctionId))

[5.5183]

[5.5424]

updateCache (CreateAuction auc) =
  pinsert A.AuctionId
    "INSERT INTO auctions (project_id, user_id, raise_amount, end_time) \
    \VALUES (?, ?, ?, ?) RETURNING id"
    ( auc ^. (A.projectId . P._ProjectId)
    , auc ^. (A.initiator . _UserId)
    , auc ^. (A.raiseAmount . satoshi)
    , auc ^. (A.auctionEnd . to fromThyme)
    )

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 309 [5.456]

B:BD[5.5425] → [4.3202:3247]

∅:D[4.3247] → [17.3487:3634]

B:BD[17.3487] → [17.3487:3634]

B:BD[17.3634] → [4.3248:3262]

∅:D[4.3262] → [17.3649:3733]

B:BD[17.3649] → [17.3649:3733]

B:BD[16.803] → [13.49:49]

B:BD[17.3733] → [3.3442:3479]

∅:D[13.49] → [14.3080:3118]

∅:D[15.297] → [14.3080:3118]

∅:D[24.800] → [14.3080:3118]

∅:D[16.803] → [14.3080:3118]

∅:D[3.3479] → [14.3080:3118]

B:BD[17.3768] → [14.3080:3118]

∅:D[14.3118] → [17.3791:3799]

B:BD[17.3791] → [17.3791:3799]

  dbEval (CreateBid (AuctionId aucId) bid) =
    pinsert BidId
      "INSERT INTO bids (auction_id, bidder_id, bid_seconds, bid_amount, bid_time) \
      \VALUES (?, ?, ?, ?, ?) RETURNING id"
      ( aucId
      , bid ^. (bidUser._UserId)
      , case bid ^. bidSeconds of (Seconds i) -> i
      , bid ^. (bidAmount . satoshi)
      , bid ^. (bidTime.to fromThyme)
      )

[5.5425]

[5.5524]

updateCache (FindAuction aucId) =
  headMay <$> pquery auctionParser
    "SELECT project_id, initiator_id, created_at, raise_amount, start_time, end_time FROM auctions WHERE id = ?"
    (Only (aucId ^. A._AuctionId))

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 314 [5.456]

B:BD[5.5525] → [4.3263:3291]

∅:D[4.3291] → [17.3829:3939]

B:BD[17.3829] → [17.3829:3939]

B:BD[17.3939] → [22.612:647]

  dbEval (ReadBids aucId) =
    pquery bidParser
      "SELECT user_id, bid_seconds, bid_amount, bid_time FROM bids WHERE auction_id = ?"
      (Only (aucId ^. _AuctionId))

[5.5525]

[19.667]

updateCache (CreateBid (A.AuctionId aucId) bid) =
  pinsert A.BidId
    "INSERT INTO bids (auction_id, bidder_id, bid_seconds, bid_amount, bid_time) \
    \VALUES (?, ?, ?, ?, ?) RETURNING id"
    ( aucId
    , bid ^. (A.bidUser . _UserId)
    , case bid ^. A.bidSeconds of (Seconds i) -> i
    , bid ^. (A.bidAmount . satoshi)
    , bid ^. (A.bidTime . to fromThyme)
    )

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 325 [5.456]

B:BD[19.668] → [4.3292:3322]

B:BD[4.3322] → [3.3480:3620]

∅:D[3.3620] → [17.4027:4109]

B:BD[17.4027] → [17.4027:4109]

B:BD[17.4109] → [3.3621:3717]

  dbEval (CreateUser user') =
    let addrMay :: Maybe ByteString
        addrMay = user' ^? (userAddress . traverse . _BtcAddr . to addrToBase58)
    in  pinsert UserId
      "INSERT INTO users (handle, btc_addr, email) VALUES (?, ?, ?) RETURNING id"
      ( user' ^. (username._UserName)
      , addrMay
      , user' ^. userEmail._Email
      )

[19.668]

[18.704]

updateCache (ReadBids aucId) =
  pquery bidParser
    "SELECT user_id, bid_seconds, bid_amount, bid_time FROM bids WHERE auction_id = ?"
    (Only (aucId ^. A._AuctionId))

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 330 [5.456]

B:BD[18.705] → [4.3323:3358]

∅:D[4.3358] → [22.684:718]

B:BD[22.684] → [22.684:718]

∅:D[22.718] → [17.4270:4350]

B:BD[17.4270] → [17.4270:4350]

  dbEval (FindUser (UserId uid)) =
    headMay <$> pquery userParser
      "SELECT handle, btc_addr, email FROM users WHERE id = ?"
      (Only uid)

[18.705]

[7.1368]

updateCache (CreateUser user') =
  let addrMay :: Maybe ByteString
      addrMay = user' ^? (userAddress . traverse . _BtcAddr . to addrToBase58)
  in  pinsert UserId
    "INSERT INTO users (handle, btc_addr, email) VALUES (?, ?, ?) RETURNING id"
    ( user' ^. (username._UserName)
    , addrMay
    , user' ^. userEmail._Email
    )

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 340 [5.456]

B:BD[7.1369] → [4.3359:3400]

∅:D[4.3400] → [22.761:798]

B:BD[22.761] → [22.761:798]

∅:D[22.798] → [17.4454:4540]

B:BD[17.4454] → [17.4454:4540]

  dbEval (FindUserByName (UserName h)) =
    headMay <$> pquery qdbUserParser
      "SELECT id, handle, btc_addr, email FROM users WHERE handle = ?"
      (Only h)

[7.1369]

[14.3218]

updateCache (FindUser (UserId uid)) =
  headMay <$> pquery userParser
    "SELECT handle, btc_addr, email FROM users WHERE id = ?"
    (Only uid)

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 345 [5.456]

B:BD[14.3219] → [14.3219:3556]

  dbEval (CreateInvitation (ProjectId pid) (UserId uid) (Email e) t) = do
    invCode <- liftIO randomInvCode
    void $ pexec
      "INSERT INTO invitations (project_id, invitor_id, invitee_email, invitation_key, invitation_time) \
      \VALUES (?, ?, ?, ?, ?)"
      (pid, uid, e, renderInvCode invCode, fromThyme t)
    pure invCode

[14.3219]

[10.3741]

updateCache (FindUserByName (UserName h)) =
  headMay <$> pquery qdbUserParser
    "SELECT id, handle, btc_addr, email FROM users WHERE handle = ?"
    (Only h)
updateCache (CreateInvitation (P.ProjectId pid) (UserId uid) (Email e) t) = do
  invCode <- liftIO P.randomInvCode
  void $ pexec
    "INSERT INTO invitations (project_id, invitor_id, invitee_email, invitation_key, invitation_time) \
    \VALUES (?, ?, ?, ?, ?)"
    (pid, uid, e, P.renderInvCode invCode, fromThyme t)
  pure invCode
updateCache (FindInvitation ic) =
  headMay <$> pquery invitationParser
    "SELECT project_id, invitor_id, invitee_email, invitation_time, acceptance_time \
    \FROM invitations WHERE invitation_key = ?"
    (Only $ P.renderInvCode ic)

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 364 [5.456]

B:BD[10.3742] → [4.3401:3432]

∅:D[4.3432] → [22.831:871]

B:BD[22.831] → [22.831:871]

∅:D[22.871] → [14.3634:3804]

B:BD[14.3634] → [14.3634:3804]

  dbEval (FindInvitation ic) =
    headMay <$> pquery invitationParser
      "SELECT project_id, invitor_id, invitee_email, invitation_time, acceptance_time \
      \FROM invitations WHERE invitation_key = ?"
      (Only $ renderInvCode ic)

[10.3742]

[14.3835]

updateCache (AcceptInvitation (UserId uid) ic t) = transactQDBM $ do
  void $ pexec
    "UPDATE invitations SET acceptance_time = ? WHERE invitation_key = ?"
    (fromThyme t, P.renderInvCode ic)
  void $ pexec
    "INSERT INTO project_companions (project_id, user_id, invited_by, joined_at) \
    \SELECT i.project_id, ?, i.invitor_id, ? \
    \FROM invitations i \
    \WHERE i.invitation_key = ?"
    (uid, fromThyme t, P.renderInvCode ic)

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 375 [5.456]

B:BD[14.3836] → [14.3836:4290]

  dbEval (AcceptInvitation (UserId uid) ic t) = transactQDBM $ do
    void $ pexec
      "UPDATE invitations SET acceptance_time = ? WHERE invitation_key = ?"
      (fromThyme t, renderInvCode ic)
    void $ pexec
      "INSERT INTO project_companions (project_id, user_id, invited_by, joined_at) \
      \SELECT i.project_id, ?, i.invitor_id, ? \
      \FROM invitations i \
      \WHERE i.invitation_key = ?"
      (uid, fromThyme t, renderInvCode ic)

[14.3836]

[14.4290]

updateCache (CreateProject p) =
  pinsert P.ProjectId
    "INSERT INTO projects (project_name, inception_date, initiator_id, depreciation_fn) \
    \VALUES (?, ?, ?, ?) RETURNING id"
    (p ^. P.projectName, p ^. (P.inceptionDate . to fromThyme), p ^. (P.initiator . _UserId), toJSON $ p ^. P.depf)

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 381 [5.456]

B:BD[14.4291] → [4.3433:3462]

∅:D[4.3462] → [17.4596:4751]

B:BD[17.4596] → [17.4596:4751]

B:BD[17.4751] → [12.586:696]

  dbEval (CreateProject p) =
    pinsert ProjectId
      "INSERT INTO projects (project_name, inception_date, initiator_id, depreciation_fn) \
      \VALUES (?, ?, ?, ?) RETURNING id"
      (p ^. projectName, p ^. (inceptionDate.to fromThyme), p ^. (P.initiator . _UserId), toJSON $ p ^. depf)

[14.4291]

[19.946]

updateCache (FindProject (P.ProjectId pid)) =
  headMay <$> pquery projectParser
    "SELECT project_name, inception_date, initiator_id, depreciation_fn FROM projects WHERE id = ?"
    (Only pid)

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 386 [5.456]

B:BD[19.947] → [4.3463:3504]

∅:D[4.3504] → [22.914:951]

B:BD[22.914] → [22.914:951]

∅:D[22.951] → [25.4:106]

B:BD[17.4924] → [25.4:106]

∅:D[25.106] → [17.5009:5026]

B:BD[17.5009] → [17.5009:5026]

  dbEval (FindProject (ProjectId pid)) =
    headMay <$> pquery projectParser
      "SELECT project_name, inception_date, initiator_id, depreciation_fn FROM projects WHERE id = ?"
      (Only pid)

[19.947]

[19.1013]

updateCache (FindUserProjects (UserId uid)) =
  pquery qdbProjectParser
    "SELECT p.id, p.project_name, p.inception_date, p.initiator_id, p.depreciation_fn \
    \FROM projects p LEFT OUTER JOIN project_companions pc ON pc.project_id = p.id \
    \WHERE pc.user_id = ? \
    \OR p.initiator_id = ?"
    (uid, uid)

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 394 [5.456]

B:BD[19.1014] → [4.3505:3548]

∅:D[4.3548] → [17.5099:5127]

B:BD[17.5099] → [17.5099:5127]

B:BD[17.5127] → [25.107:284]

B:BD[25.284] → [4.3549:3579]

∅:D[4.3579] → [25.315:345]

B:BD[25.315] → [25.315:345]

∅:D[25.345] → [17.5448:5465]

B:BD[17.5448] → [17.5448:5465]

  dbEval (FindUserProjects (UserId uid)) =
    pquery qdbProjectParser
      "SELECT p.id, p.project_name, p.inception_date, p.initiator_id, p.depreciation_fn \
      \FROM projects p LEFT OUTER JOIN project_companions pc ON pc.project_id = p.id \
      \WHERE pc.user_id = ? \
      \OR p.initiator_id = ?"
      (uid, uid)

[19.1014]

[19.1042]

updateCache (AddUserToProject pid current new) = void $
  pexec
    "INSERT INTO project_companions (project_id, user_id, invited_by) VALUES (?, ?, ?)"
    (pid ^. P._ProjectId, new ^. _UserId, current ^. _UserId)

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 399 [5.456]

B:BD[19.1043] → [4.3580:3633]

∅:D[4.3633] → [22.1006:1016]

B:BD[22.1006] → [22.1006:1016]

∅:D[22.1016] → [17.5532:5684]

B:BD[17.5532] → [17.5532:5684]

  dbEval (AddUserToProject pid current new) = void $
    pexec
      "INSERT INTO project_companions (project_id, user_id, invited_by) VALUES (?, ?, ?)"
      (pid ^. _ProjectId, new ^. _UserId, current ^. _UserId)

[19.1043]

[3.3718]

updateCache dbop @ (CreateBillable b) = do
  eventId <- requireEventId dbop
  pinsert BI.BillableId
    "INSERT INTO billables \
    \(project_id, event_id, name, description, recurrence_type, recurrence_count, billing_amount, grace_period_days)\
    \VALUES (?, ?, ?, ?, ?, ?, ?, ?) RETURNING id"
    ( b ^. (BI.project . P._ProjectId)
    , eventId ^. _EventId
    , b ^. BI.name
    , b ^. BI.description
    , b ^. (BI.recurrence . to BI.recurrenceName)
    , b ^. (BI.recurrence . to BI.recurrenceCount)
    , b ^. (BI.amount . satoshi)
    , b ^. (BI.gracePeriod . _Days)
    )

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 415 [5.456]

B:BD[3.3719] → [3.3719:3942]

  dbEval (CreateBillable _) = error "Not implemented"
  dbEval (ReadBillable _) = error "Not implemented" 
  dbEval (CreatePaymentRequest _ _) = error "Not implemented"
  dbEval (CreatePayment _ ) = error "Not implemented"

[3.3719]

[3.3942]

updateCache (ReadBillable bid) =
  headMay <$> pquery billableParser
    "SELECT b.project_id, e.created_by, b.name, b.description, b.recurrence_type, b.recurrence_count, \
    \       b.billing_amount, b.grace_period_days \
    \FROM billables b JOIN aftok_events e ON e.id = b.event_id \
    \WHERE b.id = ?"
    (Only (bid ^. BI._BillableId))

Insertion in lib/Aftok/Database/PostgreSQL.hs at line 423 [5.456]

[3.3943]

[19.1044]

updateCache (CreateSubscription _ _) = error "Not implemented"
updateCache (CreatePaymentRequest _) = error "Not implemented"
updateCache (CreatePayment _ ) = error "Not implemented"

Replacement in lib/Aftok/Database/PostgreSQL.hs at line 427 [5.456]
B:BD[19.1045] → [14.4399:4454]
```
  dbEval (RaiseDBError err _) = QDBM . lift $ left err
```
[19.1045]
[3.3944]
```
updateCache (RaiseDBError err _) = raiseError err
```

Insertion in lib/Aftok/Database/PostgreSQL.hs at line 429 [5.456]

[3.3945]

requireEventId :: DBOp a -> QDBM EventId
requireEventId = maybe (raiseError EventStorageFailed) id . storeEvent

Insertion in lib/Aftok/Database/PostgreSQL.hs at line 432 [5.456]
[3.3946]
[3.3946]
```
raiseError :: DBError -> QDBM a
raiseError = QDBM . lift . left
```
Insertion in lib/Aftok/Database/PostgreSQL.hs at line 435 [5.456]
[3.3947]
```
instance DBEval QDBM where
  dbEval e = updateCache e
```
Deletion in lib/Aftok/Database.hs at line 19 [27.4936]
B:BD[26.364] → [3.4022:4051]
```
import           Aftok.Types
```

Replacement in lib/Aftok/Database.hs at line 53 [27.4936]

B:BD[3.4053] → [3.4053:4199]

  CreateBillable   :: Billable ProjectId Satoshi -> DBOp BillableId
  ReadBillable     :: BillableId -> DBOp (Maybe (Billable ProjectId Satoshi))

[3.4053]

[3.4199]

  CreateBillable   :: Billable -> DBOp BillableId
  ReadBillable     :: BillableId -> DBOp (Maybe Billable)
  CreateSubscription :: UserId -> BillableId -> DBOp SubscriptionId

Replacement in lib/Aftok/Database.hs at line 58 [27.4936]

B:BD[3.4200] → [3.4200:4373]

  CreatePaymentRequest :: UserId -> PaymentRequest ProjectId BillableId -> DBOp PaymentRequestId
  CreatePayment        :: Payment PaymentRequestId UserId -> DBOp PaymentId

[3.4200]

[17.7074]

  CreatePaymentRequest :: PaymentRequest SubscriptionId -> DBOp PaymentRequestId
  CreatePayment        :: Payment PaymentRequestId -> DBOp PaymentId

Insertion in lib/Aftok/Database.hs at line 72 [27.4936]
[14.5074]
[14.5074]
```
             | EventStorageFailed
```

Replacement in lib/Aftok/Database.hs at line 177 [27.4936]

B:BD[12.834] → [3.4391:4546]

createBillable :: UserId -> Billable ProjectId Satoshi -> DBProg BillableId
createBillable uid b = withProjectAuth (b ^. B.project) uid $ CreateBillable b

[12.834]

[3.4546]

createBillable :: Billable -> DBProg BillableId
createBillable b = withProjectAuth (b ^. B.project) (b ^. B.creator) $ CreateBillable b

Replacement in lib/Aftok/Database.hs at line 180 [27.4936]

B:BD[3.4547] → [3.4547:4621]

readBillable :: BillableId -> DBProg (Maybe (Billable ProjectId Satoshi))

[3.4547]

[3.4621]

readBillable :: BillableId -> DBProg (Maybe Billable)

Replacement in lib/Aftok/Database.hs at line 188 [27.4936]

B:BD[3.4788] → [3.4788:4861]

readPaymentHistory :: UserId -> DBProg [Payment PaymentRequestId UserId]

[3.4788]

[3.4861]

readPaymentHistory :: UserId -> DBProg [Payment PaymentRequestId]

Replacement in lib/Aftok/Payments.hs at line 18 [3.5686]

B:BD[3.6086] → [3.6086:6159]

data PaymentRequest (p :: *) (b :: *) = PaymentRequest
  { _project :: p

[3.6086]

[3.6159]

data PaymentRequest (s :: *) = PaymentRequest
  { _subscription :: s

Deletion in lib/Aftok/Payments.hs at line 22 [3.5686]
B:BD[3.6236] → [3.6236:6255]
```
  , _billable :: b
```
Replacement in lib/Aftok/Payments.hs at line 25 [3.5686]
B:BD[3.6288] → [3.6288:6315]
```
data Payment r u = Payment
```
[3.6288]
[3.6315]
```
data Payment (r :: *) = Payment
```
Deletion in lib/Aftok/Payments.hs at line 29 [3.5686]
B:BD[3.6389] → [3.6389:6405]
```
  , _payor :: u
```
Insertion in lib/Aftok/Time.hs at line 1 [3.6473]
[3.6473]
[3.6474]
```
{-# LANGUAGE TemplateHaskell #-}
```
Insertion in lib/Aftok/Time.hs at line 5 [3.6473]
[3.6530]
[3.6530]
```
import           Control.Lens               (makePrisms)
```
Insertion in lib/Aftok/Time.hs at line 8 [3.6473]
[3.6555]
[3.6555]
```
makePrisms ''Days
```
Insertion in migrations/2016-12-31_03-45-17_create-payments.txt at line 26 [3.7446]
[3.8208]
[3.8208]
```
    created_by uuid references users(id) null,
```

Insertion in server/Aftok/Snaplet.hs at line 43 [28.1088]

[14.11872]

      handleDBError (EventStorageFailed) =
        snapError 500 "The event submitted could not be saved to the log."

Begin implementation of billing event persistence.

Dependencies

In channels

Change contents

Replacement in lib/Aftok/Billables.hs at line 7 [3.760]

Insertion in lib/Aftok/Billables.hs at line 11 [3.760]

Replacement in lib/Aftok/Billables.hs at line 16 [3.760]

Replacement in lib/Aftok/Billables.hs at line 18 [3.760]

Deletion in lib/Aftok/Billables.hs at line 23 [3.760]

Replacement in lib/Aftok/Billables.hs at line 26 [3.760]

Insertion in lib/Aftok/Billables.hs at line 42 [3.760]

Replacement in lib/Aftok/Billables.hs at line 49 [3.760]

Replacement in lib/Aftok/Billables.hs at line 53 [3.760]

Replacement in lib/Aftok/Billables.hs at line 56 [3.760]

Replacement in lib/Aftok/Billables.hs at line 59 [3.760]

Replacement in lib/Aftok/Billables.hs at line 62 [3.760]

Replacement in lib/Aftok/Billables.hs at line 65 [3.760]