Remove payment category if unused after a payment is deleted

6 files changed, 75 insertions, 85 deletions

diff --git a/server/src/Controller/Income.hs b/server/src/Controller/Income.hs
index 3f623e5..ed58ac8 100644
--- a/server/src/Controller/Income.hs
+++ b/server/src/Controller/Income.hs
@@ -1,17 +1,15 @@
 module Controller.Income
   ( create
-  , editOwn
-  , deleteOwn
+  , edit
+  , delete
   ) where
 
 import           Control.Monad.IO.Class    (liftIO)
-import qualified Data.Text.Lazy            as TL
-import           Network.HTTP.Types.Status (badRequest400, ok200)
-import           Web.Scotty
+import qualified Network.HTTP.Types.Status as Status
+import           Web.Scotty                hiding (delete)
 
 import           Common.Model              (CreateIncome (..), EditIncome (..),
                                             IncomeId, User (..))
-import qualified Common.Msg                as Msg
 
 import           Json                      (jsonId)
 import qualified Model.Query               as Query
@@ -24,23 +22,18 @@ create (CreateIncome date amount) =
     (liftIO . Query.run $ IncomePersistence.create (_user_id user) date amount) >>= jsonId
   )
 
-editOwn :: EditIncome -> ActionM ()
-editOwn (EditIncome incomeId date amount) =
+edit :: EditIncome -> ActionM ()
+edit (EditIncome incomeId date amount) =
   Secure.loggedAction (\user -> do
-    updated <- liftIO . Query.run $ IncomePersistence.editOwn (_user_id user) incomeId date amount
+    updated <- liftIO . Query.run $ IncomePersistence.edit (_user_id user) incomeId date amount
     if updated
-      then status ok200
-      else status badRequest400
+      then status Status.ok200
+      else status Status.badRequest400
   )
 
-deleteOwn :: IncomeId -> ActionM ()
-deleteOwn incomeId =
+delete :: IncomeId -> ActionM ()
+delete incomeId =
   Secure.loggedAction (\user -> do
-    deleted <- liftIO . Query.run $ IncomePersistence.deleteOwn user incomeId
-    if deleted
-      then
-        status ok200
-      else do
-        status badRequest400
-        text . TL.fromStrict $ Msg.get Msg.Income_NotDeleted
+    _ <- liftIO . Query.run $ IncomePersistence.delete (_user_id user) incomeId
+    status Status.ok200
   )
diff --git a/server/src/Controller/Payment.hs b/server/src/Controller/Payment.hs
index e82fd49..3d857be 100644
--- a/server/src/Controller/Payment.hs
+++ b/server/src/Controller/Payment.hs
@@ -1,18 +1,18 @@
 module Controller.Payment
   ( list
   , create
-  , editOwn
-  , deleteOwn
+  , edit
+  , delete
   ) where
 
 import           Control.Monad.IO.Class      (liftIO)
 import qualified Network.HTTP.Types.Status   as Status
-import           Web.Scotty
+import           Web.Scotty                  hiding (delete)
 
 import           Common.Model                (CreatePayment (..),
                                               CreatedPayment (..),
-                                              EditPayment (..), PaymentId,
-                                              User (..))
+                                              EditPayment (..), Payment (..),
+                                              PaymentId, User (..))
 import qualified Model.Query                 as Query
 import qualified Persistence.Payment         as PaymentPersistence
 import qualified Persistence.PaymentCategory as PaymentCategoryPersistence
@@ -41,11 +41,11 @@ create createPayment@(CreatePayment name cost date category frequency) =
           json validationError
   )
 
-editOwn :: EditPayment -> ActionM ()
-editOwn (EditPayment paymentId name cost date category frequency) =
+edit :: EditPayment -> ActionM ()
+edit (EditPayment paymentId name cost date category frequency) =
   Secure.loggedAction (\user -> do
     updated <- liftIO . Query.run $ do
-      edited <- PaymentPersistence.editOwn (_user_id user) paymentId name cost date frequency
+      edited <- PaymentPersistence.edit (_user_id user) paymentId name cost date frequency
       _ <- if edited
         then PaymentCategoryPersistence.save name category >> return ()
         else return ()
@@ -55,11 +55,20 @@ editOwn (EditPayment paymentId name cost date category frequency) =
       else status Status.badRequest400
   )
 
-deleteOwn :: PaymentId -> ActionM ()
-deleteOwn paymentId =
+delete :: PaymentId -> ActionM ()
+delete paymentId =
   Secure.loggedAction (\user -> do
-    deleted <- liftIO . Query.run $ PaymentPersistence.deleteOwn (_user_id user) paymentId
-    if deleted
-      then status Status.ok200
-      else status Status.badRequest400
+    deleted <- liftIO . Query.run $ do
+      payment <- PaymentPersistence.find paymentId
+      case payment of
+        Just p | _payment_user p == _user_id user -> do
+          PaymentPersistence.delete (_user_id user) paymentId
+          PaymentCategoryPersistence.deleteIfUnused (_payment_name p)
+          return True
+        _ ->
+          return False
+    if deleted then
+      status Status.ok200
+    else
+      status Status.badRequest400
   )
diff --git a/server/src/Main.hs b/server/src/Main.hs
index 745071c..0ccf5e2 100644
--- a/server/src/Main.hs
+++ b/server/src/Main.hs
@@ -35,21 +35,21 @@ main = do
       S.jsonData >>= Payment.create
 
     S.put "/payment" $
