Complete functions (#15)

src/API/Books.hs

@@ -97,9 +97,9 @@ postBookMetaHandler auth PostBook{..} = flip requireLoggedIn auth $ \SafeUser{us
 
 
 putBookMetaHandler :: AuthResult SafeUser -> BookID -> JsonBook -> AppM JsonBook
-putBookMetaHandler auth bookId b@JsonBook{..}
+putBookMetaHandler auth bookId JsonBook{..}
   | bookId == identifier = requireBookOwner auth bookId $ \SafeUser{username=owner} ->
-        maybe (throwM err403) (const (return b)) =<< runDB (updateBook UpdateBook{..})
+        maybe (throwM err403) (return . view (super @JsonBook)) =<< runDB (updateBook UpdateBook{..})
   | otherwise = throwM err403
 
 listBooksHandler :: AuthResult SafeUser -> AppM [JsonBook]

src/Database/Book.hs

@@ -23,8 +23,11 @@ import Database
 import Database.Selda
 import Database.Selda.Generic
 
-import Database.Tag (attachTag, clearTags)
+import Control.Lens (view)
-import Database.Channel (attachChannel, clearChannels)
+import Data.Generics.Product
+
+import Database.Tag (booksTags, attachTag, clearTags)
+import Database.Channel (booksChannels, attachChannel, clearChannels)
 
 usersBooks :: (MonadSelda m, MonadMask m, MonadIO m) => Username -> m [Book]
 usersBooks username = fromRels <$> query q
@@ -70,6 +73,7 @@ data UpdateBook = UpdateBook { identifier :: BookID
                              , owner :: Username
                              , tags :: [Text]
                              , channels :: [Text] }
+                deriving (Show, Generic)
 
 bookExists :: (MonadSelda m, MonadMask m, MonadIO m) => BookID -> m Bool
 bookExists identifier = not . null <$> query q
@@ -92,23 +96,32 @@ bookOwner' identifier username = do
   return (userId :*: bookId)
 
 updateBook :: (MonadSelda m, MonadMask m, MonadIO m) => UpdateBook -> m (Maybe UpdateBook)
-updateBook book@UpdateBook{..} = do
+updateBook UpdateBook{..} = do
   clearTags identifier >> connectTags
   clearChannels identifier >> connectChannels
   updateBook'
+  getUpdateBook identifier owner
   where
     connectTags = mapM_ (attachTag owner identifier) tags
     connectChannels = mapM_ (attachChannel owner identifier) channels
     updateBook' = do
       mUserId <- query (bookOwner' identifier owner)
-      forM (listToMaybe mUserId) $ \_userId -> do
+      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
 
+
+getUpdateBook :: (MonadMask m, MonadIO m, MonadSelda m) => BookID -> Username -> m (Maybe UpdateBook)
+getUpdateBook bookId username = do
+  mBook <- getBook bookId username
+  forM mBook $ \Book{..} -> do
+    channels <- map (view (field @"channel")) <$> booksChannels bookId
+    tags <- map (view (field @"tag")) <$> booksTags bookId
+    return UpdateBook{owner=username,..}
+
 setContent :: (MonadSelda m, MonadMask m, MonadIO m) => BookID -> Username -> HashDigest -> m ()
 setContent identifier owner digest = do
   mOwner <- query (bookOwner' identifier owner)

src/Database/Channel.hs

@@ -39,7 +39,7 @@ insertChannel username channel = do
       restrict (user .== literal username)
       return userId
 
-booksChannels :: (MonadMask m, MonadIO m) => BookID -> SeldaT m [Channel]
+booksChannels :: (MonadSelda m, MonadMask m, MonadIO m) => BookID -> m [Channel]
 booksChannels bookId = fromRels <$> query q
   where
     q = do
@@ -51,10 +51,10 @@ booksChannels bookId = fromRels <$> query q
 
 attachChannel :: (MonadMask m, MonadIO m, MonadSelda m) => Username -> BookID -> Text -> m ()
 attachChannel username bookId channel = do
-  -- XXX: test what happens if channel doesn't exist
+  mCh <- fromRels <$> query channelQ
-  [Channel{identifier}] <- fromRels <$> query channelQ
+  forM_ mCh $ \Channel{identifier} ->
-  whenM (null <$> query (attachQ identifier)) $
+    whenM (null <$> query (attachQ identifier)) $
-    void $ insertGen bookChannels [BookChannel identifier bookId]
+      void $ insertGen bookChannels [BookChannel identifier bookId]
   where
     attachQ channelId = do
       (channelId' :*: bookId') <- select (gen bookChannels)

src/Database/Tag.hs

@@ -16,15 +16,13 @@ import Database.Schema
 import Database
 import Database.Selda
 import Database.Selda.Generic
+import Control.Monad.Trans.Maybe
 
-upsertTag :: (MonadMask m, MonadIO m, MonadSelda m) => Username -> Text -> m Tag
+upsertTag :: (MonadMask m, MonadIO m, MonadSelda m) => Username -> Text -> m (Maybe Tag)
-upsertTag username tag = do
+upsertTag username tag = runMaybeT $ do
-  -- I want this to error out if some data is invariant is wrong and roll back
+  userId <- MaybeT (listToMaybe <$> query userQ)
-  -- the transaction. Also as a side note, run this in a transaction plz
+  void $ lift $ upsert (gen tags) (predicate userId) id [toRel (Tag def tag userId)]
-  [userId] <- query userQ
+  MaybeT (listToMaybe . fromRels <$> query (tagQ userId))
-  void $ upsert (gen tags) (predicate userId) id [toRel (Tag def tag userId)]
-  [t] <- fromRels <$> query (tagQ userId)
-  return t
   where
     predicate userId (_ :*: tag' :*: owner) = tag' .== literal tag .&& owner .== literal userId
     tagQ userId = do
@@ -48,9 +46,10 @@ booksTags bookId = fromRels <$> query q
 
 attachTag :: (MonadMask m, MonadIO m, MonadSelda m) => Username -> BookID -> Text -> m ()
 attachTag username bookId tag = do
-  Tag{identifier} <- upsertTag username tag
+  maybeT <- upsertTag username tag
-  whenM (null <$> query (tagQ identifier)) $
+  forM_ maybeT $ \Tag{identifier} -> do
-    void $ insertGen bookTags [BookTag identifier bookId]
+    whenM (null <$> query (tagQ identifier)) $
+      void $ insertGen bookTags [BookTag identifier bookId]
   where
     tagQ tagId = do
       (tagId' :*: bookId') <- select (gen bookTags)