Complete functions (#15)

Extended description

ebook-manager.cabal

@@ -1,3 +1,6 @@
+-- Initial ebook-manager.cabal generated by cabal init.  For further
+-- documentation, see http://haskell.org/cabal/users-guide/
+
 name:                ebook-manager
 version:             0.1.0.0
 -- synopsis:

migrations/V1.1__Channel_visibility.sql

@@ -1 +0,0 @@
-alter table channels add column visibility text NOT NULL default 'Private';

src/API.hs

@@ -27,8 +27,8 @@ data Index = Index
 
 type API = Get '[HTML] (AppView Index)
       :<|> Users.API
-      :<|> "api" :> "current" :> Channels.API
+      :<|> "api" :> Channels.API
-      :<|> "api" :> "current" :> Books.API
+      :<|> "api" :> Books.API
       :<|> "api" :> "1" :> Catalogue.VersionedAPI 1
       :<|> "api" :> "current" :> Catalogue.VersionedAPI 1
 

src/API/Books.hs

@@ -36,14 +36,14 @@ import Crypto.Hash (digestFromByteString)
 
 data JsonBook = JsonBook { identifier :: BookID
                          , contentType :: Text
-                         , title :: Text
+                         , title :: Maybe Text
                          , description :: Maybe Text
                          , channels :: [Text]
                          , tags :: [Text] }
               deriving (Generic, Show)
 
 data PostBook = PostBook { contentType :: Text
-                         , title :: Text
+                         , title :: Maybe Text
                          , description :: Maybe Text
                          , channels :: [Text]
                          , tags :: [Text] }
@@ -61,9 +61,7 @@ type BaseAPI = "books" :> Get '[JSON] [JsonBook]
        :<|> "books" :> ReqBody '[JSON] PostBook :> Post '[JSON] JsonBook
        :<|> "books" :> Capture "book_id" BookID :> "meta" :> ReqBody '[JSON] JsonBook :> Put '[JSON] JsonBook
        :<|> "books" :> Capture "book_id" BookID :> ReqBody '[OctetStream] ByteString :> Put '[JSON] NoContent
-       :<|> GetBook
+       :<|> "books" :> Capture "book_id" BookID :> Get '[OctetStream] ByteString
-
-type GetBook = "books" :> Capture "book_id" BookID :> Get '[OctetStream] ByteString
 
 handler :: ServerT API AppM
 handler user = listBooksHandler user

src/API/Catalogue.hs

@@ -17,16 +17,14 @@
 module API.Catalogue (VersionedAPI, handler) where
 
 import Types
-import Servant hiding (contentType)
+import Servant
 import ClassyPrelude
 import GHC.TypeLits
 import Server.Auth
 import Servant.Auth as SA
 import Servant.XML
 import qualified Database.Channel as Channel
-import Database.Book (Book(..))
 import Database
-import qualified API.Books
 
 -- This is my first try on going to versioned apis, things might change
 -- I think my rule of thumb is that you can add new things as you want, but
@@ -98,57 +96,30 @@ instance ToNode (Catalog 1) where
 
 class Monad m => VersionedCatalog m (v :: Nat) where
   getChannels :: SafeUser -> m (Catalog v)
-  getBooks :: Channel.ChannelID -> SafeUser -> m (Catalog v)
 
 instance VersionedCatalog AppM 1 where
-  getChannels = getChannelsV1
+  getChannels SafeUser{username} = do
-  getBooks = getBooksV1
+    updated <- liftIO getCurrentTime
-
+    let self = Rel ("/api/current/" <> selfUrl)
-relUrl :: Link -> Rel
+        -- I'm not sure if this safe link approach is really useable with this
-relUrl x = Rel ("/api/current/" <> (pack . uriPath . linkURI $ x))
+        -- api hierarchy since I can't access the topmost api from here. Also
-
+        -- authentication would bring a little bit of extra effort as well
-getBooksV1 :: Channel.ChannelID -> SafeUser -> AppM (Catalog 1)
+        selfUrl = pack . uriPath . linkURI $ safeLink (Proxy @(BaseAPI 1)) (Proxy @(RootCatalog 1))
-getBooksV1 channelID SafeUser{username} = do
+        start = self
-  updated <- liftIO getCurrentTime
+        pagination = Pagination Nothing Nothing
-  let self = relUrl selfUrl
+    entries <- map (fromChannel updated) <$> runDB (Channel.userChannels username)
-      start = relUrl startUrl
+    pure CatalogV1{..}
-      selfUrl = safeLink (Proxy @(BaseAPI 1)) (Proxy @(ChannelCatalog 1)) channelID
+    where
-      startUrl = safeLink (Proxy @(BaseAPI 1)) (Proxy @(RootCatalog 1))
+      fromChannel :: UTCTime -> Channel.Channel -> Entry 1
-      pagination = Pagination Nothing Nothing
+      fromChannel updated Channel.Channel{..} =
-  entries <- map (toEntry updated) <$> runDB (Channel.channelBooks username channelID)
+        let url = pack . uriPath . linkURI $ safeLink (Proxy @(BaseAPI 1)) (Proxy @(ChannelCatalog 1)) identifier
-  pure CatalogV1{..}
+            self = Rel ("/api/current/" <> url)
-  where
+        in EntryV1 channel channel updated channel (Left $ SubSection self)
-    toEntry updated Book{description,title,identifier=bookId} =
-      let content = fromMaybe "no content" description
-          identifier = pack . show $ bookId
-          link = Right (Acquisition (relUrl (safeLink (Proxy @API.Books.BaseAPI) (Proxy @API.Books.GetBook) bookId)))
-      in EntryV1{..}
-
-getChannelsV1 :: SafeUser -> AppM (Catalog 1)
-getChannelsV1 SafeUser{username} = do
-  updated <- liftIO getCurrentTime
-  let self = relUrl selfUrl
-      -- I'm not sure if this safe link approach is really useable with this
-      -- api hierarchy since I can't access the topmost api from here. Also
-      -- authentication would bring a little bit of extra effort as well
-      selfUrl = safeLink (Proxy @(BaseAPI 1)) (Proxy @(RootCatalog 1))
-      start = self
-      pagination = Pagination Nothing Nothing
-  entries <- map (fromChannel updated) <$> runDB (Channel.userChannels username)
-  pure CatalogV1{..}
-  where
-    fromChannel :: UTCTime -> Channel.Channel -> Entry 1
-    fromChannel updated Channel.Channel{..} =
-      let url = safeLink (Proxy @(BaseAPI 1)) (Proxy @(ChannelCatalog 1)) identifier
-          self = relUrl url
-      in EntryV1 channel channel updated channel (Left $ SubSection self)
 
 type VersionedAPI (v :: Nat) = Auth '[SA.BasicAuth, SA.JWT] SafeUser :> BaseAPI v
 
-type CatalogContent = '[XML, OPDS]
+type RootCatalog (v :: Nat) = "catalog" :> Get '[XML] (Catalog v)
-
+type ChannelCatalog (v :: Nat) = "catalog" :> "channel" :> Capture "channel_id" Channel.ChannelID :> Get '[XML] (Catalog v)
-type RootCatalog (v :: Nat) = "catalog" :> Get CatalogContent (Catalog v)
-type ChannelCatalog (v :: Nat) = "catalog" :> "channel" :> Capture "channel_id" Channel.ChannelID :> Get CatalogContent (Catalog v)
 type BaseAPI (v :: Nat) = RootCatalog v
                     :<|> ChannelCatalog v
 
@@ -156,8 +127,6 @@ handler :: forall v. VersionedCatalog AppM v => ServerT (VersionedAPI v) AppM
 handler auth = catalogRoot :<|> catalogChannels
   where
     catalogChannels :: Channel.ChannelID -> AppM (Catalog v)
-    -- Channel specific catalog returns tags inside the catalog
+    catalogChannels _ = throwM err403{errBody="Not implemented"}
-    catalogChannels identifier = flip requireLoggedIn auth (getBooks identifier)
     catalogRoot :: AppM (Catalog v)
-    -- catalog root returns channels
     catalogRoot = flip requireLoggedIn auth getChannels

src/API/Channels.hs

@@ -11,8 +11,6 @@
 {-# Language FlexibleInstances #-}
 {-# Language TypeApplications #-}
 {-# Language DataKinds #-}
-{-# Language DuplicateRecordFields #-}
-{-# Language NamedFieldPuns #-}
 module API.Channels (API, handler, JsonChannel(..)) where
 
 import Servant
@@ -27,37 +25,18 @@ import Data.Aeson
 import Control.Lens
 import Data.Generics.Product
 
-data JsonChannel = JsonChannel { channel :: Text
+data JsonChannel = JsonChannel { channel :: Text } deriving (Show, Generic)
-                               , visibility :: Visibility }
-                 deriving (Show, Generic)
-data UpdateChannel = UpdateChannel { identifier :: ChannelID
-                                   , channel :: Text
-                                   , visibility :: Visibility }
-                 deriving (Show, Generic)
 
 instance ToJSON JsonChannel
 instance FromJSON JsonChannel
-instance ToJSON UpdateChannel
-instance FromJSON UpdateChannel
 
 type API = Auth '[SA.BasicAuth, SA.Cookie, SA.JWT] SafeUser :> BaseAPI
 
-type BaseAPI = "channels" :> ReqBody '[JSON] JsonChannel :> Post '[JSON] UpdateChannel
+type BaseAPI = "channels" :> ReqBody '[JSON] JsonChannel :> Put '[JSON] JsonChannel
-          :<|> "channels" :> Capture "channel_id" ChannelID :> ReqBody '[JSON] UpdateChannel :> Put '[JSON] UpdateChannel
           :<|> "channels" :> Get '[JSON] [JsonChannel]
 
 handler :: ServerT API AppM
-handler user = newChannelHandler user :<|> updateChannelHandler user :<|> listChannelsHandler user
+handler user = newChannelHandler user :<|> listChannelsHandler user
-
-requireChannelOwner :: AuthResult SafeUser -> ChannelID -> (SafeUser -> AppM a) -> AppM a
-requireChannelOwner auth channelId f = flip requireLoggedIn auth $ \u@SafeUser{username} -> do
-  unlessM (runDB . channelExists $ channelId) $ throwM err404
-  runDB (isChannelOwner channelId username) >>= \o -> if o then f u else throwM err403
-
-updateChannelHandler :: AuthResult SafeUser -> ChannelID -> UpdateChannel -> AppM UpdateChannel
-updateChannelHandler auth channelId UpdateChannel{visibility} = requireChannelOwner auth channelId $ \_ -> do
-  mChannel <- fmap toChannel <$> runDB (updateChannelPrivacy channelId visibility)
-  maybe (throwM err403) return mChannel
 
 listChannelsHandler :: AuthResult SafeUser -> AppM [JsonChannel]
 listChannelsHandler = requireLoggedIn $ \user ->
@@ -65,11 +44,8 @@ listChannelsHandler = requireLoggedIn $ \user ->
   -- use the 'channel' accessor somehow or export it
   fmap (\Channel{..} -> JsonChannel{..}) <$> runDB (userChannels (view (field @"username") user))
 
-newChannelHandler :: AuthResult SafeUser -> JsonChannel -> AppM UpdateChannel
+newChannelHandler :: AuthResult SafeUser -> JsonChannel -> AppM JsonChannel
-newChannelHandler auth JsonChannel{..} = flip requireLoggedIn auth $ \user -> do
+newChannelHandler auth ch@JsonChannel{..} = flip requireLoggedIn auth $ \user -> do
   $logInfo $ "Creating channel for user " <> pack (show user)
-  mChannel <- fmap toChannel <$> runDB (insertChannel (view (field @"username") user) channel visibility)
+  runDB (insertChannel (view (field @"username") user) channel)
-  maybe (throwM err403{errBody="Could not create the channel"}) return mChannel
+  return ch
-
-toChannel :: Channel -> UpdateChannel
-toChannel Channel{..} = UpdateChannel{..}

src/Database/Book.hs

@@ -51,7 +51,7 @@ getBook identifier owner = listToMaybe . fromRels <$> query q
       return book
 
 data InsertBook = InsertBook { contentType :: Text
-                             , title :: Text
+                             , title :: Maybe Text
                              , description :: Maybe Text
                              , owner :: Username }
 
@@ -68,7 +68,7 @@ insertBook InsertBook{..} = do
 
 data UpdateBook = UpdateBook { identifier :: BookID
                              , contentType :: Text
-                             , title :: Text
+                             , title :: Maybe Text
                              , description :: Maybe Text
                              , owner :: Username
                              , tags :: [Text]

src/Database/Channel.hs

@@ -4,16 +4,11 @@
 module Database.Channel
   ( userChannels
   , insertChannel
-  , channelExists
-  , isChannelOwner
-  , updateChannelPrivacy
   , attachChannel
-  , Visibility(..)
   , clearChannels
   , booksChannels
-  , channelBooks
   , Channel(..)
-  , ChannelID(..) )
+  , ChannelID )
   where
 
 import ClassyPrelude
@@ -22,78 +17,28 @@ import Database
 import Database.Selda
 import Database.Selda.Generic
 
-import Control.Monad.Trans.Maybe
-
-getChannel :: (MonadSelda m, MonadMask m, MonadIO m) => ChannelID -> m (Maybe Channel)
-getChannel identifier = listToMaybe . fromRels <$> query q
-  where
-    q = do
-      ch@(channelId :*: _) <- select (gen channels)
-      restrict (channelId .== literal identifier)
-      return ch
-
-channelExists :: (MonadSelda m, MonadMask m, MonadIO m) => ChannelID -> m Bool
-channelExists identifier = not . null <$> getChannel identifier
-
-isChannelOwner :: (MonadSelda m, MonadIO m, MonadMask m) => ChannelID -> Username -> m Bool
-isChannelOwner identifier username = not . null <$> query q
-  where
-    q = do
-      userId :*: _ :*: username' :*: _ <- select (gen users)
-      channelId :*: _ :*: channelOwner :*: _ <- select (gen channels)
-      restrict (userId .== channelOwner)
-      restrict (username' .== literal username)
-      restrict (channelId .== literal identifier)
-      return channelId
-
 userChannels :: (MonadMask m, MonadIO m) => Username -> SeldaT m [Channel]
 userChannels username = fromRels <$> query q
   where
     q = do
       userId :*: _ :*: username' :*: _ <- select (gen users)
-      channel@(_ :*: _ :*: owner :*: _) <- select (gen channels)
+      channel@(_ :*: _ :*: owner) <- select (gen channels)
       restrict (owner .== userId)
       restrict (username' .== literal username)
       return channel
 
-updateChannelPrivacy :: (MonadMask m, MonadIO m, MonadSelda m) => ChannelID -> Visibility -> m (Maybe Channel)
+insertChannel :: (MonadMask m, MonadIO m) => Username -> Text -> SeldaT m ()
-updateChannelPrivacy channelId visibility = do
+insertChannel username channel = do
-  void $ update (gen channels) predicate (\channel -> channel `with` [pVis := literal visibility])
+  mUserId <- listToMaybe <$> getUser
-  getChannel channelId
+  void $ forM mUserId $ \userId ->
+    insertUnless (gen channels) (doesNotExist userId) [ def :*: channel :*: userId ]
   where
-    predicate (channelId' :*: _) = channelId' .== literal channelId
+    doesNotExist userId (_ :*: channel' :*: userId') = channel' .== literal channel .&& userId' .== literal userId
-    _ :*: _ :*: _ :*: pVis = selectors (gen channels)
-
-insertChannel :: (MonadMask m, MonadIO m, MonadSelda m) => Username -> Text -> Visibility -> m (Maybe Channel)
-insertChannel username channel visibility = runMaybeT $ do
-  userId <- MaybeT (listToMaybe <$> getUser)
-  channelId <- toChannelId <$> MaybeT (insertUnless (gen channels) (doesNotExist userId) [ def :*: channel :*: userId :*: visibility ])
-  MaybeT (listToMaybe . fromRels <$> query (q channelId))
-  where
-    q channelId = do
-      ch@(channelId' :*: _) <- select (gen channels)
-      restrict (channelId' .== literal channelId)
-      return ch
-    toChannelId = ChannelID . fromRowId
-    doesNotExist userId (_ :*: channel' :*: userId' :*: _) = channel' .== literal channel .&& userId' .== literal userId
     getUser = query $ do
       userId :*: _ :*: user :*: _ <- select (gen users)
       restrict (user .== literal username)
       return userId
 
-channelBooks :: (MonadSelda m, MonadMask m, MonadIO m) => Username -> ChannelID -> m [Book]
-channelBooks username identifier = fromRels <$> query q
-  where
-    q = do
-      channelId :*: bookId' <- select (gen bookChannels)
-      channelId' :*: _ :*: owner :*: _ <- select (gen channels)
-      userId :*: _ :*: username' :*: _ <- select (gen users)
-      book@(bookId :*: _) <- select (gen books)
-      restrict (username' .== literal username .&& owner .== userId)
-      restrict (channelId .== literal identifier .&& channelId .== channelId')
-      restrict (bookId .== bookId')
-      return book
-
 booksChannels :: (MonadSelda m, MonadMask m, MonadIO m) => BookID -> m [Channel]
 booksChannels bookId = fromRels <$> query q
   where
@@ -117,7 +62,7 @@ attachChannel username bookId channel = do
       return channelId'
     channelQ = do
       userId :*: _ :*: username' :*: _ <- select (gen users)
-      ch@(_ :*: channel' :*: owner :*: _) <- select (gen channels)
+      ch@(_ :*: channel' :*: owner) <- select (gen channels)
       restrict (username' .== literal username)
       restrict (owner .== userId)
       restrict (channel' .== literal channel)

src/Database/Schema.hs

@@ -42,9 +42,9 @@ instance SqlType Username where
 
 newtype UserID = UserID {unUserID :: Int} deriving (Show)
 
-newtype BookID = BookID {unBookID :: Int} deriving (Show, ToJSON, FromJSON, FromHttpApiData, Eq, Ord, ToHttpApiData)
+newtype BookID = BookID {unBookID :: Int} deriving (Show, ToJSON, FromJSON, FromHttpApiData, Eq, Ord)
 
-newtype ChannelID = ChannelID {unChannelID :: Int} deriving (Show, ToHttpApiData, FromHttpApiData, ToJSON, FromJSON)
+newtype ChannelID = ChannelID {unChannelID :: Int} deriving (Show, ToHttpApiData, FromHttpApiData)
 
 newtype TagID = TagID {unTagID :: Int} deriving (Show)
 
@@ -101,7 +101,7 @@ newtype HashDigest = HashDigest { unHex :: ByteString } deriving Show
 data Book = Book { identifier :: BookID
                  , contentHash :: Maybe HashDigest
                  , contentType :: Text
-                 , title :: Text
+                 , title :: Maybe Text
                  , description :: Maybe Text
                  , owner :: UserID }
           deriving (Show, Generic)
@@ -124,22 +124,9 @@ data Tag = Tag { identifier :: TagID
                , owner :: UserID }
          deriving (Show, Generic)
 
-data Visibility = Public | Private | Followers
-                deriving (Show, Read, Generic)
-
-instance ToJSON Visibility
-instance FromJSON Visibility
-
-instance SqlType Visibility where
-  mkLit = LCustom . LText . pack . show
-  fromSql (SqlString x) = fromMaybe (error "fromSql: Not a valid visibility token") . readMay . unpack $ x
-  fromSql _             = error "fromSql: Not a valid visibility token"
-  defaultValue = mkLit Private
-
 data Channel = Channel { identifier :: ChannelID
                        , channel :: Text
-                       , owner :: UserID
+                       , owner :: UserID }
-                       , visibility :: Visibility }
              deriving (Show, Generic)
 
 tags :: GenTable Tag

src/Servant/XML.hs

@@ -1,11 +1,9 @@
 {-# Language OverloadedStrings #-}
 {-# Language FlexibleInstances #-}
 {-# Language MultiParamTypeClasses #-}
-{-# Language TypeApplications #-}
 module Servant.XML
   ( ToNode(..)
   , XML
-  , OPDS
   , Text.Hamlet.XML.xml
   , iso8601 )
   where
@@ -18,22 +16,14 @@ import Network.HTTP.Media.MediaType
 
 data XML
 
-data OPDS
-
 instance (ToNode a) => MimeRender XML a where
   mimeRender _ a =
     let [NodeElement root] = toNode a
     in renderLBS def (Document (Prologue [] Nothing []) root [])
 
-instance (ToNode a) => MimeRender OPDS a where
-  mimeRender _ a = mimeRender (Proxy @XML) a
-
 instance Accept XML where
   contentType _ = "application" // "xml" /: ("charset", "utf-8")
 
-instance Accept OPDS where
-  contentType _ = "application" // "atom+xml" /: ("charset", "utf-8") /: ("profile", "opds-catalog")
-
 iso8601 :: UTCTime -> Text
 iso8601 = pack . formatTime defaultTimeLocale "%Y-%m-%dT%H:%M:%SZ"