module Reddit.Types.User where

import Reddit.Parser
import Reddit.Types.Thing

import Control.Applicative
import Data.Aeson
import Data.Monoid
import Data.Text (Text)
import Data.Time.Clock
import Data.Time.Clock.POSIX
import Network.API.Builder.Query
import Prelude
import qualified Data.Text as Text
import qualified Data.Vector as Vector

newtype Username = Username Text
  deriving (Int -> Username -> ShowS
[Username] -> ShowS
Username -> String
(Int -> Username -> ShowS)
-> (Username -> String) -> ([Username] -> ShowS) -> Show Username
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Username] -> ShowS
$cshowList :: [Username] -> ShowS
show :: Username -> String
$cshow :: Username -> String
showsPrec :: Int -> Username -> ShowS
$cshowsPrec :: Int -> Username -> ShowS
Show, ReadPrec [Username]
ReadPrec Username
Int -> ReadS Username
ReadS [Username]
(Int -> ReadS Username)
-> ReadS [Username]
-> ReadPrec Username
-> ReadPrec [Username]
-> Read Username
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Username]
$creadListPrec :: ReadPrec [Username]
readPrec :: ReadPrec Username
$creadPrec :: ReadPrec Username
readList :: ReadS [Username]
$creadList :: ReadS [Username]
readsPrec :: Int -> ReadS Username
$creadsPrec :: Int -> ReadS Username
Read, Eq Username
Eq Username
-> (Username -> Username -> Ordering)
-> (Username -> Username -> Bool)
-> (Username -> Username -> Bool)
-> (Username -> Username -> Bool)
-> (Username -> Username -> Bool)
-> (Username -> Username -> Username)
-> (Username -> Username -> Username)
-> Ord Username
Username -> Username -> Bool
Username -> Username -> Ordering
Username -> Username -> Username
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Username -> Username -> Username
$cmin :: Username -> Username -> Username
max :: Username -> Username -> Username
$cmax :: Username -> Username -> Username
>= :: Username -> Username -> Bool
$c>= :: Username -> Username -> Bool
> :: Username -> Username -> Bool
$c> :: Username -> Username -> Bool
<= :: Username -> Username -> Bool
$c<= :: Username -> Username -> Bool
< :: Username -> Username -> Bool
$c< :: Username -> Username -> Bool
compare :: Username -> Username -> Ordering
$ccompare :: Username -> Username -> Ordering
$cp1Ord :: Eq Username
Ord)

instance Eq Username where
  Username Text
x == :: Username -> Username -> Bool
== Username Text
y = Text -> Text
Text.toCaseFold Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text -> Text
Text.toCaseFold Text
y

instance FromJSON Username where
  parseJSON :: Value -> Parser Username
parseJSON (String Text
s) = Username -> Parser Username
forall (m :: * -> *) a. Monad m => a -> m a
return (Username -> Parser Username) -> Username -> Parser Username
forall a b. (a -> b) -> a -> b
$ Text -> Username
Username Text
s
  parseJSON Value
_ = Parser Username
forall a. Monoid a => a
mempty

instance ToQuery Username where
  toQuery :: Text -> Username -> [(Text, Text)]
toQuery Text
k (Username Text
user) = [(Text
k, Text
user)]

