, sqlite

{-# LANGUAGE OverloadedStrings #-}

{-# LANGUAGE ScopedTypeVariables, OverloadedStrings #-}

import Control.Monad

import qualified Data.Text as T
import qualified Data.Text.Lazy as LT

import Data.Time.Format

import Database.SQLite

import Quixotic.Database.SQLite

main = do 
  db <- openConnection "quixotic.db"
  adb <- sqliteADB db
  dbMain db adb

dbMain :: a -> ADB a -> IO ()

dbMain :: a -> ADB IO a -> IO ()

    post "/logStart/:btcAddr" $ handleLogRequest adb StartWork
    post "/logEnd/:btcAddr" $ handleLogRequest db StopWork

    post "/logStart/:btcAddr" $ handleLogRequest db adb StartWork
    post "/logEnd/:btcAddr" $ handleLogRequest db adb StopWork

    get "/payouts" $ currentPayouts adb

    get "/payouts" $ currentPayouts db adb

handleLogRequest :: ADB a -> (UTCTime -> WorkEvent) -> ActionM ()
handleLogRequest db ev = do 

handleLogRequest :: a -> ADB IO a -> (UTCTime -> WorkEvent) -> ActionM ()
handleLogRequest db adb ev = do 

  liftIO . recordEvent db $ LogEntry addr (ev timestamp)

  liftIO $ recordEvent adb db $ LogEntry addr (ev timestamp)

currentPayouts :: ADB a -> ActionM ()
currentPayouts db = do 

currentPayouts :: a -> ADB IO a -> ActionM ()
currentPayouts db adb = do 

  widx <- undefined 
  json . PayoutsResponse $ payouts dep ptime widx

      buildPayoutsResponse :: WorkIndex -> ActionM ()
      buildPayoutsResponse widx = json . PayoutsResponse $ payouts dep ptime widx

      payoutsAction :: EitherT T.Text ActionM WorkIndex
      payoutsAction = mapEitherT liftIO $ readWorkIndex adb db 
  eitherT (raise . LT.fromStrict) buildPayoutsResponse payoutsAction

{-# LANGUAGE ScopedTypeVariables, OverloadedStrings #-}

import System.Locale

import System.Locale (defaultTimeLocale)

sqliteADB :: String -> IO (D.ADB IO SQLiteHandle)
sqliteADB dbName = do
  db <- openConnection "quixotic.db"

sqliteADB :: SQLiteHandle -> IO (D.ADB IO SQLiteHandle)
sqliteADB db = do
  _ <- defineTableOpt db True eventTable

readWorkIndex :: SQLiteHandle -> EitherT String IO WorkIndex

readWorkIndex :: SQLiteHandle -> EitherT T.Text IO WorkIndex

  rows <- EitherT $ execStatement db "SELECT btcAddr, event, eventTime from workEvents"
  undefined

  let baseResult = EitherT $ execStatement db "SELECT btcAddr, event, eventTime from workEvents"
  rows <- bimapEitherT T.pack id baseResult
  return . intervals $ fmap parseRow (join rows)

parseRow :: Row Value -> LogEntry
parseRow = undefined

import Data.Text

  , readWorkIndex :: a -> EitherT String m WorkIndex

  , readWorkIndex :: a -> EitherT Text m WorkIndex

{-# LANGUAGE DeriveDataTypeable, ScopedTypeVariables, OverloadedStrings #-}

{-# LANGUAGE ScopedTypeVariables, OverloadedStrings #-}