Feed.hs

module Lucienne.Model.Feed 
  ( Feed, id, ownerId, title, url, newFeed, setOwner
  , feedByUrlQuery, feedByIdQuery, feedsQuery)
where

import           Prelude hiding (id)
import           Data.Maybe (fromJust)
import qualified Data.CompactString.UTF8 as CS
import           Data.Bson (Document,ObjectId,(=:),at)
import           Lucienne.DatabaseAble (DatabaseAble(..))
import           Lucienne.Model.Util (maybeAddId)
import qualified Lucienne.Model.User as U

data Feed = Feed { _id       :: Maybe ObjectId
                 , _ownerId  :: Maybe String
                 , title     :: String
                 , url       :: String
                 }

newFeed :: String -> String -> Feed
newFeed = Feed Nothing Nothing

id :: Feed -> ObjectId
id = fromJust . _id

ownerId :: Feed -> String
ownerId = fromJust . _ownerId

setOwner :: U.User -> Feed -> Feed
setOwner owner feed = feed { _ownerId = Just $ U.name owner }

instance DatabaseAble Feed where
  toDocument feed = maybeAddId _id feed $ 
                    [ "ownerId" =: CS.pack (ownerId feed)
                    , "title"   =: CS.pack (title  feed)
                    , "url"     =: CS.pack (url    feed)
                    ]

  fromDocument document = 
    let _id     =             "_id"     `at` document
        ownerId = CS.unpack $ "ownerId"  `at` document
        title   = CS.unpack $ "title"   `at` document
        url     = CS.unpack $ "url"     `at` document
    in
      Feed (Just _id) (Just ownerId) title url

feedByUrlQuery :: String -> String -> Document
feedByUrlQuery ownerId url =
  [ "ownerId" =: CS.pack ownerId
  , "url"     =: CS.pack url
  ]

feedByIdQuery :: String -> ObjectId -> Document
feedByIdQuery ownerId _id =
  [ "ownerId"  =: CS.pack ownerId
  , "_id"      =: _id
  ]

feedsQuery :: String -> Document
feedsQuery ownerId = ["ownerId" =: CS.pack ownerId]