newtype UserID = UserID Text
  deriving (Int -> UserID -> ShowS
[UserID] -> ShowS
UserID -> String
(Int -> UserID -> ShowS)
-> (UserID -> String) -> ([UserID] -> ShowS) -> Show UserID
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UserID] -> ShowS
$cshowList :: [UserID] -> ShowS
show :: UserID -> String
$cshow :: UserID -> String
showsPrec :: Int -> UserID -> ShowS
$cshowsPrec :: Int -> UserID -> ShowS
Show, ReadPrec [UserID]
ReadPrec UserID
Int -> ReadS UserID
ReadS [UserID]
(Int -> ReadS UserID)
-> ReadS [UserID]
-> ReadPrec UserID
-> ReadPrec [UserID]
-> Read UserID
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UserID]
$creadListPrec :: ReadPrec [UserID]
readPrec :: ReadPrec UserID
$creadPrec :: ReadPrec UserID
readList :: ReadS [UserID]
$creadList :: ReadS [UserID]
readsPrec :: Int -> ReadS UserID
$creadsPrec :: Int -> ReadS UserID
Read, UserID -> UserID -> Bool
(UserID -> UserID -> Bool)
-> (UserID -> UserID -> Bool) -> Eq UserID
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UserID -> UserID -> Bool
$c/= :: UserID -> UserID -> Bool
== :: UserID -> UserID -> Bool
$c== :: UserID -> UserID -> Bool
Eq, Eq UserID
Eq UserID
-> (UserID -> UserID -> Ordering)
-> (UserID -> UserID -> Bool)
-> (UserID -> UserID -> Bool)
-> (UserID -> UserID -> Bool)
-> (UserID -> UserID -> Bool)
-> (UserID -> UserID -> UserID)
-> (UserID -> UserID -> UserID)
-> Ord UserID
UserID -> UserID -> Bool
UserID -> UserID -> Ordering
UserID -> UserID -> UserID
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: UserID -> UserID -> UserID
$cmin :: UserID -> UserID -> UserID
max :: UserID -> UserID -> UserID
$cmax :: UserID -> UserID -> UserID
>= :: UserID -> UserID -> Bool
$c>= :: UserID -> UserID -> Bool
> :: UserID -> UserID -> Bool
$c> :: UserID -> UserID -> Bool
<= :: UserID -> UserID -> Bool
$c<= :: UserID -> UserID -> Bool
< :: UserID -> UserID -> Bool
$c< :: UserID -> UserID -> Bool
compare :: UserID -> UserID -> Ordering
$ccompare :: UserID -> UserID -> Ordering
$cp1Ord :: Eq UserID
Ord)

instance FromJSON UserID where
  parseJSON :: Value -> Parser UserID
parseJSON (String Text
s) =
    Text -> UserID
UserID (Text -> UserID) -> Parser Text -> Parser UserID
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> Text -> Parser Text
stripPrefix Text
userPrefix Text
s
  parseJSON Value
_ = Parser UserID
forall a. Monoid a => a
mempty

instance Thing UserID where
  fullName :: UserID -> Text
fullName (UserID Text
u) = [Text] -> Text
forall a. Monoid a => [a] -> a
mconcat [Text
userPrefix, Text
"_", Text
u]

instance ToQuery UserID where
  toQuery :: Text -> UserID -> [(Text, Text)]
toQuery Text
k UserID
v = [(Text
k, UserID -> Text
forall a. Thing a => a -> Text
fullName UserID
v)]

data User =
  User { User -> Text
userID :: Text
       , User -> Username
userName :: Username
       , User -> UTCTime
userCreated :: UTCTime
       , User -> Integer
linkKarma :: Integer
       , User -> Integer
commentKarma :: Integer
       , User -> Maybe Bool
hasMail :: Maybe Bool
       , User -> Maybe Bool
hasModMail :: Maybe Bool
       , User -> Bool
isFriend :: Bool
       , User -> Maybe Bool
userIsOver18 :: Maybe Bool
       , User -> Bool
isMod :: Bool
       , User -> Bool
hasGold :: Bool
       , User -> Maybe Bool
hasVerifiedEmail :: Maybe Bool }
  deriving (Int -> User -> ShowS
[User] -> ShowS
User -> String
(Int -> User -> ShowS)
-> (User -> String) -> ([User] -> ShowS) -> Show User
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [User] -> ShowS
$cshowList :: [User] -> ShowS
show :: User -> String
$cshow :: User -> String
showsPrec :: Int -> User -> ShowS
$cshowsPrec :: Int -> User -> ShowS
Show, User -> User -> Bool
(User -> User -> Bool) -> (User -> User -> Bool) -> Eq User
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: User -> User -> Bool
$c/= :: User -> User -> Bool
== :: User -> User -> Bool
$c== :: User -> User -> Bool
Eq)

instance FromJSON User where
  parseJSON :: Value -> Parser User
parseJSON (Object Object
o) = do
    Object
o Object -> Text -> Parser ()
`ensureKind` Text
userPrefix
    Object
d <- Object
o Object -> Key -> Parser Object
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"data"
    Text
-> Username
-> UTCTime
-> Integer
-> Integer
-> Maybe Bool
-> Maybe Bool
-> Bool
-> Maybe Bool
-> Bool
-> Bool
-> Maybe Bool
-> User
User (Text
 -> Username
 -> UTCTime
 -> Integer
 -> Integer
 -> Maybe Bool
 -> Maybe Bool
 -> Bool
 -> Maybe Bool
 -> Bool
 -> Bool
 -> Maybe Bool
 -> User)
-> Parser Text
-> Parser
     (Username
      -> UTCTime
      -> Integer
      -> Integer
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe Bool
      -> User)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
d Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
         Parser
  (Username
   -> UTCTime
   -> Integer
   -> Integer
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe Bool
   -> User)