-      S.jsonData >>= Payment.editOwn
+      S.jsonData >>= Payment.edit
 
     S.delete "/payment/:id" $ do
       paymentId <- S.param "id"
-      Payment.deleteOwn paymentId
+      Payment.delete paymentId
 
     S.post "/income" $
       S.jsonData >>= Income.create
 
     S.put "/income" $
-      S.jsonData >>= Income.editOwn
+      S.jsonData >>= Income.edit
 
     S.delete "/income/:id" $ do
       incomeId <- S.param "id"
-      Income.deleteOwn incomeId
+      Income.delete incomeId
 
     S.post "/category" $
       S.jsonData >>= Category.create
diff --git a/server/src/Persistence/Income.hs b/server/src/Persistence/Income.hs
index a863f85..cee9892 100644
--- a/server/src/Persistence/Income.hs
+++ b/server/src/Persistence/Income.hs
@@ -1,8 +1,8 @@
 module Persistence.Income
   ( list
   , create
-  , editOwn
-  , deleteOwn
+  , edit
+  , delete
   ) where
 
 import           Data.Maybe             (listToMaybe)
@@ -12,7 +12,7 @@ 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 (..),
+import           Common.Model           (Income (..), IncomeId, PaymentId,
                                          UserId)
 
 import           Model.Query            (Query (Query))
@@ -47,8 +47,8 @@ create incomeUserId incomeDate incomeAmount =
     SQLite.lastInsertRowId conn
   )
 
-editOwn :: UserId -> IncomeId -> Day -> Int -> Query Bool
-editOwn incomeUserId incomeId incomeDate incomeAmount =
+edit :: UserId -> IncomeId -> Day -> Int -> Query Bool
+edit incomeUserId incomeId incomeDate incomeAmount =
   Query (\conn -> do
     mbIncome <- fmap (\(Row i) -> i) . listToMaybe <$>
       SQLite.query conn "SELECT * FROM income WHERE id = ?" (Only incomeId)
@@ -68,21 +68,11 @@ editOwn incomeUserId incomeId incomeDate incomeAmount =
         return False
   )
 
-deleteOwn :: User -> IncomeId -> Query Bool
-deleteOwn user incomeId =
-  Query (\conn -> do
-    mbIncome <-
-      fmap (\(Row i) -> i) . 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
+delete :: UserId -> PaymentId -> Query ()
+delete userId paymentId =
+  Query (\conn ->
+    SQLite.execute
+      conn
+      "UPDATE income SET deleted_at = datetime('now') WHERE id = ? AND user_id = ?"
+      (paymentId, userId)
   )
diff --git a/server/src/Persistence/Payment.hs b/server/src/Persistence/Payment.hs
index 272cd39..3d8f129 100644
--- a/server/src/Persistence/Payment.hs
+++ b/server/src/Persistence/Payment.hs
@@ -6,8 +6,8 @@ module Persistence.Payment
   , listActiveMonthlyOrderedByName
   , create
   , createMany
-  , editOwn
-  , deleteOwn
+  , edit
+  , delete
   ) where
 
 import           Data.Maybe                     (listToMaybe)
@@ -129,8 +129,8 @@ createMany payments =
       (map InsertRow payments)
   )
 
-editOwn :: UserId -> PaymentId -> Text -> Int -> Day -> Frequency -> Query Bool
-editOwn userId paymentId paymentName paymentCost paymentDate paymentFrequency =
+edit :: UserId -> PaymentId -> Text -> Int -> Day -> Frequency -> Query Bool
+edit userId paymentId paymentName paymentCost paymentDate paymentFrequency =
   Query (\conn -> do
     mbPayment <- fmap (\(Row p) -> p) . listToMaybe <$>
       SQLite.query conn "SELECT * FROM payment WHERE id = ?" (Only paymentId)
@@ -158,23 +158,11 @@ editOwn userId paymentId paymentName paymentCost paymentDate paymentFrequency =
         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 (Row 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
+delete :: UserId -> PaymentId -> Query ()
+delete userId paymentId =
+  Query (\conn ->
+    SQLite.execute
+      conn
+      "UPDATE payment SET deleted_at = datetime('now') WHERE id = ? AND user_id = ?"
+      (paymentId, userId)
   )
diff --git a/server/src/Persistence/PaymentCategory.hs b/server/src/Persistence/PaymentCategory.hs
index 5fd035a..7dc363c 100644
--- a/server/src/Persistence/PaymentCategory.hs
+++ b/server/src/Persistence/PaymentCategory.hs
@@ -2,16 +2,17 @@ module Persistence.PaymentCategory
   ( list
   , listByCategory
   , save
+  , deleteIfUnused
   ) where
 
 import qualified Data.Maybe             as Maybe
 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))
 
@@ -76,4 +77,13 @@ save newName categoryId =
             Nothing
   )
   where
-    formattedNewName = T.formatSearch newName
+    formattedNewName = T.toLower newName
+
+deleteIfUnused :: Text -> Query ()
+deleteIfUnused name =
+  Query (\conn ->
+    SQLite.execute
+      conn
+      "DELETE FROM payment_category WHERE name = lower(?) AND name IN (SELECT DISTINCT lower(name) FROM payment WHERE name = lower(?) AND deleted_at IS NOT NULL)"
+      (name, name)
+  ) >> return ()