src/API/Books.hs

@@ -21,9 +21,9 @@ import ClassyPrelude
 import Server.Auth
 import Servant.Auth as SA
 import Data.Aeson
+import API.Channels (JsonChannel(..))
 import Database.Book
 import Database.Channel
-import Database.Tag
 import Database
 import Control.Lens
 import Data.Generics.Product
@@ -38,15 +38,13 @@ data JsonBook = JsonBook { identifier :: BookID
                          , contentType :: Text
                          , title :: Maybe Text
                          , description :: Maybe Text
-                         , channels :: [Text]
-                         , tags :: [Text] }
+                         , channels :: [JsonChannel] }
               deriving (Generic, Show)
 
 data PostBook = PostBook { contentType :: Text
                          , title :: Maybe Text
                          , description :: Maybe Text
-                         , channels :: [Text]
-                         , tags :: [Text] }
+                         , channels :: [JsonChannel] }
               deriving (Generic, Show)
 
 
@@ -107,6 +105,5 @@ listBooksHandler = requireLoggedIn $ \user -> do
   runDB (usersBooks (view (field @"username") user) >>= mapM augment)
     where
       augment Book{identifier=bookId,contentType,title,description} = do
-        channels <- fmap (view (field @"channel")) <$> booksChannels bookId
-        tags <- fmap (view (field @"tag")) <$> booksTags bookId
+        channels <- fmap (\Channel{..} -> JsonChannel{..}) <$> booksChannels bookId
         pure JsonBook{identifier=bookId,..}

src/Database.hs

@@ -11,7 +11,6 @@ module Database
   , fromRel
   , fromRels
   , toRel
-  , transaction
   , SeldaT )
   where
 
@@ -19,7 +18,7 @@ import Data.Generics.Product
 import Control.Lens (view)
 import Data.Pool (Pool, withResource)
 import Database.Selda.Backend (SeldaConnection, runSeldaT, SeldaT)
-import Database.Selda (query, select, transaction)
+import Database.Selda (query, select)
 import Database.Selda.Generic (gen, fromRel, fromRels, toRel)
 import ClassyPrelude
 

src/Database/Book.hs

@@ -18,13 +18,11 @@ module Database.Book
   , BookID) where
 
 import ClassyPrelude
-import Database.Schema (books, users, Username, Book(..), BookID(..), UserID, HashDigest(..))
+import Database.Schema
 import Database
 import Database.Selda
 import Database.Selda.Generic
 
-import Database.Tag (attachTag)
-
 usersBooks :: (MonadSelda m, MonadMask m, MonadIO m) => Username -> m [Book]
 usersBooks username = fromRels <$> query q
   where
@@ -66,8 +64,7 @@ data UpdateBook = UpdateBook { identifier :: BookID
                              , contentType :: Text
                              , title :: Maybe Text
                              , description :: Maybe Text
-                             , owner :: Username
-                             , tags :: [Text]}
+                             , owner :: Username }
 
 bookExists :: (MonadSelda m, MonadMask m, MonadIO m) => BookID -> m Bool
 bookExists identifier = not . null <$> query q
@@ -91,19 +88,13 @@ bookOwner' identifier username = do
 
 updateBook :: (MonadSelda m, MonadMask m, MonadIO m) => UpdateBook -> m (Maybe UpdateBook)
 updateBook book@UpdateBook{..} = do
-  connectChannels
-  connectTags
-  updateBook'
+  mUserId <- query (bookOwner' identifier owner)
+  forM (listToMaybe mUserId) $ \_userId -> do
+    update_ (gen books) predicate (\b -> b `with` [ pContentType := literal contentType
+                                                  , pTitle := literal title
+                                                  , pDescription := literal description ])
+    return book
   where
-    connectTags = mapM_ (attachTag owner identifier) tags
-    connectChannels = return ()
-    updateBook' = do
-      mUserId <- query (bookOwner' identifier owner)
-      forM (listToMaybe mUserId) $ \_userId -> do
-        update_ (gen books) predicate (\b -> b `with` [ pContentType := literal contentType
-                                                      , pTitle := literal title
-                                                      , pDescription := literal description ])
-        return book
     _ :*: _ :*: pContentType :*: pTitle :*: pDescription :*: _ = selectors (gen books)
     predicate (bookId :*: _) = bookId .== literal identifier
 

src/Database/Tag.hs

@@ -2,11 +2,9 @@
 {-# Language TypeOperators #-}
 {-# Language DataKinds #-}
 {-# Language DuplicateRecordFields #-}
-{-# Language NamedFieldPuns #-}
 module Database.Tag
   ( def
   , booksTags
-  , attachTag
   , upsertTag
   , Tag(..) ) where
 
@@ -14,12 +12,11 @@ import ClassyPrelude
 import Database.Schema
 import Database
 import Database.Selda
-import Database.Selda.Generic
 
 upsertTag :: (MonadMask m, MonadIO m, MonadSelda m) => Username -> Text -> m Tag
-upsertTag username tag = do
+upsertTag username tag = transaction $ do
   -- I want this to error out if some data is invariant is wrong and roll back
-  -- the transaction. Also as a side note, run this in a transaction plz
+  -- the transaction
   [userId] <- query userQ
   void $ upsert (gen tags) (predicate userId) id [toRel (Tag def tag userId)]
   [t] <- fromRels <$> query (tagQ userId)
@@ -44,14 +41,3 @@ booksTags bookId = fromRels <$> query q
       restrict (tagId .== tagId')
       restrict (bookId' .== literal bookId)
       return tag
-
-attachTag :: (MonadMask m, MonadIO m, MonadSelda m) => Username -> BookID -> Text -> m ()
-attachTag username bookId tag = do
-  Tag{identifier} <- upsertTag username tag
-  whenM (null <$> query (tagQ identifier)) $
-    void $ insertGen bookTags [BookTag identifier bookId]
-  where
-    tagQ tagId = do
-      (tagId' :*: bookId') <- select (gen bookTags)
-      restrict (tagId' .== literal tagId .&& bookId' .== literal bookId)
-      return tagId'