-> Parser Username
-> Parser
     (UTCTime
      -> Integer
      -> Integer
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe Bool
      -> User)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
d Object -> Key -> Parser Username
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
         Parser
  (UTCTime
   -> Integer
   -> Integer
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe Bool
   -> User)
-> Parser UTCTime
-> Parser
     (Integer
      -> Integer
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe Bool
      -> User)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (POSIXTime -> UTCTime
posixSecondsToUTCTime (POSIXTime -> UTCTime)
-> (Integer -> POSIXTime) -> Integer -> UTCTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> POSIXTime
forall a. Num a => Integer -> a
fromInteger (Integer -> UTCTime) -> Parser Integer -> Parser UTCTime
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
d Object -> Key -> Parser Integer
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_utc")
         Parser
  (Integer
   -> Integer
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe Bool
   -> User)
-> Parser Integer
-> Parser
     (Integer
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe Bool
      -> User)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
d Object -> Key -> Parser Integer
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"link_karma"
         Parser
  (Integer
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe Bool
   -> User)
-> Parser Integer
-> Parser
     (Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe Bool
      -> User)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
d Object -> Key -> Parser Integer
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"comment_karma"
         Parser
  (Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe Bool
   -> User)
-> Parser (Maybe Bool)
-> Parser
     (Maybe Bool
      -> Bool -> Maybe Bool -> Bool -> Bool -> Maybe Bool -> User)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
d Object -> Key -> Parser (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"has_mail"
         Parser
  (Maybe Bool
   -> Bool -> Maybe Bool -> Bool -> Bool -> Maybe Bool -> User)
-> Parser (Maybe Bool)
-> Parser
     (Bool -> Maybe Bool -> Bool -> Bool -> Maybe Bool -> User)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
d Object -> Key -> Parser (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"has_mod_mail"
         Parser (Bool -> Maybe Bool -> Bool -> Bool -> Maybe Bool -> User)
-> Parser Bool
-> Parser (Maybe Bool -> Bool -> Bool -> Maybe Bool -> User)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
d Object -> Key -> Parser Bool
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"is_friend"
         Parser (Maybe Bool -> Bool -> Bool -> Maybe Bool -> User)
-> Parser (Maybe Bool)
-> Parser (Bool -> Bool -> Maybe Bool -> User)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
d Object -> Key -> Parser (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"over_18"
         Parser (Bool -> Bool -> Maybe Bool -> User)
-> Parser Bool -> Parser (Bool -> Maybe Bool -> User)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
d Object -> Key -> Parser Bool
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"is_mod"
         Parser (Bool -> Maybe Bool -> User)
-> Parser Bool -> Parser (Maybe Bool -> User)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
d Object -> Key -> Parser Bool
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"is_gold"
         Parser (Maybe Bool -> User) -> Parser (Maybe Bool) -> Parser User
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
d Object -> Key -> Parser (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"has_verified_email"
  parseJSON Value
_ = Parser User
forall a. Monoid a => a
mempty

newtype UserList = UserList [Relationship]
  deriving (Int -> UserList -> ShowS
[UserList] -> ShowS
UserList -> String
(Int -> UserList -> ShowS)
-> (UserList -> String) -> ([UserList] -> ShowS) -> Show UserList
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UserList] -> ShowS
$cshowList :: [UserList] -> ShowS
show :: UserList -> String
$cshow :: UserList -> String
showsPrec :: Int -> UserList -> ShowS
$cshowsPrec :: Int -> UserList -> ShowS
Show, ReadPrec [UserList]
ReadPrec UserList
Int -> ReadS UserList
ReadS [UserList]
(Int -> ReadS UserList)
-> ReadS [UserList]
-> ReadPrec UserList
-> ReadPrec [UserList]
-> Read UserList
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UserList]
$creadListPrec :: ReadPrec [UserList]
readPrec :: ReadPrec UserList
$creadPrec :: ReadPrec UserList
readList :: ReadS [UserList]
$creadList :: ReadS [UserList]
readsPrec :: Int -> ReadS UserList
$creadsPrec :: Int -> ReadS UserList
Read, UserList -> UserList -> Bool
(UserList -> UserList -> Bool)
-> (UserList -> UserList -> Bool) -> Eq UserList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UserList -> UserList -> Bool
$c/= :: UserList -> UserList -> Bool
== :: UserList -> UserList -> Bool
$c== :: UserList -> UserList -> Bool
Eq)

instance FromJSON UserList where
  parseJSON :: Value -> Parser UserList
parseJSON (Object Object
o) = do
    Object
o Object -> Text -> Parser ()
`ensureKind` Text
"UserList"
    [Relationship] -> UserList
UserList ([Relationship] -> UserList)
-> Parser [Relationship] -> Parser UserList
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((Object
o Object -> Key -> Parser Object
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"data") Parser Object
-> (Object -> Parser [Relationship]) -> Parser [Relationship]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Object -> Key -> Parser [Relationship]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"children"))
  parseJSON (Array Array
a) =
    case Array -> [Value]
forall a. Vector a -> [a]
Vector.toList Array
a of
      [Value
o] -> Value -> Parser UserList
forall a. FromJSON a => Value -> Parser a
parseJSON Value
o
      [Value
o, Value
_] -> Value -> Parser UserList
forall a. FromJSON a => Value -> Parser a
parseJSON Value
o
      [Value]
_ -> Parser UserList
forall a. Monoid a => a
mempty
  parseJSON Value
_ = String -> Parser UserList
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"wat"

data Relationship =
  Relationship { Relationship -> Username
relationUsername :: Username
               , Relationship -> UserID
relationUserID :: UserID
               , Relationship -> UTCTime
relationSince :: UTCTime
               , Relationship -> Maybe Text
relationNote :: Maybe Text }
  deriving (Int -> Relationship -> ShowS
[Relationship] -> ShowS
Relationship -> String
(Int -> Relationship -> ShowS)
-> (Relationship -> String)
-> ([Relationship] -> ShowS)
-> Show Relationship
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Relationship] -> ShowS
$cshowList :: [Relationship] -> ShowS
show :: Relationship -> String
$cshow :: Relationship -> String
showsPrec :: Int -> Relationship -> ShowS
$cshowsPrec :: Int -> Relationship -> ShowS
Show, ReadPrec [Relationship]
ReadPrec Relationship
Int -> ReadS Relationship
ReadS [Relationship]
(Int -> ReadS Relationship)
-> ReadS [Relationship]
-> ReadPrec Relationship
-> ReadPrec [Relationship]
-> Read Relationship
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Relationship]
$creadListPrec :: ReadPrec [Relationship]
readPrec :: ReadPrec Relationship
$creadPrec :: ReadPrec Relationship
readList :: ReadS [Relationship]
$creadList :: ReadS [Relationship]
readsPrec :: Int -> ReadS Relationship
$creadsPrec :: Int -> ReadS Relationship
Read, Relationship -> Relationship -> Bool
(Relationship -> Relationship -> Bool)
-> (Relationship -> Relationship -> Bool) -> Eq Relationship
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Relationship -> Relationship -> Bool
$c/= :: Relationship -> Relationship -> Bool
== :: Relationship -> Relationship -> Bool
$c== :: Relationship -> Relationship -> Bool
Eq)

