WIP

9 files changed, 30 insertions, 489 deletions

diff --git a/server/src/Model/Category.hs b/server/src/Model/Category.hs
deleted file mode 100644
index ee406bc..0000000
--- a/server/src/Model/Category.hs
+++ /dev/null
@@ -1,78 +0,0 @@
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-
-module Model.Category
-  ( list
-  , create
-  , edit
-  , delete
-  ) where
-
-import           Data.Maybe             (isJust, listToMaybe)
-import           Data.Text              (Text)
-import           Data.Time.Clock        (getCurrentTime)
-import           Database.SQLite.Simple (FromRow (fromRow), Only (Only))
-import qualified Database.SQLite.Simple as SQLite
-import           Prelude                hiding (id)
-
-import           Common.Model           (Category (..), CategoryId)
-
-import           Model.Query            (Query (Query))
-
-instance FromRow Category where
-  fromRow = Category <$>
-    SQLite.field <*>
-    SQLite.field <*>
-    SQLite.field <*>
-    SQLite.field <*>
-    SQLite.field <*>
-    SQLite.field
-
-list :: Query [Category]
-list =
-  Query (\conn ->
-    SQLite.query_ conn "SELECT * FROM category WHERE deleted_at IS NULL"
-  )
-
-create :: Text -> Text -> Query CategoryId
-create categoryName categoryColor =
-  Query (\conn -> do
-    now <- getCurrentTime
-    SQLite.execute
-      conn
-      "INSERT INTO category (name, color, created_at) VALUES (?, ?, ?)"
-      (categoryName, categoryColor, now)
-    SQLite.lastInsertRowId conn
-  )
-
-edit :: CategoryId -> Text -> Text -> Query Bool
-edit categoryId categoryName categoryColor =
-  Query (\conn -> do
-    mbCategory <- listToMaybe <$>
-      (SQLite.query conn "SELECT * FROM category WHERE id = ?" (Only categoryId) :: IO [Category])
-    if isJust mbCategory
-      then do
-        now <- getCurrentTime
-        SQLite.execute
-          conn
-          "UPDATE category SET edited_at = ?, name = ?, color = ? WHERE id = ?"
-          (now, categoryName, categoryColor, categoryId)
-        return True
-      else
-        return False
-  )
-
-delete :: CategoryId -> Query Bool
-delete categoryId =
-  Query (\conn -> do
-    mbCategory <- listToMaybe <$>
-      (SQLite.query conn "SELECT * FROM category WHERE id = ?" (Only categoryId) :: IO [Category])
-    if isJust mbCategory
-      then do
-        now <- getCurrentTime
-        SQLite.execute
-          conn
-          "UPDATE category SET deleted_at = ? WHERE id = ?" (now, categoryId)
-        return True
-      else
-        return False
-  )
diff --git a/server/src/Model/Frequency.hs b/server/src/Model/Frequency.hs
deleted file mode 100644
index c29cf37..0000000
--- a/server/src/Model/Frequency.hs
+++ /dev/null
@@ -1,20 +0,0 @@
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-
-module Model.Frequency () where
-
-import qualified Data.Text                        as T
-import           Database.SQLite.Simple           (SQLData (SQLText))
-import           Database.SQLite.Simple.FromField (FromField (fromField),
-                                                   fieldData)
-import           Database.SQLite.Simple.Ok        (Ok (Errors, Ok))
-import           Database.SQLite.Simple.ToField   (ToField (toField))
-
-import           Common.Model                     (Frequency)
-
-instance FromField Frequency where
-  fromField field = case fieldData field of
-    SQLText text -> Ok (read (T.unpack text) :: Frequency)
-    _            -> Errors [error "SQLText field required for frequency"]
-
-instance ToField Frequency where
-  toField frequency = SQLText . T.pack . show $ frequency
diff --git a/server/src/Model/Income.hs b/server/src/Model/Income.hs
deleted file mode 100644
index 4938e50..0000000
--- a/server/src/Model/Income.hs
+++ /dev/null
@@ -1,88 +0,0 @@
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-
-module Model.Income
-  ( list
-  , create
-  , editOwn
-  , deleteOwn
-  ) where
-
-import           Data.Maybe             (listToMaybe)
-import           Data.Time.Calendar     (Day)
-import           Data.Time.Clock        (getCurrentTime)
-import           Database.SQLite.Simple (FromRow (fromRow), Only (Only))
-import qualified Database.SQLite.Simple as SQLite
-import           Prelude                hiding (id)
-
-import           Common.Model           (Income (..), IncomeId, User (..),
-                                         UserId)
-
-import           Model.Query            (Query (Query))
-import           Resource               (Resource, resourceCreatedAt,
-                                         resourceDeletedAt, resourceEditedAt)
-
-instance Resource Income where
-  resourceCreatedAt = _income_createdAt
-  resourceEditedAt = _income_editedAt
-  resourceDeletedAt = _income_deletedAt
-
-instance FromRow Income where
-  fromRow = Income <$>
-    SQLite.field <*>
-    SQLite.field <*>
-    SQLite.field <*>
-    SQLite.field <*>
-    SQLite.field <*>
-    SQLite.field <*>
-    SQLite.field
-
-list :: Query [Income]
-list = Query (\conn -> SQLite.query_ conn "SELECT * FROM income WHERE deleted_at IS NULL")
-
-create :: UserId -> Day -> Int -> Query IncomeId
-create incomeUserId incomeDate incomeAmount =
-  Query (\conn -> do
-    now <- getCurrentTime
-    SQLite.execute
-      conn
-      "INSERT INTO income (user_id, date, amount, created_at) VALUES (?, ?, ?, ?)"
-      (incomeUserId, incomeDate, incomeAmount, now)
-    SQLite.lastInsertRowId conn
-  )
-
-editOwn :: UserId -> IncomeId -> Day -> Int -> Query Bool
-editOwn incomeUserId incomeId incomeDate incomeAmount =
-  Query (\conn -> do
-    mbIncome <- listToMaybe <$> SQLite.query conn "SELECT * FROM income WHERE id = ?" (Only incomeId)
-    case mbIncome of
-      Just income ->
-        if _income_userId income == incomeUserId
-          then do
-            now <- getCurrentTime
-            SQLite.execute
-              conn
-              "UPDATE income SET edited_at = ?, date = ?, amount = ? WHERE id = ?"
-              (now, incomeDate, incomeAmount, incomeId)
-            return True
-          else
-            return False
-      Nothing ->
-        return False
-  )
-
-deleteOwn :: User -> IncomeId -> Query Bool
-deleteOwn user incomeId =
-  Query (\conn -> do
-    mbIncome <- listToMaybe <$> SQLite.query conn "SELECT * FROM income WHERE id = ?" (Only incomeId)
-    case mbIncome of
-      Just income ->
-        if _income_userId income == _user_id user
-          then do
-            now <- getCurrentTime
-            SQLite.execute conn "UPDATE income SET deleted_at = ? WHERE id = ?" (now, incomeId)
-            return True
-          else
-            return False
-      Nothing ->
-        return False
-  )
diff --git a/server/src/Model/IncomeResource.hs b/server/src/Model/IncomeResource.hs
new file mode 100644
index 0000000..6ab5f18
--- /dev/null
+++ b/server/src/Model/IncomeResource.hs
@@ -0,0 +1,15 @@
+module Model.IncomeResource
+  ( IncomeResource(..)
+  ) where
+
+import           Common.Model (Income (..))
+
+import           Resource     (Resource, resourceCreatedAt, resourceDeletedAt,
+                               resourceEditedAt)
+
+newtype IncomeResource = IncomeResource Income
+
+instance Resource IncomeResource where
+  resourceCreatedAt (IncomeResource i) = _income_createdAt i
+  resourceEditedAt (IncomeResource i) = _income_editedAt i
+  resourceDeletedAt (IncomeResource i) = _income_deletedAt i
diff --git a/server/src/Model/Init.hs b/server/src/Model/Init.hs
deleted file mode 100644
index 0a0ffc7..0000000
--- a/server/src/Model/Init.hs
+++ /dev/null
@@ -1,25 +0,0 @@
-module Model.Init
-  ( getInit
-  ) where
-
-import           Common.Model          (Init (Init), User (..))
-
-import           Conf                  (Conf)
-import qualified Conf
-import qualified Model.Category        as Category
-import qualified Model.Income          as Income
-import qualified Model.Payment         as Payment
-import qualified Model.PaymentCategory as PaymentCategory
-import           Model.Query           (Query)
-import qualified Model.User            as User
-
-getInit :: User -> Conf -> Query Init
-getInit user conf =
-  Init <$>
-    User.list <*>
-    (return . _user_id $ user) <*>
-    Payment.listActive <*>
-    Income.list <*>
-    Category.list <*>
-    PaymentCategory.list <*>
-    (return . Conf.currency $ conf)
diff --git a/server/src/Model/Payment.hs b/server/src/Model/Payment.hs
deleted file mode 100644
index 5b29409..0000000
--- a/server/src/Model/Payment.hs
+++ /dev/null
@@ -1,169 +0,0 @@
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-
-module Model.Payment
-  ( Payment(..)
-  , find
-  , listActive
-  , listPunctual
-  , listActiveMonthlyOrderedByName
-  , create
-  , createMany
-  , editOwn
-  , deleteOwn
-  ) where
-
-import           Data.Maybe                     (listToMaybe)
-import           Data.Text                      (Text)
-import qualified Data.Text                      as T
-import           Data.Time.Calendar             (Day)
-import           Data.Time.Clock                (getCurrentTime)
-import           Database.SQLite.Simple         (FromRow (fromRow), Only (Only),
-                                                 ToRow)
-import qualified Database.SQLite.Simple         as SQLite
-import           Database.SQLite.Simple.ToField (ToField (toField))
-import           Prelude                        hiding (id)
-
-import           Common.Model                   (Frequency (..), Payment (..),
-                                                 PaymentId, UserId)
-
-import           Model.Frequency                ()
-import           Model.Query                    (Query (Query))
-import           Resource                       (Resource, resourceCreatedAt,
-                                                 resourceDeletedAt,
-                                                 resourceEditedAt)
-
-instance Resource Payment where
-  resourceCreatedAt = _payment_createdAt
-  resourceEditedAt = _payment_editedAt
-  resourceDeletedAt = _payment_deletedAt
-
-instance FromRow Payment where
-  fromRow = Payment <$>
-    SQLite.field <*>
-    SQLite.field <*>
-    SQLite.field <*>
-    SQLite.field <*>
-    SQLite.field <*>
-    SQLite.field <*>
-    SQLite.field <*>
-    SQLite.field <*>
-    SQLite.field
-
-instance ToRow Payment where
-  toRow p =
-    [ toField (_payment_user p)
-    , toField (_payment_name p)
-    , toField (_payment_cost p)
-    , toField (_payment_date p)
-    , toField (_payment_frequency p)
-    , toField (_payment_createdAt p)
-    ]
-
-find :: PaymentId -> Query (Maybe Payment)
-find paymentId =
-  Query (\conn -> listToMaybe <$>
-    SQLite.query conn "SELECT * FROM payment WHERE id = ?" (Only paymentId)
-  )
-
-listActive :: Query [Payment]
-listActive =
-  Query (\conn ->
-    SQLite.query_ conn "SELECT * FROM payment WHERE deleted_at IS NULL"
-  )
-
-listPunctual :: Query [Payment]
-listPunctual =
-  Query (\conn ->
-    SQLite.query
-      conn
-      (SQLite.Query "SELECT * FROM payment WHERE frequency = ?")
-      (Only Punctual))
-
-listActiveMonthlyOrderedByName :: Query [Payment]
-listActiveMonthlyOrderedByName =
-  Query (\conn ->
-    SQLite.query
-      conn
-      (SQLite.Query $ T.intercalate " "
-        [ "SELECT *"
-        , "FROM payment"
-        , "WHERE deleted_at IS NULL AND frequency = ?"
-        , "ORDER BY name DESC"
-        ])
-      (Only Monthly))
-
-create :: UserId -> Text -> Int -> Day -> Frequency -> Query PaymentId
-create userId paymentName paymentCost paymentDate paymentFrequency =
-  Query (\conn -> do
-    now <- getCurrentTime
-    SQLite.execute
-      conn
-      (SQLite.Query $ T.intercalate " "
-        [ "INSERT INTO payment (user_id, name, cost, date, frequency, created_at)"
-        , "VALUES (?, ?, ?, ?, ?, ?)"
-        ])
-      (userId, paymentName, paymentCost, paymentDate, paymentFrequency, now)
-    SQLite.lastInsertRowId conn
-  )
-
-createMany :: [Payment] -> Query ()
-createMany payments =
-  Query (\conn ->
-    SQLite.executeMany
-      conn
-      (SQLite.Query $ T.intercalate ""
-        [ "INSERT INTO payment (user_id, name, cost, date, frequency, created_at)"
-        , "VALUES (?, ?, ?, ?, ?, ?)"
-        ])
-      payments
-  )
-
-editOwn :: UserId -> PaymentId -> Text -> Int -> Day -> Frequency -> Query Bool
-editOwn userId paymentId paymentName paymentCost paymentDate paymentFrequency =
-  Query (\conn -> do
-    mbPayment <- listToMaybe <$>
-      SQLite.query conn "SELECT * FROM payment WHERE id = ?" (Only paymentId)
-    case mbPayment of
-      Just payment ->
-        if _payment_user payment == userId
-          then do
-            now <- getCurrentTime
-            SQLite.execute
-              conn
-              (SQLite.Query $ T.intercalate " "
-                [ "UPDATE payment"
-                , "SET edited_at = ?,"
-                , "    name = ?,"
-                , "    cost = ?,"
-                , "    date = ?,"
-                , "    frequency = ?"
-                , "WHERE id = ?"
-                ])
-              (now, paymentName, paymentCost, paymentDate, paymentFrequency, paymentId)
-            return True
-          else
-            return False
-      Nothing ->
-        return False
-  )
-
-deleteOwn :: UserId -> PaymentId -> Query Bool
-deleteOwn userId paymentId =
-  Query (\conn -> do
-    mbPayment <- listToMaybe <$>
-      SQLite.query conn "SELECT * FROM payment WHERE id = ?" (Only paymentId)
-    case mbPayment of
-      Just payment ->
-        if _payment_user payment == userId
-          then do
-            now <- getCurrentTime
-            SQLite.execute
-              conn
-              "UPDATE payment SET deleted_at = ? WHERE id = ?"
-              (now, paymentId)
-            return True
-          else
-            return False
-      Nothing ->
-        return False
-  )
diff --git a/server/src/Model/PaymentCategory.hs b/server/src/Model/PaymentCategory.hs
deleted file mode 100644
index c60c1a2..0000000
--- a/server/src/Model/PaymentCategory.hs
+++ /dev/null
@@ -1,61 +0,0 @@
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-
-module Model.PaymentCategory
-  ( list
-  , listByCategory
-  , save
-  ) where
-
-import           Data.Maybe             (isJust, listToMaybe)
-import           Data.Text              (Text)
-import qualified Data.Text              as T
-import           Data.Time.Clock        (getCurrentTime)
-import           Database.SQLite.Simple (FromRow (fromRow), Only (Only))
-import qualified Database.SQLite.Simple as SQLite
-
-import           Common.Model           (CategoryId, PaymentCategory (..))
-import qualified Common.Util.Text       as T
-
-import           Model.Query            (Query (Query))
-
-instance FromRow PaymentCategory where
-  fromRow = PaymentCategory <$>
-    SQLite.field <*>
-    SQLite.field <*>
-    SQLite.field <*>
-    SQLite.field <*>
-    SQLite.field
-
-list :: Query [PaymentCategory]
-list = Query (\conn -> SQLite.query_ conn "SELECT * from payment_category")
-
-listByCategory :: CategoryId -> Query [PaymentCategory]
-listByCategory cat =
-  Query (\conn ->
-    SQLite.query conn "SELECT * FROM payment_category WHERE category = ?" (Only cat)
-  )
-
-save :: Text -> CategoryId -> Query ()
-save newName categoryId =
-  Query (\conn -> do
-    now <- getCurrentTime
-    mbPaymentCategory <- listToMaybe <$>
-      (SQLite.query
-        conn
-        "SELECT * FROM payment_category WHERE name = ?"
-        (Only (formatPaymentName newName)) :: IO [PaymentCategory])
-    if isJust mbPaymentCategory
-      then
-        SQLite.execute
-          conn
-          "UPDATE payment_category SET category = ?, edited_at = ? WHERE name = ?"
-          (categoryId, now, formatPaymentName newName)
-      else do
-        SQLite.execute
-          conn
-          "INSERT INTO payment_category (name, category, created_at) VALUES (?, ?, ?)"
-          (formatPaymentName newName, categoryId, now)
-  )
-  where
-    formatPaymentName :: Text -> Text
-    formatPaymentName = T.unaccent . T.toLower
diff --git a/server/src/Model/PaymentResource.hs b/server/src/Model/PaymentResource.hs
new file mode 100644
index 0000000..1ea978c
--- /dev/null
+++ b/server/src/Model/PaymentResource.hs
@@ -0,0 +1,15 @@
+module Model.PaymentResource
+  ( PaymentResource(..)
+  ) where
+
+import           Common.Model (Payment (..))
+
+import           Resource     (Resource, resourceCreatedAt, resourceDeletedAt,
+                               resourceEditedAt)
+
+newtype PaymentResource = PaymentResource Payment
+
+instance Resource PaymentResource where
+  resourceCreatedAt (PaymentResource p) = _payment_createdAt p
+  resourceEditedAt (PaymentResource p) = _payment_editedAt p
+  resourceDeletedAt (PaymentResource p) = _payment_deletedAt p
diff --git a/server/src/Model/User.hs b/server/src/Model/User.hs
deleted file mode 100644
index 8dc1fc8..0000000
--- a/server/src/Model/User.hs
+++ /dev/null
@@ -1,48 +0,0 @@
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-
-module Model.User
-  ( list
-  , get
-  , create
-  , delete
-  ) where
-
-import           Data.Maybe             (listToMaybe)
-import           Data.Text              (Text)
-import           Data.Time.Clock        (getCurrentTime)
-import           Database.SQLite.Simple (FromRow (fromRow), Only (Only))
-import qualified Database.SQLite.Simple as SQLite
-import           Prelude                hiding (id)
-
-import           Common.Model           (User (..), UserId)
-
-import           Model.Query            (Query (Query))
-
-instance FromRow User where
-  fromRow = User <$> SQLite.field <*> SQLite.field <*> SQLite.field <*> SQLite.field
-
-list :: Query [User]
-list = Query (\conn -> SQLite.query_ conn "SELECT * from user ORDER BY creation DESC")
-
-get :: Text -> Query (Maybe User)
-get userEmail =
-  Query (\conn -> listToMaybe <$>
-    SQLite.query conn "SELECT * FROM user WHERE email = ? LIMIT 1" (Only userEmail)
-  )
-
-create :: Text -> Text -> Query UserId
-create userEmail userName =
-  Query (\conn -> do
-    now <- getCurrentTime
-    SQLite.execute
-      conn
-      "INSERT INTO user (creation, email, name) VALUES (?, ?, ?)"
-      (now, userEmail, userName)
-    SQLite.lastInsertRowId conn
-  )
-
-delete :: Text -> Query ()
-delete userEmail =
-  Query (\conn ->
-    SQLite.execute conn "DELETE FROM user WHERE email = ?" (Only userEmail)
-  )