instance FromJSON Relationship where
  parseJSON :: Value -> Parser Relationship
parseJSON (Object Object
o) =
    Username -> UserID -> UTCTime -> Maybe Text -> Relationship
Relationship (Username -> UserID -> UTCTime -> Maybe Text -> Relationship)
-> Parser Username
-> Parser (UserID -> UTCTime -> Maybe Text -> Relationship)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Username
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
                 Parser (UserID -> UTCTime -> Maybe Text -> Relationship)
-> Parser UserID -> Parser (UTCTime -> Maybe Text -> Relationship)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser UserID
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
                 Parser (UTCTime -> Maybe Text -> Relationship)
-> Parser UTCTime -> Parser (Maybe Text -> Relationship)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (POSIXTime -> UTCTime
posixSecondsToUTCTime (POSIXTime -> UTCTime)
-> (Integer -> POSIXTime) -> Integer -> UTCTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> POSIXTime
forall a. Num a => Integer -> a
fromInteger (Integer -> UTCTime) -> Parser Integer -> Parser UTCTime
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Integer
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"date")
                 Parser (Maybe Text -> Relationship)
-> Parser (Maybe Text) -> Parser Relationship
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Maybe Text -> Maybe Text
forall a. (Eq a, IsString a) => Maybe a -> Maybe a
f (Maybe Text -> Maybe Text)
-> Parser (Maybe Text) -> Parser (Maybe Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"note")
    where f :: Maybe a -> Maybe a
f (Just a
"") = Maybe a
forall a. Maybe a
Nothing
          f Maybe a
x = Maybe a
x
  parseJSON Value
_ = String -> Parser Relationship
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Relationship should be an object"

userPrefix :: Text
userPrefix :: Text
userPrefix = Text
"t2"