{-# LANGUAGE OverloadedLabels #-}
{-# LANGUAGE StrictData #-}

{- HLINT ignore "Use camelCase" -}

module Mensam.Server.Database.Schema where

import Mensam.Server.Database.Extra

import Data.ByteString qualified as BS
import Data.Kind
import Data.Maybe
import Data.Text qualified as T
import Data.Time.Zones.All qualified as Time
import Data.Time.Zones.All.OrphanInstances ()
import Database.Selda qualified as Selda
import GHC.Generics

type DbMigration :: Type
data DbMigration = MkDbMigration
  { DbMigration -> ID DbMigration
dbMigration_id :: Selda.ID DbMigration
  , DbMigration -> Text
dbMigration_name :: Selda.Text
  , DbMigration -> UTCTime
dbMigration_time_applied :: Selda.UTCTime
  }
  deriving stock ((forall x. DbMigration -> Rep DbMigration x)
-> (forall x. Rep DbMigration x -> DbMigration)
-> Generic DbMigration
forall x. Rep DbMigration x -> DbMigration
forall x. DbMigration -> Rep DbMigration x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DbMigration -> Rep DbMigration x
from :: forall x. DbMigration -> Rep DbMigration x
$cto :: forall x. Rep DbMigration x -> DbMigration
to :: forall x. Rep DbMigration x -> DbMigration
Generic, Int -> DbMigration -> ShowS
[DbMigration] -> ShowS
DbMigration -> String
(Int -> DbMigration -> ShowS)
-> (DbMigration -> String)
-> ([DbMigration] -> ShowS)
-> Show DbMigration
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DbMigration -> ShowS
showsPrec :: Int -> DbMigration -> ShowS
$cshow :: DbMigration -> String
show :: DbMigration -> String
$cshowList :: [DbMigration] -> ShowS
showList :: [DbMigration] -> ShowS
Show)
  deriving anyclass (SqlRow DbMigration
Proxy DbMigration
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
SqlRow DbMigration =>
(DbMigration -> IO [Either Param Param])
-> (Proxy DbMigration
    -> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo])
-> (forall sql. Proxy DbMigration -> [UntypedCol sql])
-> (forall sql. DbMigration -> [UntypedCol sql])
-> Relational DbMigration
DbMigration -> IO [Either Param Param]
forall sql. Proxy DbMigration -> [UntypedCol sql]
forall a.
SqlRow a =>
(a -> IO [Either Param Param])
-> (Proxy a
    -> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo])
-> (forall sql. Proxy a -> [UntypedCol sql])
-> (forall sql. a -> [UntypedCol sql])
-> Relational a
forall sql. DbMigration -> [UntypedCol sql]
$crelParams :: DbMigration -> IO [Either Param Param]
relParams :: DbMigration -> IO [Either Param Param]
$crelTblCols :: Proxy DbMigration
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
relTblCols :: Proxy DbMigration
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
$crelNew :: forall sql. Proxy DbMigration -> [UntypedCol sql]
relNew :: forall sql. Proxy DbMigration -> [UntypedCol sql]
$crelRow :: forall sql. DbMigration -> [UntypedCol sql]
relRow :: forall sql. DbMigration -> [UntypedCol sql]
Selda.Relational, Typeable DbMigration
ResultReader DbMigration
Typeable DbMigration =>
ResultReader DbMigration
-> (Proxy DbMigration -> Int) -> SqlRow DbMigration
Proxy DbMigration -> Int
forall a.
Typeable a =>
ResultReader a -> (Proxy a -> Int) -> SqlRow a
$cnextResult :: ResultReader DbMigration
nextResult :: ResultReader DbMigration
$cnestedCols :: Proxy DbMigration -> Int
nestedCols :: Proxy DbMigration -> Int
Selda.SqlRow)

tableMigration :: Selda.Table DbMigration
tableMigration :: Table DbMigration
tableMigration =
  TableName
-> [Attr DbMigration] -> (Text -> Text) -> Table DbMigration
forall a.
Relational a =>
TableName -> [Attr a] -> (Text -> Text) -> Table a
Selda.tableFieldMod
    TableName
"migration"
    [ Group DbMigration (ID DbMigration)
#dbMigration_id Group DbMigration (ID DbMigration)
-> Attribute Group DbMigration (ID DbMigration) -> Attr DbMigration
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Attribute Group DbMigration (ID DbMigration)
forall t a. Attribute Group t a
Selda.primary
    , Group DbMigration Text
#dbMigration_name Group DbMigration Text
-> Attribute Group DbMigration Text -> Attr DbMigration
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Attribute Group DbMigration Text
forall t a. Attribute Group t a
Selda.unique
    ]
    (Maybe Text -> Text
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Text -> Text) -> (Text -> Maybe Text) -> Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text -> Maybe Text
T.stripPrefix Text
"dbMigration_")

type DbJwk :: Type
data DbJwk = MkDbJwk
  { DbJwk -> ID DbJwk
dbJwk_id :: ~(Selda.ID DbJwk)
  , DbJwk -> ByteString
dbJwk_jwk :: BS.ByteString
  , DbJwk -> UTCTime
dbJwk_created :: Selda.UTCTime
  }
  deriving stock ((forall x. DbJwk -> Rep DbJwk x)
-> (forall x. Rep DbJwk x -> DbJwk) -> Generic DbJwk
forall x. Rep DbJwk x -> DbJwk
forall x. DbJwk -> Rep DbJwk x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DbJwk -> Rep DbJwk x
from :: forall x. DbJwk -> Rep DbJwk x
$cto :: forall x. Rep DbJwk x -> DbJwk
to :: forall x. Rep DbJwk x -> DbJwk
Generic, Int -> DbJwk -> ShowS
[DbJwk] -> ShowS
DbJwk -> String
(Int -> DbJwk -> ShowS)
-> (DbJwk -> String) -> ([DbJwk] -> ShowS) -> Show DbJwk
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DbJwk -> ShowS
showsPrec :: Int -> DbJwk -> ShowS
$cshow :: DbJwk -> String
show :: DbJwk -> String
$cshowList :: [DbJwk] -> ShowS
showList :: [DbJwk] -> ShowS
Show)
  deriving anyclass (SqlRow DbJwk
Proxy DbJwk
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
SqlRow DbJwk =>
(DbJwk -> IO [Either Param Param])
-> (Proxy DbJwk
    -> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo])
-> (forall sql. Proxy DbJwk -> [UntypedCol sql])
-> (forall sql. DbJwk -> [UntypedCol sql])
-> Relational DbJwk
DbJwk -> IO [Either Param Param]
forall sql. Proxy DbJwk -> [UntypedCol sql]
forall a.
SqlRow a =>
(a -> IO [Either Param Param])
-> (Proxy a
    -> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo])
-> (forall sql. Proxy a -> [UntypedCol sql])
-> (forall sql. a -> [UntypedCol sql])
-> Relational a
forall sql. DbJwk -> [UntypedCol sql]
$crelParams :: DbJwk -> IO [Either Param Param]
relParams :: DbJwk -> IO [Either Param Param]
$crelTblCols :: Proxy DbJwk
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
relTblCols :: Proxy DbJwk
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
$crelNew :: forall sql. Proxy DbJwk -> [UntypedCol sql]
relNew :: forall sql. Proxy DbJwk -> [UntypedCol sql]
$crelRow :: forall sql. DbJwk -> [UntypedCol sql]
relRow :: forall sql. DbJwk -> [UntypedCol sql]
Selda.Relational, Typeable DbJwk
ResultReader DbJwk
Typeable DbJwk =>
ResultReader DbJwk -> (Proxy DbJwk -> Int) -> SqlRow DbJwk
Proxy DbJwk -> Int
forall a.
Typeable a =>
ResultReader a -> (Proxy a -> Int) -> SqlRow a
$cnextResult :: ResultReader DbJwk
nextResult :: ResultReader DbJwk
$cnestedCols :: Proxy DbJwk -> Int
nestedCols :: Proxy DbJwk -> Int
Selda.SqlRow)

tableJwk :: Selda.Table DbJwk
tableJwk :: Table DbJwk
tableJwk =
  TableName -> [Attr DbJwk] -> (Text -> Text) -> Table DbJwk
forall a.
Relational a =>
TableName -> [Attr a] -> (Text -> Text) -> Table a
Selda.tableFieldMod
    TableName
"jwk"
    [ Selector DbJwk (ID DbJwk)
#dbJwk_id Selector DbJwk (ID DbJwk)
-> Attribute Selector DbJwk (ID DbJwk) -> Attr DbJwk
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Attribute Selector DbJwk (ID DbJwk)
forall t. Attribute Selector t (ID t)
Selda.autoPrimary
    , Group DbJwk ByteString
#dbJwk_jwk Group DbJwk ByteString
-> Attribute Group DbJwk ByteString -> Attr DbJwk
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Attribute Group DbJwk ByteString
forall t a. Attribute Group t a
Selda.unique
    ]
    (Maybe Text -> Text
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Text -> Text) -> (Text -> Maybe Text) -> Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text -> Maybe Text
T.stripPrefix Text
"dbJwk_")

type DbUser :: Type
data DbUser = MkDbUser
  { DbUser -> ID DbUser
dbUser_id :: ~(Selda.ID DbUser)
  , DbUser -> Text
dbUser_name :: Selda.Text
  , DbUser -> Text
dbUser_password_hash :: Selda.Text
  , DbUser -> Text
dbUser_email :: Selda.Text
  , DbUser -> DbEmailVisibility
dbUser_email_visibility :: DbEmailVisibility
  , DbUser -> Bool
dbUser_email_validated :: Bool
  , DbUser -> Bool
dbUser_email_notifications :: Bool
  , DbUser -> Maybe ByteString
dbUser_picture_jpeg :: Maybe BS.ByteString
  }
  deriving stock ((forall x. DbUser -> Rep DbUser x)
-> (forall x. Rep DbUser x -> DbUser) -> Generic DbUser
forall x. Rep DbUser x -> DbUser
forall x. DbUser -> Rep DbUser x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DbUser -> Rep DbUser x
from :: forall x. DbUser -> Rep DbUser x
$cto :: forall x. Rep DbUser x -> DbUser
to :: forall x. Rep DbUser x -> DbUser
Generic, Int -> DbUser -> ShowS
[DbUser] -> ShowS
DbUser -> String
(Int -> DbUser -> ShowS)
-> (DbUser -> String) -> ([DbUser] -> ShowS) -> Show DbUser
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DbUser -> ShowS
showsPrec :: Int -> DbUser -> ShowS
$cshow :: DbUser -> String
show :: DbUser -> String
$cshowList :: [DbUser] -> ShowS
showList :: [DbUser] -> ShowS
Show)
  deriving anyclass (SqlRow DbUser
Proxy DbUser
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
SqlRow DbUser =>
(DbUser -> IO [Either Param Param])
-> (Proxy DbUser
    -> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo])
-> (forall sql. Proxy DbUser -> [UntypedCol sql])
-> (forall sql. DbUser -> [UntypedCol sql])
-> Relational DbUser
DbUser -> IO [Either Param Param]
forall sql. Proxy DbUser -> [UntypedCol sql]
forall a.
SqlRow a =>
(a -> IO [Either Param Param])
-> (Proxy a
    -> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo])
-> (forall sql. Proxy a -> [UntypedCol sql])
-> (forall sql. a -> [UntypedCol sql])
-> Relational a
forall sql. DbUser -> [UntypedCol sql]
$crelParams :: DbUser -> IO [Either Param Param]
relParams :: DbUser -> IO [Either Param Param]
$crelTblCols :: Proxy DbUser
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
relTblCols :: Proxy DbUser
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
$crelNew :: forall sql. Proxy DbUser -> [UntypedCol sql]
relNew :: forall sql. Proxy DbUser -> [UntypedCol sql]
$crelRow :: forall sql. DbUser -> [UntypedCol sql]
relRow :: forall sql. DbUser -> [UntypedCol sql]
Selda.Relational, Typeable DbUser
ResultReader DbUser
Typeable DbUser =>
ResultReader DbUser -> (Proxy DbUser -> Int) -> SqlRow DbUser
Proxy DbUser -> Int
forall a.
Typeable a =>
ResultReader a -> (Proxy a -> Int) -> SqlRow a
$cnextResult :: ResultReader DbUser
nextResult :: ResultReader DbUser
$cnestedCols :: Proxy DbUser -> Int
nestedCols :: Proxy DbUser -> Int
Selda.SqlRow)

type DbEmailVisibility :: Type
data DbEmailVisibility
  = MkDbEmailVisibility_visible
  | MkDbEmailVisibility_hidden
  deriving stock (DbEmailVisibility
DbEmailVisibility -> DbEmailVisibility -> Bounded DbEmailVisibility
forall a. a -> a -> Bounded a
$cminBound :: DbEmailVisibility
minBound :: DbEmailVisibility
$cmaxBound :: DbEmailVisibility
maxBound :: DbEmailVisibility
Bounded, Int -> DbEmailVisibility
DbEmailVisibility -> Int
DbEmailVisibility -> [DbEmailVisibility]
DbEmailVisibility -> DbEmailVisibility
DbEmailVisibility -> DbEmailVisibility -> [DbEmailVisibility]
DbEmailVisibility
-> DbEmailVisibility -> DbEmailVisibility -> [DbEmailVisibility]
(DbEmailVisibility -> DbEmailVisibility)
-> (DbEmailVisibility -> DbEmailVisibility)
-> (Int -> DbEmailVisibility)
-> (DbEmailVisibility -> Int)
-> (DbEmailVisibility -> [DbEmailVisibility])
-> (DbEmailVisibility -> DbEmailVisibility -> [DbEmailVisibility])
-> (DbEmailVisibility -> DbEmailVisibility -> [DbEmailVisibility])
-> (DbEmailVisibility
    -> DbEmailVisibility -> DbEmailVisibility -> [DbEmailVisibility])
-> Enum DbEmailVisibility
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: DbEmailVisibility -> DbEmailVisibility
succ :: DbEmailVisibility -> DbEmailVisibility
$cpred :: DbEmailVisibility -> DbEmailVisibility
pred :: DbEmailVisibility -> DbEmailVisibility
$ctoEnum :: Int -> DbEmailVisibility
toEnum :: Int -> DbEmailVisibility
$cfromEnum :: DbEmailVisibility -> Int
fromEnum :: DbEmailVisibility -> Int
$cenumFrom :: DbEmailVisibility -> [DbEmailVisibility]
enumFrom :: DbEmailVisibility -> [DbEmailVisibility]
$cenumFromThen :: DbEmailVisibility -> DbEmailVisibility -> [DbEmailVisibility]
enumFromThen :: DbEmailVisibility -> DbEmailVisibility -> [DbEmailVisibility]
$cenumFromTo :: DbEmailVisibility -> DbEmailVisibility -> [DbEmailVisibility]
enumFromTo :: DbEmailVisibility -> DbEmailVisibility -> [DbEmailVisibility]
$cenumFromThenTo :: DbEmailVisibility
-> DbEmailVisibility -> DbEmailVisibility -> [DbEmailVisibility]
enumFromThenTo :: DbEmailVisibility
-> DbEmailVisibility -> DbEmailVisibility -> [DbEmailVisibility]
Enum, ReadPrec [DbEmailVisibility]
ReadPrec DbEmailVisibility
Int -> ReadS DbEmailVisibility
ReadS [DbEmailVisibility]
(Int -> ReadS DbEmailVisibility)
-> ReadS [DbEmailVisibility]
-> ReadPrec DbEmailVisibility
-> ReadPrec [DbEmailVisibility]
-> Read DbEmailVisibility
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DbEmailVisibility
readsPrec :: Int -> ReadS DbEmailVisibility
$creadList :: ReadS [DbEmailVisibility]
readList :: ReadS [DbEmailVisibility]
$creadPrec :: ReadPrec DbEmailVisibility
readPrec :: ReadPrec DbEmailVisibility
$creadListPrec :: ReadPrec [DbEmailVisibility]
readListPrec :: ReadPrec [DbEmailVisibility]
Read, Int -> DbEmailVisibility -> ShowS
[DbEmailVisibility] -> ShowS
DbEmailVisibility -> String
(Int -> DbEmailVisibility -> ShowS)
-> (DbEmailVisibility -> String)
-> ([DbEmailVisibility] -> ShowS)
-> Show DbEmailVisibility
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DbEmailVisibility -> ShowS
showsPrec :: Int -> DbEmailVisibility -> ShowS
$cshow :: DbEmailVisibility -> String
show :: DbEmailVisibility -> String
$cshowList :: [DbEmailVisibility] -> ShowS
showList :: [DbEmailVisibility] -> ShowS
Show)
  deriving (Bounded DbEmailVisibility
Enum DbEmailVisibility
Typeable DbEmailVisibility
(Typeable DbEmailVisibility, Bounded DbEmailVisibility,
 Enum DbEmailVisibility) =>
(DbEmailVisibility -> Text)
-> (Text -> DbEmailVisibility) -> SqlEnum DbEmailVisibility
Text -> DbEmailVisibility
DbEmailVisibility -> Text
forall a.
(Typeable a, Bounded a, Enum a) =>
(a -> Text) -> (Text -> a) -> SqlEnum a
$ctoText :: DbEmailVisibility -> Text
toText :: DbEmailVisibility -> Text
$cfromText :: Text -> DbEmailVisibility
fromText :: Text -> DbEmailVisibility
Selda.SqlEnum) via (SqlEnumStripPrefix "MkDbEmailVisibility_" DbEmailVisibility)
  deriving anyclass (Typeable DbEmailVisibility
Lit DbEmailVisibility
Typeable DbEmailVisibility =>
(DbEmailVisibility -> Lit DbEmailVisibility)
-> (Proxy DbEmailVisibility -> SqlTypeRep)
-> (SqlValue -> DbEmailVisibility)
-> Lit DbEmailVisibility
-> SqlType DbEmailVisibility
Proxy DbEmailVisibility -> SqlTypeRep
SqlValue -> DbEmailVisibility
DbEmailVisibility -> Lit DbEmailVisibility
forall a.
Typeable a =>
(a -> Lit a)
-> (Proxy a -> SqlTypeRep) -> (SqlValue -> a) -> Lit a -> SqlType a
$cmkLit :: DbEmailVisibility -> Lit DbEmailVisibility
mkLit :: DbEmailVisibility -> Lit DbEmailVisibility
$csqlType :: Proxy DbEmailVisibility -> SqlTypeRep
sqlType :: Proxy DbEmailVisibility -> SqlTypeRep
$cfromSql :: SqlValue -> DbEmailVisibility
fromSql :: SqlValue -> DbEmailVisibility
$cdefaultValue :: Lit DbEmailVisibility
defaultValue :: Lit DbEmailVisibility
Selda.SqlType)

tableUser :: Selda.Table DbUser
tableUser :: Table DbUser
tableUser =
  TableName -> [Attr DbUser] -> (Text -> Text) -> Table DbUser
forall a.
Relational a =>
TableName -> [Attr a] -> (Text -> Text) -> Table a
Selda.tableFieldMod
    TableName
"user"
    [ Selector DbUser (ID DbUser)
#dbUser_id Selector DbUser (ID DbUser)
-> Attribute Selector DbUser (ID DbUser) -> Attr DbUser
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Attribute Selector DbUser (ID DbUser)
forall t. Attribute Selector t (ID t)
Selda.autoPrimary
    , Group DbUser Text
#dbUser_name Group DbUser Text -> Attribute Group DbUser Text -> Attr DbUser
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Attribute Group DbUser Text
forall t a. Attribute Group t a
Selda.unique
    ]
    (Maybe Text -> Text
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Text -> Text) -> (Text -> Maybe Text) -> Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text -> Maybe Text
T.stripPrefix Text
"dbUser_")

type DbConfirmation :: Type
data DbConfirmation = MkDbConfirmation
  { DbConfirmation -> ID DbConfirmation
dbConfirmation_id :: ~(Selda.ID DbConfirmation)
  , DbConfirmation -> ID DbUser
dbConfirmation_user :: Selda.ID DbUser
  , DbConfirmation -> Text
dbConfirmation_secret :: Selda.Text
  , DbConfirmation -> UTCTime
dbConfirmation_expired :: Selda.UTCTime
  , DbConfirmation -> Text
dbConfirmation_effect :: Selda.Text
  }
  deriving stock ((forall x. DbConfirmation -> Rep DbConfirmation x)
-> (forall x. Rep DbConfirmation x -> DbConfirmation)
-> Generic DbConfirmation
forall x. Rep DbConfirmation x -> DbConfirmation
forall x. DbConfirmation -> Rep DbConfirmation x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DbConfirmation -> Rep DbConfirmation x
from :: forall x. DbConfirmation -> Rep DbConfirmation x
$cto :: forall x. Rep DbConfirmation x -> DbConfirmation
to :: forall x. Rep DbConfirmation x -> DbConfirmation
Generic, Int -> DbConfirmation -> ShowS
[DbConfirmation] -> ShowS
DbConfirmation -> String
(Int -> DbConfirmation -> ShowS)
-> (DbConfirmation -> String)
-> ([DbConfirmation] -> ShowS)
-> Show DbConfirmation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DbConfirmation -> ShowS
showsPrec :: Int -> DbConfirmation -> ShowS
$cshow :: DbConfirmation -> String
show :: DbConfirmation -> String
$cshowList :: [DbConfirmation] -> ShowS
showList :: [DbConfirmation] -> ShowS
Show)
  deriving anyclass (SqlRow DbConfirmation
Proxy DbConfirmation
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
SqlRow DbConfirmation =>
(DbConfirmation -> IO [Either Param Param])
-> (Proxy DbConfirmation
    -> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo])
-> (forall sql. Proxy DbConfirmation -> [UntypedCol sql])
-> (forall sql. DbConfirmation -> [UntypedCol sql])
-> Relational DbConfirmation
DbConfirmation -> IO [Either Param Param]
forall sql. Proxy DbConfirmation -> [UntypedCol sql]
forall a.
SqlRow a =>
(a -> IO [Either Param Param])
-> (Proxy a
    -> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo])
-> (forall sql. Proxy a -> [UntypedCol sql])
-> (forall sql. a -> [UntypedCol sql])
-> Relational a
forall sql. DbConfirmation -> [UntypedCol sql]
$crelParams :: DbConfirmation -> IO [Either Param Param]
relParams :: DbConfirmation -> IO [Either Param Param]
$crelTblCols :: Proxy DbConfirmation
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
relTblCols :: Proxy DbConfirmation
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
$crelNew :: forall sql. Proxy DbConfirmation -> [UntypedCol sql]
relNew :: forall sql. Proxy DbConfirmation -> [UntypedCol sql]
$crelRow :: forall sql. DbConfirmation -> [UntypedCol sql]
relRow :: forall sql. DbConfirmation -> [UntypedCol sql]
Selda.Relational, Typeable DbConfirmation
ResultReader DbConfirmation
Typeable DbConfirmation =>
ResultReader DbConfirmation
-> (Proxy DbConfirmation -> Int) -> SqlRow DbConfirmation
Proxy DbConfirmation -> Int
forall a.
Typeable a =>
ResultReader a -> (Proxy a -> Int) -> SqlRow a
$cnextResult :: ResultReader DbConfirmation
nextResult :: ResultReader DbConfirmation
$cnestedCols :: Proxy DbConfirmation -> Int
nestedCols :: Proxy DbConfirmation -> Int
Selda.SqlRow)

tableConfirmation :: Selda.Table DbConfirmation
tableConfirmation :: Table DbConfirmation
tableConfirmation =
  TableName
-> [Attr DbConfirmation] -> (Text -> Text) -> Table DbConfirmation
forall a.
Relational a =>
TableName -> [Attr a] -> (Text -> Text) -> Table a
Selda.tableFieldMod
    TableName
"confirmation"
    [ Selector DbConfirmation (ID DbConfirmation)
#dbConfirmation_id Selector DbConfirmation (ID DbConfirmation)
-> Attribute Selector DbConfirmation (ID DbConfirmation)
-> Attr DbConfirmation
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Attribute Selector DbConfirmation (ID DbConfirmation)
forall t. Attribute Selector t (ID t)
Selda.autoPrimary
    , Selector DbConfirmation (ID DbUser)
#dbConfirmation_user Selector DbConfirmation (ID DbUser)
-> Attribute Selector DbConfirmation (ID DbUser)
-> Attr DbConfirmation
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Table DbUser
-> Selector DbUser (ID DbUser)
-> Attribute Selector DbConfirmation (ID DbUser)
forall t self.
Table t
-> Selector t (ID DbUser) -> Attribute Selector self (ID DbUser)
forall a b t self.
ForeignKey a b =>
Table t -> Selector t a -> Attribute Selector self b
Selda.foreignKey Table DbUser
tableUser Selector DbUser (ID DbUser)
#dbUser_id
    , Selector DbConfirmation Text
#dbConfirmation_secret Selector DbConfirmation Text
-> Group DbConfirmation (ID DbUser)
-> Group DbConfirmation (Text :*: ID DbUser)
forall t a1 b. Selector t a1 -> Group t b -> Group t (a1 :*: b)
Selda.:+ Group DbConfirmation (ID DbUser)
#dbConfirmation_user Group DbConfirmation (Text :*: ID DbUser)
-> Attribute Group DbConfirmation (Text :*: ID DbUser)
-> Attr DbConfirmation
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Attribute Group DbConfirmation (Text :*: ID DbUser)
forall t a. Attribute Group t a
Selda.unique
    ]
    (Maybe Text -> Text
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Text -> Text) -> (Text -> Maybe Text) -> Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text -> Maybe Text
T.stripPrefix Text
"dbConfirmation_")

type DbSession :: Type
data DbSession = MkDbSession
  { DbSession -> ID DbSession
dbSession_id :: ~(Selda.ID DbSession)
  , DbSession -> ID DbUser
dbSession_user :: Selda.ID DbUser
  , DbSession -> UTCTime
dbSession_time_created :: Selda.UTCTime
  , DbSession -> Maybe UTCTime
dbSession_time_expired :: Maybe Selda.UTCTime
  }
  deriving stock ((forall x. DbSession -> Rep DbSession x)
-> (forall x. Rep DbSession x -> DbSession) -> Generic DbSession
forall x. Rep DbSession x -> DbSession
forall x. DbSession -> Rep DbSession x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DbSession -> Rep DbSession x
from :: forall x. DbSession -> Rep DbSession x
$cto :: forall x. Rep DbSession x -> DbSession
to :: forall x. Rep DbSession x -> DbSession
Generic, Int -> DbSession -> ShowS
[DbSession] -> ShowS
DbSession -> String
(Int -> DbSession -> ShowS)
-> (DbSession -> String)
-> ([DbSession] -> ShowS)
-> Show DbSession
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DbSession -> ShowS
showsPrec :: Int -> DbSession -> ShowS
$cshow :: DbSession -> String
show :: DbSession -> String
$cshowList :: [DbSession] -> ShowS
showList :: [DbSession] -> ShowS
Show)
  deriving anyclass (SqlRow DbSession
Proxy DbSession
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
SqlRow DbSession =>
(DbSession -> IO [Either Param Param])
-> (Proxy DbSession
    -> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo])
-> (forall sql. Proxy DbSession -> [UntypedCol sql])
-> (forall sql. DbSession -> [UntypedCol sql])
-> Relational DbSession
DbSession -> IO [Either Param Param]
forall sql. Proxy DbSession -> [UntypedCol sql]
forall a.
SqlRow a =>
(a -> IO [Either Param Param])
-> (Proxy a
    -> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo])
-> (forall sql. Proxy a -> [UntypedCol sql])
-> (forall sql. a -> [UntypedCol sql])
-> Relational a
forall sql. DbSession -> [UntypedCol sql]
$crelParams :: DbSession -> IO [Either Param Param]
relParams :: DbSession -> IO [Either Param Param]
$crelTblCols :: Proxy DbSession
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
relTblCols :: Proxy DbSession
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
$crelNew :: forall sql. Proxy DbSession -> [UntypedCol sql]
relNew :: forall sql. Proxy DbSession -> [UntypedCol sql]
$crelRow :: forall sql. DbSession -> [UntypedCol sql]
relRow :: forall sql. DbSession -> [UntypedCol sql]
Selda.Relational, Typeable DbSession
ResultReader DbSession
Typeable DbSession =>
ResultReader DbSession
-> (Proxy DbSession -> Int) -> SqlRow DbSession
Proxy DbSession -> Int
forall a.
Typeable a =>
ResultReader a -> (Proxy a -> Int) -> SqlRow a
$cnextResult :: ResultReader DbSession
nextResult :: ResultReader DbSession
$cnestedCols :: Proxy DbSession -> Int
nestedCols :: Proxy DbSession -> Int
Selda.SqlRow)

tableSession :: Selda.Table DbSession
tableSession :: Table DbSession
tableSession =
  TableName -> [Attr DbSession] -> (Text -> Text) -> Table DbSession
forall a.
Relational a =>
TableName -> [Attr a] -> (Text -> Text) -> Table a
Selda.tableFieldMod
    TableName
"session"
    [ Selector DbSession (ID DbSession)
#dbSession_id Selector DbSession (ID DbSession)
-> Attribute Selector DbSession (ID DbSession) -> Attr DbSession
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Attribute Selector DbSession (ID DbSession)
forall t. Attribute Selector t (ID t)
Selda.autoPrimary
    , Selector DbSession (ID DbUser)
#dbSession_user Selector DbSession (ID DbUser)
-> Attribute Selector DbSession (ID DbUser) -> Attr DbSession
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Table DbUser
-> Selector DbUser (ID DbUser)
-> Attribute Selector DbSession (ID DbUser)
forall t self.
Table t
-> Selector t (ID DbUser) -> Attribute Selector self (ID DbUser)
forall a b t self.
ForeignKey a b =>
Table t -> Selector t a -> Attribute Selector self b
Selda.foreignKey Table DbUser
tableUser Selector DbUser (ID DbUser)
#dbUser_id
    ]
    (Maybe Text -> Text
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Text -> Text) -> (Text -> Maybe Text) -> Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text -> Maybe Text
T.stripPrefix Text
"dbSession_")

type DbSpace :: Type
data DbSpace = MkDbSpace
  { DbSpace -> ID DbSpace
dbSpace_id :: ~(Selda.ID DbSpace)
  , DbSpace -> Text
dbSpace_name :: Selda.Text
  , DbSpace -> TZLabel
dbSpace_timezone :: Time.TZLabel
  , DbSpace -> DbSpaceVisibility
dbSpace_visibility :: DbSpaceVisibility
  , DbSpace -> ID DbUser
dbSpace_owner :: Selda.ID DbUser
  , DbSpace -> Maybe ByteString
dbSpace_picture_jpeg :: Maybe BS.ByteString
  }
  deriving stock ((forall x. DbSpace -> Rep DbSpace x)
-> (forall x. Rep DbSpace x -> DbSpace) -> Generic DbSpace
forall x. Rep DbSpace x -> DbSpace
forall x. DbSpace -> Rep DbSpace x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DbSpace -> Rep DbSpace x
from :: forall x. DbSpace -> Rep DbSpace x
$cto :: forall x. Rep DbSpace x -> DbSpace
to :: forall x. Rep DbSpace x -> DbSpace
Generic, Int -> DbSpace -> ShowS
[DbSpace] -> ShowS
DbSpace -> String
(Int -> DbSpace -> ShowS)
-> (DbSpace -> String) -> ([DbSpace] -> ShowS) -> Show DbSpace
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DbSpace -> ShowS
showsPrec :: Int -> DbSpace -> ShowS
$cshow :: DbSpace -> String
show :: DbSpace -> String
$cshowList :: [DbSpace] -> ShowS
showList :: [DbSpace] -> ShowS
Show)
  deriving anyclass (SqlRow DbSpace
Proxy DbSpace
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
SqlRow DbSpace =>
(DbSpace -> IO [Either Param Param])
-> (Proxy DbSpace
    -> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo])
-> (forall sql. Proxy DbSpace -> [UntypedCol sql])
-> (forall sql. DbSpace -> [UntypedCol sql])
-> Relational DbSpace
DbSpace -> IO [Either Param Param]
forall sql. Proxy DbSpace -> [UntypedCol sql]
forall a.
SqlRow a =>
(a -> IO [Either Param Param])
-> (Proxy a
    -> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo])
-> (forall sql. Proxy a -> [UntypedCol sql])
-> (forall sql. a -> [UntypedCol sql])
-> Relational a
forall sql. DbSpace -> [UntypedCol sql]
$crelParams :: DbSpace -> IO [Either Param Param]
relParams :: DbSpace -> IO [Either Param Param]
$crelTblCols :: Proxy DbSpace
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
relTblCols :: Proxy DbSpace
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
$crelNew :: forall sql. Proxy DbSpace -> [UntypedCol sql]
relNew :: forall sql. Proxy DbSpace -> [UntypedCol sql]
$crelRow :: forall sql. DbSpace -> [UntypedCol sql]
relRow :: forall sql. DbSpace -> [UntypedCol sql]
Selda.Relational, Typeable DbSpace
ResultReader DbSpace
Typeable DbSpace =>
ResultReader DbSpace -> (Proxy DbSpace -> Int) -> SqlRow DbSpace
Proxy DbSpace -> Int
forall a.
Typeable a =>
ResultReader a -> (Proxy a -> Int) -> SqlRow a
$cnextResult :: ResultReader DbSpace
nextResult :: ResultReader DbSpace
$cnestedCols :: Proxy DbSpace -> Int
nestedCols :: Proxy DbSpace -> Int
Selda.SqlRow)

type DbSpaceVisibility :: Type
data DbSpaceVisibility
  = MkDbSpaceVisibility_visible
  | MkDbSpaceVisibility_hidden
  deriving stock (DbSpaceVisibility
DbSpaceVisibility -> DbSpaceVisibility -> Bounded DbSpaceVisibility
forall a. a -> a -> Bounded a
$cminBound :: DbSpaceVisibility
minBound :: DbSpaceVisibility
$cmaxBound :: DbSpaceVisibility
maxBound :: DbSpaceVisibility
Bounded, Int -> DbSpaceVisibility
DbSpaceVisibility -> Int
DbSpaceVisibility -> [DbSpaceVisibility]
DbSpaceVisibility -> DbSpaceVisibility
DbSpaceVisibility -> DbSpaceVisibility -> [DbSpaceVisibility]
DbSpaceVisibility
-> DbSpaceVisibility -> DbSpaceVisibility -> [DbSpaceVisibility]
(DbSpaceVisibility -> DbSpaceVisibility)
-> (DbSpaceVisibility -> DbSpaceVisibility)
-> (Int -> DbSpaceVisibility)
-> (DbSpaceVisibility -> Int)
-> (DbSpaceVisibility -> [DbSpaceVisibility])
-> (DbSpaceVisibility -> DbSpaceVisibility -> [DbSpaceVisibility])
-> (DbSpaceVisibility -> DbSpaceVisibility -> [DbSpaceVisibility])
-> (DbSpaceVisibility
    -> DbSpaceVisibility -> DbSpaceVisibility -> [DbSpaceVisibility])
-> Enum DbSpaceVisibility
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: DbSpaceVisibility -> DbSpaceVisibility
succ :: DbSpaceVisibility -> DbSpaceVisibility
$cpred :: DbSpaceVisibility -> DbSpaceVisibility
pred :: DbSpaceVisibility -> DbSpaceVisibility
$ctoEnum :: Int -> DbSpaceVisibility
toEnum :: Int -> DbSpaceVisibility
$cfromEnum :: DbSpaceVisibility -> Int
fromEnum :: DbSpaceVisibility -> Int
$cenumFrom :: DbSpaceVisibility -> [DbSpaceVisibility]
enumFrom :: DbSpaceVisibility -> [DbSpaceVisibility]
$cenumFromThen :: DbSpaceVisibility -> DbSpaceVisibility -> [DbSpaceVisibility]
enumFromThen :: DbSpaceVisibility -> DbSpaceVisibility -> [DbSpaceVisibility]
$cenumFromTo :: DbSpaceVisibility -> DbSpaceVisibility -> [DbSpaceVisibility]
enumFromTo :: DbSpaceVisibility -> DbSpaceVisibility -> [DbSpaceVisibility]
$cenumFromThenTo :: DbSpaceVisibility
-> DbSpaceVisibility -> DbSpaceVisibility -> [DbSpaceVisibility]
enumFromThenTo :: DbSpaceVisibility
-> DbSpaceVisibility -> DbSpaceVisibility -> [DbSpaceVisibility]
Enum, ReadPrec [DbSpaceVisibility]
ReadPrec DbSpaceVisibility
Int -> ReadS DbSpaceVisibility
ReadS [DbSpaceVisibility]
(Int -> ReadS DbSpaceVisibility)
-> ReadS [DbSpaceVisibility]
-> ReadPrec DbSpaceVisibility
-> ReadPrec [DbSpaceVisibility]
-> Read DbSpaceVisibility
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DbSpaceVisibility
readsPrec :: Int -> ReadS DbSpaceVisibility
$creadList :: ReadS [DbSpaceVisibility]
readList :: ReadS [DbSpaceVisibility]
$creadPrec :: ReadPrec DbSpaceVisibility
readPrec :: ReadPrec DbSpaceVisibility
$creadListPrec :: ReadPrec [DbSpaceVisibility]
readListPrec :: ReadPrec [DbSpaceVisibility]
Read, Int -> DbSpaceVisibility -> ShowS
[DbSpaceVisibility] -> ShowS
DbSpaceVisibility -> String
(Int -> DbSpaceVisibility -> ShowS)
-> (DbSpaceVisibility -> String)
-> ([DbSpaceVisibility] -> ShowS)
-> Show DbSpaceVisibility
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DbSpaceVisibility -> ShowS
showsPrec :: Int -> DbSpaceVisibility -> ShowS
$cshow :: DbSpaceVisibility -> String
show :: DbSpaceVisibility -> String
$cshowList :: [DbSpaceVisibility] -> ShowS
showList :: [DbSpaceVisibility] -> ShowS
Show)
  deriving (Bounded DbSpaceVisibility
Enum DbSpaceVisibility
Typeable DbSpaceVisibility
(Typeable DbSpaceVisibility, Bounded DbSpaceVisibility,
 Enum DbSpaceVisibility) =>
(DbSpaceVisibility -> Text)
-> (Text -> DbSpaceVisibility) -> SqlEnum DbSpaceVisibility
Text -> DbSpaceVisibility
DbSpaceVisibility -> Text
forall a.
(Typeable a, Bounded a, Enum a) =>
(a -> Text) -> (Text -> a) -> SqlEnum a
$ctoText :: DbSpaceVisibility -> Text
toText :: DbSpaceVisibility -> Text
$cfromText :: Text -> DbSpaceVisibility
fromText :: Text -> DbSpaceVisibility
Selda.SqlEnum) via (SqlEnumStripPrefix "MkDbSpaceVisibility_" DbSpaceVisibility)
  deriving anyclass (Typeable DbSpaceVisibility
Lit DbSpaceVisibility
Typeable DbSpaceVisibility =>
(DbSpaceVisibility -> Lit DbSpaceVisibility)
-> (Proxy DbSpaceVisibility -> SqlTypeRep)
-> (SqlValue -> DbSpaceVisibility)
-> Lit DbSpaceVisibility
-> SqlType DbSpaceVisibility
Proxy DbSpaceVisibility -> SqlTypeRep
SqlValue -> DbSpaceVisibility
DbSpaceVisibility -> Lit DbSpaceVisibility
forall a.
Typeable a =>
(a -> Lit a)
-> (Proxy a -> SqlTypeRep) -> (SqlValue -> a) -> Lit a -> SqlType a
$cmkLit :: DbSpaceVisibility -> Lit DbSpaceVisibility
mkLit :: DbSpaceVisibility -> Lit DbSpaceVisibility
$csqlType :: Proxy DbSpaceVisibility -> SqlTypeRep
sqlType :: Proxy DbSpaceVisibility -> SqlTypeRep
$cfromSql :: SqlValue -> DbSpaceVisibility
fromSql :: SqlValue -> DbSpaceVisibility
$cdefaultValue :: Lit DbSpaceVisibility
defaultValue :: Lit DbSpaceVisibility
Selda.SqlType)

tableSpace :: Selda.Table DbSpace
tableSpace :: Table DbSpace
tableSpace =
  TableName -> [Attr DbSpace] -> (Text -> Text) -> Table DbSpace
forall a.
Relational a =>
TableName -> [Attr a] -> (Text -> Text) -> Table a
Selda.tableFieldMod
    TableName
"space"
    [ Selector DbSpace (ID DbSpace)
#dbSpace_id Selector DbSpace (ID DbSpace)
-> Attribute Selector DbSpace (ID DbSpace) -> Attr DbSpace
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Attribute Selector DbSpace (ID DbSpace)
forall t. Attribute Selector t (ID t)
Selda.autoPrimary
    , Group DbSpace Text
#dbSpace_name Group DbSpace Text -> Attribute Group DbSpace Text -> Attr DbSpace
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Attribute Group DbSpace Text
forall t a. Attribute Group t a
Selda.unique
    ]
    (Maybe Text -> Text
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Text -> Text) -> (Text -> Maybe Text) -> Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text -> Maybe Text
T.stripPrefix Text
"dbSpace_")

-- TODO: Some assumptions are currently not checked by the database:
--   - When `accessibility = 'joinable_with_password'` we also have `password_hash IS NOT NULL`
--   - When `accessibility != 'joinable_with_password'` we also have `password_hash IS NULL`
type DbRole :: Type
data DbRole = MkDbRole
  { DbRole -> ID DbRole
dbRole_id :: ~(Selda.ID DbRole)
  , DbRole -> ID DbSpace
dbRole_space :: Selda.ID DbSpace
  , DbRole -> Text
dbRole_name :: Selda.Text
  , DbRole -> DbRoleAccessibility
dbRole_accessibility :: DbRoleAccessibility
  , DbRole -> Maybe Text
dbRole_password_hash :: Maybe Selda.Text
  }
  deriving stock ((forall x. DbRole -> Rep DbRole x)
-> (forall x. Rep DbRole x -> DbRole) -> Generic DbRole
forall x. Rep DbRole x -> DbRole
forall x. DbRole -> Rep DbRole x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DbRole -> Rep DbRole x
from :: forall x. DbRole -> Rep DbRole x
$cto :: forall x. Rep DbRole x -> DbRole
to :: forall x. Rep DbRole x -> DbRole
Generic, Int -> DbRole -> ShowS
[DbRole] -> ShowS
DbRole -> String
(Int -> DbRole -> ShowS)
-> (DbRole -> String) -> ([DbRole] -> ShowS) -> Show DbRole
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DbRole -> ShowS
showsPrec :: Int -> DbRole -> ShowS
$cshow :: DbRole -> String
show :: DbRole -> String
$cshowList :: [DbRole] -> ShowS
showList :: [DbRole] -> ShowS
Show)
  deriving anyclass (SqlRow DbRole
Proxy DbRole
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
SqlRow DbRole =>
(DbRole -> IO [Either Param Param])
-> (Proxy DbRole
    -> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo])
-> (forall sql. Proxy DbRole -> [UntypedCol sql])
-> (forall sql. DbRole -> [UntypedCol sql])
-> Relational DbRole
DbRole -> IO [Either Param Param]
forall sql. Proxy DbRole -> [UntypedCol sql]
forall a.
SqlRow a =>
(a -> IO [Either Param Param])
-> (Proxy a
    -> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo])
-> (forall sql. Proxy a -> [UntypedCol sql])
-> (forall sql. a -> [UntypedCol sql])
-> Relational a
forall sql. DbRole -> [UntypedCol sql]
$crelParams :: DbRole -> IO [Either Param Param]
relParams :: DbRole -> IO [Either Param Param]
$crelTblCols :: Proxy DbRole
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
relTblCols :: Proxy DbRole
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
$crelNew :: forall sql. Proxy DbRole -> [UntypedCol sql]
relNew :: forall sql. Proxy DbRole -> [UntypedCol sql]
$crelRow :: forall sql. DbRole -> [UntypedCol sql]
relRow :: forall sql. DbRole -> [UntypedCol sql]
Selda.Relational, Typeable DbRole
ResultReader DbRole
Typeable DbRole =>
ResultReader DbRole -> (Proxy DbRole -> Int) -> SqlRow DbRole
Proxy DbRole -> Int
forall a.
Typeable a =>
ResultReader a -> (Proxy a -> Int) -> SqlRow a
$cnextResult :: ResultReader DbRole
nextResult :: ResultReader DbRole
$cnestedCols :: Proxy DbRole -> Int
nestedCols :: Proxy DbRole -> Int
Selda.SqlRow)

type DbRoleAccessibility :: Type
data DbRoleAccessibility
  = MkDbRoleAccessibility_joinable
  | MkDbRoleAccessibility_joinable_with_password
  | MkDbRoleAccessibility_inaccessible
  deriving stock (DbRoleAccessibility
DbRoleAccessibility
-> DbRoleAccessibility -> Bounded DbRoleAccessibility
forall a. a -> a -> Bounded a
$cminBound :: DbRoleAccessibility
minBound :: DbRoleAccessibility
$cmaxBound :: DbRoleAccessibility
maxBound :: DbRoleAccessibility
Bounded, Int -> DbRoleAccessibility
DbRoleAccessibility -> Int
DbRoleAccessibility -> [DbRoleAccessibility]
DbRoleAccessibility -> DbRoleAccessibility
DbRoleAccessibility -> DbRoleAccessibility -> [DbRoleAccessibility]
DbRoleAccessibility
-> DbRoleAccessibility
-> DbRoleAccessibility
-> [DbRoleAccessibility]
(DbRoleAccessibility -> DbRoleAccessibility)
-> (DbRoleAccessibility -> DbRoleAccessibility)
-> (Int -> DbRoleAccessibility)
-> (DbRoleAccessibility -> Int)
-> (DbRoleAccessibility -> [DbRoleAccessibility])
-> (DbRoleAccessibility
    -> DbRoleAccessibility -> [DbRoleAccessibility])
-> (DbRoleAccessibility
    -> DbRoleAccessibility -> [DbRoleAccessibility])
-> (DbRoleAccessibility
    -> DbRoleAccessibility
    -> DbRoleAccessibility
    -> [DbRoleAccessibility])
-> Enum DbRoleAccessibility
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: DbRoleAccessibility -> DbRoleAccessibility
succ :: DbRoleAccessibility -> DbRoleAccessibility
$cpred :: DbRoleAccessibility -> DbRoleAccessibility
pred :: DbRoleAccessibility -> DbRoleAccessibility
$ctoEnum :: Int -> DbRoleAccessibility
toEnum :: Int -> DbRoleAccessibility
$cfromEnum :: DbRoleAccessibility -> Int
fromEnum :: DbRoleAccessibility -> Int
$cenumFrom :: DbRoleAccessibility -> [DbRoleAccessibility]
enumFrom :: DbRoleAccessibility -> [DbRoleAccessibility]
$cenumFromThen :: DbRoleAccessibility -> DbRoleAccessibility -> [DbRoleAccessibility]
enumFromThen :: DbRoleAccessibility -> DbRoleAccessibility -> [DbRoleAccessibility]
$cenumFromTo :: DbRoleAccessibility -> DbRoleAccessibility -> [DbRoleAccessibility]
enumFromTo :: DbRoleAccessibility -> DbRoleAccessibility -> [DbRoleAccessibility]
$cenumFromThenTo :: DbRoleAccessibility
-> DbRoleAccessibility
-> DbRoleAccessibility
-> [DbRoleAccessibility]
enumFromThenTo :: DbRoleAccessibility
-> DbRoleAccessibility
-> DbRoleAccessibility
-> [DbRoleAccessibility]
Enum, ReadPrec [DbRoleAccessibility]
ReadPrec DbRoleAccessibility
Int -> ReadS DbRoleAccessibility
ReadS [DbRoleAccessibility]
(Int -> ReadS DbRoleAccessibility)
-> ReadS [DbRoleAccessibility]
-> ReadPrec DbRoleAccessibility
-> ReadPrec [DbRoleAccessibility]
-> Read DbRoleAccessibility
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DbRoleAccessibility
readsPrec :: Int -> ReadS DbRoleAccessibility
$creadList :: ReadS [DbRoleAccessibility]
readList :: ReadS [DbRoleAccessibility]
$creadPrec :: ReadPrec DbRoleAccessibility
readPrec :: ReadPrec DbRoleAccessibility
$creadListPrec :: ReadPrec [DbRoleAccessibility]
readListPrec :: ReadPrec [DbRoleAccessibility]
Read, Int -> DbRoleAccessibility -> ShowS
[DbRoleAccessibility] -> ShowS
DbRoleAccessibility -> String
(Int -> DbRoleAccessibility -> ShowS)
-> (DbRoleAccessibility -> String)
-> ([DbRoleAccessibility] -> ShowS)
-> Show DbRoleAccessibility
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DbRoleAccessibility -> ShowS
showsPrec :: Int -> DbRoleAccessibility -> ShowS
$cshow :: DbRoleAccessibility -> String
show :: DbRoleAccessibility -> String
$cshowList :: [DbRoleAccessibility] -> ShowS
showList :: [DbRoleAccessibility] -> ShowS
Show)
  deriving (Bounded DbRoleAccessibility
Enum DbRoleAccessibility
Typeable DbRoleAccessibility
(Typeable DbRoleAccessibility, Bounded DbRoleAccessibility,
 Enum DbRoleAccessibility) =>
(DbRoleAccessibility -> Text)
-> (Text -> DbRoleAccessibility) -> SqlEnum DbRoleAccessibility
Text -> DbRoleAccessibility
DbRoleAccessibility -> Text
forall a.
(Typeable a, Bounded a, Enum a) =>
(a -> Text) -> (Text -> a) -> SqlEnum a
$ctoText :: DbRoleAccessibility -> Text
toText :: DbRoleAccessibility -> Text
$cfromText :: Text -> DbRoleAccessibility
fromText :: Text -> DbRoleAccessibility
Selda.SqlEnum) via (SqlEnumStripPrefix "MkDbRoleAccessibility_" DbRoleAccessibility)
  deriving anyclass (Typeable DbRoleAccessibility
Lit DbRoleAccessibility
Typeable DbRoleAccessibility =>
(DbRoleAccessibility -> Lit DbRoleAccessibility)
-> (Proxy DbRoleAccessibility -> SqlTypeRep)
-> (SqlValue -> DbRoleAccessibility)
-> Lit DbRoleAccessibility
-> SqlType DbRoleAccessibility
Proxy DbRoleAccessibility -> SqlTypeRep
SqlValue -> DbRoleAccessibility
DbRoleAccessibility -> Lit DbRoleAccessibility
forall a.
Typeable a =>
(a -> Lit a)
-> (Proxy a -> SqlTypeRep) -> (SqlValue -> a) -> Lit a -> SqlType a
$cmkLit :: DbRoleAccessibility -> Lit DbRoleAccessibility
mkLit :: DbRoleAccessibility -> Lit DbRoleAccessibility
$csqlType :: Proxy DbRoleAccessibility -> SqlTypeRep
sqlType :: Proxy DbRoleAccessibility -> SqlTypeRep
$cfromSql :: SqlValue -> DbRoleAccessibility
fromSql :: SqlValue -> DbRoleAccessibility
$cdefaultValue :: Lit DbRoleAccessibility
defaultValue :: Lit DbRoleAccessibility
Selda.SqlType)

tableRole :: Selda.Table DbRole
tableRole :: Table DbRole
tableRole =
  TableName -> [Attr DbRole] -> (Text -> Text) -> Table DbRole
forall a.
Relational a =>
TableName -> [Attr a] -> (Text -> Text) -> Table a
Selda.tableFieldMod
    TableName
"role"
    [ Selector DbRole (ID DbRole)
#dbRole_id Selector DbRole (ID DbRole)
-> Attribute Selector DbRole (ID DbRole) -> Attr DbRole
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Attribute Selector DbRole (ID DbRole)
forall t. Attribute Selector t (ID t)
Selda.autoPrimary
    , Selector DbRole (ID DbSpace)
#dbRole_space Selector DbRole (ID DbSpace)
-> Group DbRole Text -> Group DbRole (ID DbSpace :*: Text)
forall t a1 b. Selector t a1 -> Group t b -> Group t (a1 :*: b)
Selda.:+ Group DbRole Text
#dbRole_name Group DbRole (ID DbSpace :*: Text)
-> Attribute Group DbRole (ID DbSpace :*: Text) -> Attr DbRole
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Attribute Group DbRole (ID DbSpace :*: Text)
forall t a. Attribute Group t a
Selda.unique
    , Selector DbRole (ID DbSpace)
#dbRole_space Selector DbRole (ID DbSpace)
-> Attribute Selector DbRole (ID DbSpace) -> Attr DbRole
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Table DbSpace
-> Selector DbSpace (ID DbSpace)
-> Attribute Selector DbRole (ID DbSpace)
forall t self.
Table t
-> Selector t (ID DbSpace) -> Attribute Selector self (ID DbSpace)
forall a b t self.
ForeignKey a b =>
Table t -> Selector t a -> Attribute Selector self b
Selda.foreignKey Table DbSpace
tableSpace Selector DbSpace (ID DbSpace)
#dbSpace_id
    ]
    (Maybe Text -> Text
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Text -> Text) -> (Text -> Maybe Text) -> Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text -> Maybe Text
T.stripPrefix Text
"dbRole_")

type DbRolePermission :: Type
data DbRolePermission = MkDbRolePermission
  { DbRolePermission -> ID DbRolePermission
dbRolePermission_id :: ~(Selda.ID DbRolePermission)
  , DbRolePermission -> ID DbRole
dbRolePermission_role :: Selda.ID DbRole
  , DbRolePermission -> DbPermission
dbRolePermission_permission :: DbPermission
  }
  deriving stock ((forall x. DbRolePermission -> Rep DbRolePermission x)
-> (forall x. Rep DbRolePermission x -> DbRolePermission)
-> Generic DbRolePermission
forall x. Rep DbRolePermission x -> DbRolePermission
forall x. DbRolePermission -> Rep DbRolePermission x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DbRolePermission -> Rep DbRolePermission x
from :: forall x. DbRolePermission -> Rep DbRolePermission x
$cto :: forall x. Rep DbRolePermission x -> DbRolePermission
to :: forall x. Rep DbRolePermission x -> DbRolePermission
Generic, Int -> DbRolePermission -> ShowS
[DbRolePermission] -> ShowS
DbRolePermission -> String
(Int -> DbRolePermission -> ShowS)
-> (DbRolePermission -> String)
-> ([DbRolePermission] -> ShowS)
-> Show DbRolePermission
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DbRolePermission -> ShowS
showsPrec :: Int -> DbRolePermission -> ShowS
$cshow :: DbRolePermission -> String
show :: DbRolePermission -> String
$cshowList :: [DbRolePermission] -> ShowS
showList :: [DbRolePermission] -> ShowS
Show)
  deriving anyclass (SqlRow DbRolePermission
Proxy DbRolePermission
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
SqlRow DbRolePermission =>
(DbRolePermission -> IO [Either Param Param])
-> (Proxy DbRolePermission
    -> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo])
-> (forall sql. Proxy DbRolePermission -> [UntypedCol sql])
-> (forall sql. DbRolePermission -> [UntypedCol sql])
-> Relational DbRolePermission
DbRolePermission -> IO [Either Param Param]
forall sql. Proxy DbRolePermission -> [UntypedCol sql]
forall a.
SqlRow a =>
(a -> IO [Either Param Param])
-> (Proxy a
    -> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo])
-> (forall sql. Proxy a -> [UntypedCol sql])
-> (forall sql. a -> [UntypedCol sql])
-> Relational a
forall sql. DbRolePermission -> [UntypedCol sql]
$crelParams :: DbRolePermission -> IO [Either Param Param]
relParams :: DbRolePermission -> IO [Either Param Param]
$crelTblCols :: Proxy DbRolePermission
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
relTblCols :: Proxy DbRolePermission
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
$crelNew :: forall sql. Proxy DbRolePermission -> [UntypedCol sql]
relNew :: forall sql. Proxy DbRolePermission -> [UntypedCol sql]
$crelRow :: forall sql. DbRolePermission -> [UntypedCol sql]
relRow :: forall sql. DbRolePermission -> [UntypedCol sql]
Selda.Relational, Typeable DbRolePermission
ResultReader DbRolePermission
Typeable DbRolePermission =>
ResultReader DbRolePermission
-> (Proxy DbRolePermission -> Int) -> SqlRow DbRolePermission
Proxy DbRolePermission -> Int
forall a.
Typeable a =>
ResultReader a -> (Proxy a -> Int) -> SqlRow a
$cnextResult :: ResultReader DbRolePermission
nextResult :: ResultReader DbRolePermission
$cnestedCols :: Proxy DbRolePermission -> Int
nestedCols :: Proxy DbRolePermission -> Int
Selda.SqlRow)

tableRolePermission :: Selda.Table DbRolePermission
tableRolePermission :: Table DbRolePermission
tableRolePermission =
  TableName
-> [Attr DbRolePermission]
-> (Text -> Text)
-> Table DbRolePermission
forall a.
Relational a =>
TableName -> [Attr a] -> (Text -> Text) -> Table a
Selda.tableFieldMod
    TableName
"role_permission"
    [ Selector DbRolePermission (ID DbRolePermission)
#dbRolePermission_id Selector DbRolePermission (ID DbRolePermission)
-> Attribute Selector DbRolePermission (ID DbRolePermission)
-> Attr DbRolePermission
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Attribute Selector DbRolePermission (ID DbRolePermission)
forall t. Attribute Selector t (ID t)
Selda.autoPrimary
    , Selector DbRolePermission (ID DbRole)
#dbRolePermission_role Selector DbRolePermission (ID DbRole)
-> Group DbRolePermission DbPermission
-> Group DbRolePermission (ID DbRole :*: DbPermission)
forall t a1 b. Selector t a1 -> Group t b -> Group t (a1 :*: b)
Selda.:+ Group DbRolePermission DbPermission
#dbRolePermission_permission Group DbRolePermission (ID DbRole :*: DbPermission)
-> Attribute Group DbRolePermission (ID DbRole :*: DbPermission)
-> Attr DbRolePermission
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Attribute Group DbRolePermission (ID DbRole :*: DbPermission)
forall t a. Attribute Group t a
Selda.unique
    , Selector DbRolePermission (ID DbRole)
#dbRolePermission_role Selector DbRolePermission (ID DbRole)
-> Attribute Selector DbRolePermission (ID DbRole)
-> Attr DbRolePermission
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Table DbRole
-> Selector DbRole (ID DbRole)
-> Attribute Selector DbRolePermission (ID DbRole)
forall t self.
Table t
-> Selector t (ID DbRole) -> Attribute Selector self (ID DbRole)
forall a b t self.
ForeignKey a b =>
Table t -> Selector t a -> Attribute Selector self b
Selda.foreignKey Table DbRole
tableRole Selector DbRole (ID DbRole)
#dbRole_id
    ]
    (Maybe Text -> Text
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Text -> Text) -> (Text -> Maybe Text) -> Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text -> Maybe Text
T.stripPrefix Text
"dbRolePermission_")

type DbPermission :: Type
data DbPermission
  = MkDbPermission_view_space
  | MkDbPermission_edit_desk
  | MkDbPermission_edit_user
  | MkDbPermission_edit_role
  | MkDbPermission_edit_space
  | MkDbPermission_create_reservation
  | MkDbPermission_cancel_reservation
  deriving stock (DbPermission
DbPermission -> DbPermission -> Bounded DbPermission
forall a. a -> a -> Bounded a
$cminBound :: DbPermission
minBound :: DbPermission
$cmaxBound :: DbPermission
maxBound :: DbPermission
Bounded, Int -> DbPermission
DbPermission -> Int
DbPermission -> [DbPermission]
DbPermission -> DbPermission
DbPermission -> DbPermission -> [DbPermission]
DbPermission -> DbPermission -> DbPermission -> [DbPermission]
(DbPermission -> DbPermission)
-> (DbPermission -> DbPermission)
-> (Int -> DbPermission)
-> (DbPermission -> Int)
-> (DbPermission -> [DbPermission])
-> (DbPermission -> DbPermission -> [DbPermission])
-> (DbPermission -> DbPermission -> [DbPermission])
-> (DbPermission -> DbPermission -> DbPermission -> [DbPermission])
-> Enum DbPermission
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: DbPermission -> DbPermission
succ :: DbPermission -> DbPermission
$cpred :: DbPermission -> DbPermission
pred :: DbPermission -> DbPermission
$ctoEnum :: Int -> DbPermission
toEnum :: Int -> DbPermission
$cfromEnum :: DbPermission -> Int
fromEnum :: DbPermission -> Int
$cenumFrom :: DbPermission -> [DbPermission]
enumFrom :: DbPermission -> [DbPermission]
$cenumFromThen :: DbPermission -> DbPermission -> [DbPermission]
enumFromThen :: DbPermission -> DbPermission -> [DbPermission]
$cenumFromTo :: DbPermission -> DbPermission -> [DbPermission]
enumFromTo :: DbPermission -> DbPermission -> [DbPermission]
$cenumFromThenTo :: DbPermission -> DbPermission -> DbPermission -> [DbPermission]
enumFromThenTo :: DbPermission -> DbPermission -> DbPermission -> [DbPermission]
Enum, ReadPrec [DbPermission]
ReadPrec DbPermission
Int -> ReadS DbPermission
ReadS [DbPermission]
(Int -> ReadS DbPermission)
-> ReadS [DbPermission]
-> ReadPrec DbPermission
-> ReadPrec [DbPermission]
-> Read DbPermission
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DbPermission
readsPrec :: Int -> ReadS DbPermission
$creadList :: ReadS [DbPermission]
readList :: ReadS [DbPermission]
$creadPrec :: ReadPrec DbPermission
readPrec :: ReadPrec DbPermission
$creadListPrec :: ReadPrec [DbPermission]
readListPrec :: ReadPrec [DbPermission]
Read, Int -> DbPermission -> ShowS
[DbPermission] -> ShowS
DbPermission -> String
(Int -> DbPermission -> ShowS)
-> (DbPermission -> String)
-> ([DbPermission] -> ShowS)
-> Show DbPermission
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DbPermission -> ShowS
showsPrec :: Int -> DbPermission -> ShowS
$cshow :: DbPermission -> String
show :: DbPermission -> String
$cshowList :: [DbPermission] -> ShowS
showList :: [DbPermission] -> ShowS
Show)
  deriving (Bounded DbPermission
Enum DbPermission
Typeable DbPermission
(Typeable DbPermission, Bounded DbPermission, Enum DbPermission) =>
(DbPermission -> Text)
-> (Text -> DbPermission) -> SqlEnum DbPermission
Text -> DbPermission
DbPermission -> Text
forall a.
(Typeable a, Bounded a, Enum a) =>
(a -> Text) -> (Text -> a) -> SqlEnum a
$ctoText :: DbPermission -> Text
toText :: DbPermission -> Text
$cfromText :: Text -> DbPermission
fromText :: Text -> DbPermission
Selda.SqlEnum) via (SqlEnumStripPrefix "MkDbPermission_" DbPermission)
  deriving anyclass (Typeable DbPermission
Lit DbPermission
Typeable DbPermission =>
(DbPermission -> Lit DbPermission)
-> (Proxy DbPermission -> SqlTypeRep)
-> (SqlValue -> DbPermission)
-> Lit DbPermission
-> SqlType DbPermission
Proxy DbPermission -> SqlTypeRep
SqlValue -> DbPermission
DbPermission -> Lit DbPermission
forall a.
Typeable a =>
(a -> Lit a)
-> (Proxy a -> SqlTypeRep) -> (SqlValue -> a) -> Lit a -> SqlType a
$cmkLit :: DbPermission -> Lit DbPermission
mkLit :: DbPermission -> Lit DbPermission
$csqlType :: Proxy DbPermission -> SqlTypeRep
sqlType :: Proxy DbPermission -> SqlTypeRep
$cfromSql :: SqlValue -> DbPermission
fromSql :: SqlValue -> DbPermission
$cdefaultValue :: Lit DbPermission
defaultValue :: Lit DbPermission
Selda.SqlType)

type DbSpaceUser :: Type
data DbSpaceUser = MkDbSpaceUser
  { DbSpaceUser -> ID DbSpaceUser
dbSpaceUser_id :: ~(Selda.ID DbSpaceUser)
  , DbSpaceUser -> ID DbSpace
dbSpaceUser_space :: Selda.ID DbSpace
  , DbSpaceUser -> ID DbUser
dbSpaceUser_user :: Selda.ID DbUser
  , DbSpaceUser -> ID DbRole
dbSpaceUser_role :: Selda.ID DbRole
  }
  deriving stock ((forall x. DbSpaceUser -> Rep DbSpaceUser x)
-> (forall x. Rep DbSpaceUser x -> DbSpaceUser)
-> Generic DbSpaceUser
forall x. Rep DbSpaceUser x -> DbSpaceUser
forall x. DbSpaceUser -> Rep DbSpaceUser x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DbSpaceUser -> Rep DbSpaceUser x
from :: forall x. DbSpaceUser -> Rep DbSpaceUser x
$cto :: forall x. Rep DbSpaceUser x -> DbSpaceUser
to :: forall x. Rep DbSpaceUser x -> DbSpaceUser
Generic, Int -> DbSpaceUser -> ShowS
[DbSpaceUser] -> ShowS
DbSpaceUser -> String
(Int -> DbSpaceUser -> ShowS)
-> (DbSpaceUser -> String)
-> ([DbSpaceUser] -> ShowS)
-> Show DbSpaceUser
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DbSpaceUser -> ShowS
showsPrec :: Int -> DbSpaceUser -> ShowS
$cshow :: DbSpaceUser -> String
show :: DbSpaceUser -> String
$cshowList :: [DbSpaceUser] -> ShowS
showList :: [DbSpaceUser] -> ShowS
Show)
  deriving anyclass (SqlRow DbSpaceUser
Proxy DbSpaceUser
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
SqlRow DbSpaceUser =>
(DbSpaceUser -> IO [Either Param Param])
-> (Proxy DbSpaceUser
    -> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo])
-> (forall sql. Proxy DbSpaceUser -> [UntypedCol sql])
-> (forall sql. DbSpaceUser -> [UntypedCol sql])
-> Relational DbSpaceUser
DbSpaceUser -> IO [Either Param Param]
forall sql. Proxy DbSpaceUser -> [UntypedCol sql]
forall a.
SqlRow a =>
(a -> IO [Either Param Param])
-> (Proxy a
    -> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo])
-> (forall sql. Proxy a -> [UntypedCol sql])
-> (forall sql. a -> [UntypedCol sql])
-> Relational a
forall sql. DbSpaceUser -> [UntypedCol sql]
$crelParams :: DbSpaceUser -> IO [Either Param Param]
relParams :: DbSpaceUser -> IO [Either Param Param]
$crelTblCols :: Proxy DbSpaceUser
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
relTblCols :: Proxy DbSpaceUser
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
$crelNew :: forall sql. Proxy DbSpaceUser -> [UntypedCol sql]
relNew :: forall sql. Proxy DbSpaceUser -> [UntypedCol sql]
$crelRow :: forall sql. DbSpaceUser -> [UntypedCol sql]
relRow :: forall sql. DbSpaceUser -> [UntypedCol sql]
Selda.Relational, Typeable DbSpaceUser
ResultReader DbSpaceUser
Typeable DbSpaceUser =>
ResultReader DbSpaceUser
-> (Proxy DbSpaceUser -> Int) -> SqlRow DbSpaceUser
Proxy DbSpaceUser -> Int
forall a.
Typeable a =>
ResultReader a -> (Proxy a -> Int) -> SqlRow a
$cnextResult :: ResultReader DbSpaceUser
nextResult :: ResultReader DbSpaceUser
$cnestedCols :: Proxy DbSpaceUser -> Int
nestedCols :: Proxy DbSpaceUser -> Int
Selda.SqlRow)

tableSpaceUser :: Selda.Table DbSpaceUser
tableSpaceUser :: Table DbSpaceUser
tableSpaceUser =
  TableName
-> [Attr DbSpaceUser] -> (Text -> Text) -> Table DbSpaceUser
forall a.
Relational a =>
TableName -> [Attr a] -> (Text -> Text) -> Table a
Selda.tableFieldMod
    TableName
"space_user"
    [ Selector DbSpaceUser (ID DbSpaceUser)
#dbSpaceUser_id Selector DbSpaceUser (ID DbSpaceUser)
-> Attribute Selector DbSpaceUser (ID DbSpaceUser)
-> Attr DbSpaceUser
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Attribute Selector DbSpaceUser (ID DbSpaceUser)
forall t. Attribute Selector t (ID t)
Selda.autoPrimary
    , Selector DbSpaceUser (ID DbSpace)
#dbSpaceUser_space Selector DbSpaceUser (ID DbSpace)
-> Group DbSpaceUser (ID DbUser)
-> Group DbSpaceUser (ID DbSpace :*: ID DbUser)
forall t a1 b. Selector t a1 -> Group t b -> Group t (a1 :*: b)
Selda.:+ Group DbSpaceUser (ID DbUser)
#dbSpaceUser_user Group DbSpaceUser (ID DbSpace :*: ID DbUser)
-> Attribute Group DbSpaceUser (ID DbSpace :*: ID DbUser)
-> Attr DbSpaceUser
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Attribute Group DbSpaceUser (ID DbSpace :*: ID DbUser)
forall t a. Attribute Group t a
Selda.unique
    , Selector DbSpaceUser (ID DbSpace)
#dbSpaceUser_space Selector DbSpaceUser (ID DbSpace)
-> Attribute Selector DbSpaceUser (ID DbSpace) -> Attr DbSpaceUser
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Table DbSpace
-> Selector DbSpace (ID DbSpace)
-> Attribute Selector DbSpaceUser (ID DbSpace)
forall t self.
Table t
-> Selector t (ID DbSpace) -> Attribute Selector self (ID DbSpace)
forall a b t self.
ForeignKey a b =>
Table t -> Selector t a -> Attribute Selector self b
Selda.foreignKey Table DbSpace
tableSpace Selector DbSpace (ID DbSpace)
#dbSpace_id
    , Selector DbSpaceUser (ID DbUser)
#dbSpaceUser_user Selector DbSpaceUser (ID DbUser)
-> Attribute Selector DbSpaceUser (ID DbUser) -> Attr DbSpaceUser
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Table DbUser
-> Selector DbUser (ID DbUser)
-> Attribute Selector DbSpaceUser (ID DbUser)
forall t self.
Table t
-> Selector t (ID DbUser) -> Attribute Selector self (ID DbUser)
forall a b t self.
ForeignKey a b =>
Table t -> Selector t a -> Attribute Selector self b
Selda.foreignKey Table DbUser
tableUser Selector DbUser (ID DbUser)
#dbUser_id
    ]
    (Maybe Text -> Text
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Text -> Text) -> (Text -> Maybe Text) -> Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text -> Maybe Text
T.stripPrefix Text
"dbSpaceUser_")

type DbDesk :: Type
data DbDesk = MkDbDesk
  { DbDesk -> ID DbDesk
dbDesk_id :: ~(Selda.ID DbDesk)
  , DbDesk -> ID DbSpace
dbDesk_space :: Selda.ID DbSpace
  , DbDesk -> Text
dbDesk_name :: Selda.Text
  , DbDesk -> Maybe Double
dbDesk_position_x :: Maybe Double
  , DbDesk -> Maybe Double
dbDesk_position_y :: Maybe Double
  , DbDesk -> Maybe Double
dbDesk_direction :: Maybe Double
  , DbDesk -> Maybe Double
dbDesk_size_width :: Maybe Double
  , DbDesk -> Maybe Double
dbDesk_size_depth :: Maybe Double
  }
  deriving stock ((forall x. DbDesk -> Rep DbDesk x)
-> (forall x. Rep DbDesk x -> DbDesk) -> Generic DbDesk
forall x. Rep DbDesk x -> DbDesk
forall x. DbDesk -> Rep DbDesk x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DbDesk -> Rep DbDesk x
from :: forall x. DbDesk -> Rep DbDesk x
$cto :: forall x. Rep DbDesk x -> DbDesk
to :: forall x. Rep DbDesk x -> DbDesk
Generic, Int -> DbDesk -> ShowS
[DbDesk] -> ShowS
DbDesk -> String
(Int -> DbDesk -> ShowS)
-> (DbDesk -> String) -> ([DbDesk] -> ShowS) -> Show DbDesk
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DbDesk -> ShowS
showsPrec :: Int -> DbDesk -> ShowS
$cshow :: DbDesk -> String
show :: DbDesk -> String
$cshowList :: [DbDesk] -> ShowS
showList :: [DbDesk] -> ShowS
Show)
  deriving anyclass (SqlRow DbDesk
Proxy DbDesk
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
SqlRow DbDesk =>
(DbDesk -> IO [Either Param Param])
-> (Proxy DbDesk
    -> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo])
-> (forall sql. Proxy DbDesk -> [UntypedCol sql])
-> (forall sql. DbDesk -> [UntypedCol sql])
-> Relational DbDesk
DbDesk -> IO [Either Param Param]
forall sql. Proxy DbDesk -> [UntypedCol sql]
forall a.
SqlRow a =>
(a -> IO [Either Param Param])
-> (Proxy a
    -> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo])
-> (forall sql. Proxy a -> [UntypedCol sql])
-> (forall sql. a -> [UntypedCol sql])
-> Relational a
forall sql. DbDesk -> [UntypedCol sql]
$crelParams :: DbDesk -> IO [Either Param Param]
relParams :: DbDesk -> IO [Either Param Param]
$crelTblCols :: Proxy DbDesk
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
relTblCols :: Proxy DbDesk
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
$crelNew :: forall sql. Proxy DbDesk -> [UntypedCol sql]
relNew :: forall sql. Proxy DbDesk -> [UntypedCol sql]
$crelRow :: forall sql. DbDesk -> [UntypedCol sql]
relRow :: forall sql. DbDesk -> [UntypedCol sql]
Selda.Relational, Typeable DbDesk
ResultReader DbDesk
Typeable DbDesk =>
ResultReader DbDesk -> (Proxy DbDesk -> Int) -> SqlRow DbDesk
Proxy DbDesk -> Int
forall a.
Typeable a =>
ResultReader a -> (Proxy a -> Int) -> SqlRow a
$cnextResult :: ResultReader DbDesk
nextResult :: ResultReader DbDesk
$cnestedCols :: Proxy DbDesk -> Int
nestedCols :: Proxy DbDesk -> Int
Selda.SqlRow)

tableDesk :: Selda.Table DbDesk
tableDesk :: Table DbDesk
tableDesk =
  TableName -> [Attr DbDesk] -> (Text -> Text) -> Table DbDesk
forall a.
Relational a =>
TableName -> [Attr a] -> (Text -> Text) -> Table a
Selda.tableFieldMod
    TableName
"desk"
    [ Selector DbDesk (ID DbDesk)
#dbDesk_id Selector DbDesk (ID DbDesk)
-> Attribute Selector DbDesk (ID DbDesk) -> Attr DbDesk
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Attribute Selector DbDesk (ID DbDesk)
forall t. Attribute Selector t (ID t)
Selda.autoPrimary
    , Selector DbDesk (ID DbSpace)
#dbDesk_space Selector DbDesk (ID DbSpace)
-> Group DbDesk Text -> Group DbDesk (ID DbSpace :*: Text)
forall t a1 b. Selector t a1 -> Group t b -> Group t (a1 :*: b)
Selda.:+ Group DbDesk Text
#dbDesk_name Group DbDesk (ID DbSpace :*: Text)
-> Attribute Group DbDesk (ID DbSpace :*: Text) -> Attr DbDesk
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Attribute Group DbDesk (ID DbSpace :*: Text)
forall t a. Attribute Group t a
Selda.unique
    , Selector DbDesk (ID DbSpace)
#dbDesk_space Selector DbDesk (ID DbSpace)
-> Attribute Selector DbDesk (ID DbSpace) -> Attr DbDesk
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Table DbSpace
-> Selector DbSpace (ID DbSpace)
-> Attribute Selector DbDesk (ID DbSpace)
forall t self.
Table t
-> Selector t (ID DbSpace) -> Attribute Selector self (ID DbSpace)
forall a b t self.
ForeignKey a b =>
Table t -> Selector t a -> Attribute Selector self b
Selda.foreignKey Table DbSpace
tableSpace Selector DbSpace (ID DbSpace)
#dbSpace_id
    ]
    (Maybe Text -> Text
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Text -> Text) -> (Text -> Maybe Text) -> Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text -> Maybe Text
T.stripPrefix Text
"dbDesk_")

type DbReservation :: Type
data DbReservation = MkDbReservation
  { DbReservation -> ID DbReservation
dbReservation_id :: ~(Selda.ID DbReservation)
  , DbReservation -> ID DbDesk
dbReservation_desk :: Selda.ID DbDesk
  , DbReservation -> ID DbUser
dbReservation_user :: Selda.ID DbUser
  , DbReservation -> UTCTime
dbReservation_time_begin :: Selda.UTCTime
  , DbReservation -> UTCTime
dbReservation_time_end :: Selda.UTCTime
  , DbReservation -> DbReservationStatus
dbReservation_status :: DbReservationStatus
  }
  deriving stock ((forall x. DbReservation -> Rep DbReservation x)
-> (forall x. Rep DbReservation x -> DbReservation)
-> Generic DbReservation
forall x. Rep DbReservation x -> DbReservation
forall x. DbReservation -> Rep DbReservation x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DbReservation -> Rep DbReservation x
from :: forall x. DbReservation -> Rep DbReservation x
$cto :: forall x. Rep DbReservation x -> DbReservation
to :: forall x. Rep DbReservation x -> DbReservation
Generic, Int -> DbReservation -> ShowS
[DbReservation] -> ShowS
DbReservation -> String
(Int -> DbReservation -> ShowS)
-> (DbReservation -> String)
-> ([DbReservation] -> ShowS)
-> Show DbReservation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DbReservation -> ShowS
showsPrec :: Int -> DbReservation -> ShowS
$cshow :: DbReservation -> String
show :: DbReservation -> String
$cshowList :: [DbReservation] -> ShowS
showList :: [DbReservation] -> ShowS
Show)
  deriving anyclass (SqlRow DbReservation
Proxy DbReservation
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
SqlRow DbReservation =>
(DbReservation -> IO [Either Param Param])
-> (Proxy DbReservation
    -> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo])
-> (forall sql. Proxy DbReservation -> [UntypedCol sql])
-> (forall sql. DbReservation -> [UntypedCol sql])
-> Relational DbReservation
DbReservation -> IO [Either Param Param]
forall sql. Proxy DbReservation -> [UntypedCol sql]
forall a.
SqlRow a =>
(a -> IO [Either Param Param])
-> (Proxy a
    -> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo])
-> (forall sql. Proxy a -> [UntypedCol sql])
-> (forall sql. a -> [UntypedCol sql])
-> Relational a
forall sql. DbReservation -> [UntypedCol sql]
$crelParams :: DbReservation -> IO [Either Param Param]
relParams :: DbReservation -> IO [Either Param Param]
$crelTblCols :: Proxy DbReservation
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
relTblCols :: Proxy DbReservation
-> (Int -> Maybe ColName -> ColName) -> State Int [ColInfo]
$crelNew :: forall sql. Proxy DbReservation -> [UntypedCol sql]
relNew :: forall sql. Proxy DbReservation -> [UntypedCol sql]
$crelRow :: forall sql. DbReservation -> [UntypedCol sql]
relRow :: forall sql. DbReservation -> [UntypedCol sql]
Selda.Relational, Typeable DbReservation
ResultReader DbReservation
Typeable DbReservation =>
ResultReader DbReservation
-> (Proxy DbReservation -> Int) -> SqlRow DbReservation
Proxy DbReservation -> Int
forall a.
Typeable a =>
ResultReader a -> (Proxy a -> Int) -> SqlRow a
$cnextResult :: ResultReader DbReservation
nextResult :: ResultReader DbReservation
$cnestedCols :: Proxy DbReservation -> Int
nestedCols :: Proxy DbReservation -> Int
Selda.SqlRow)

type DbReservationStatus :: Type
data DbReservationStatus
  = MkDbReservationStatus_planned
  | MkDbReservationStatus_cancelled
  deriving stock (DbReservationStatus
DbReservationStatus
-> DbReservationStatus -> Bounded DbReservationStatus
forall a. a -> a -> Bounded a
$cminBound :: DbReservationStatus
minBound :: DbReservationStatus
$cmaxBound :: DbReservationStatus
maxBound :: DbReservationStatus
Bounded, Int -> DbReservationStatus
DbReservationStatus -> Int
DbReservationStatus -> [DbReservationStatus]
DbReservationStatus -> DbReservationStatus
DbReservationStatus -> DbReservationStatus -> [DbReservationStatus]
DbReservationStatus
-> DbReservationStatus
-> DbReservationStatus
-> [DbReservationStatus]
(DbReservationStatus -> DbReservationStatus)
-> (DbReservationStatus -> DbReservationStatus)
-> (Int -> DbReservationStatus)
-> (DbReservationStatus -> Int)
-> (DbReservationStatus -> [DbReservationStatus])
-> (DbReservationStatus
    -> DbReservationStatus -> [DbReservationStatus])
-> (DbReservationStatus
    -> DbReservationStatus -> [DbReservationStatus])
-> (DbReservationStatus
    -> DbReservationStatus
    -> DbReservationStatus
    -> [DbReservationStatus])
-> Enum DbReservationStatus
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: DbReservationStatus -> DbReservationStatus
succ :: DbReservationStatus -> DbReservationStatus
$cpred :: DbReservationStatus -> DbReservationStatus
pred :: DbReservationStatus -> DbReservationStatus
$ctoEnum :: Int -> DbReservationStatus
toEnum :: Int -> DbReservationStatus
$cfromEnum :: DbReservationStatus -> Int
fromEnum :: DbReservationStatus -> Int
$cenumFrom :: DbReservationStatus -> [DbReservationStatus]
enumFrom :: DbReservationStatus -> [DbReservationStatus]
$cenumFromThen :: DbReservationStatus -> DbReservationStatus -> [DbReservationStatus]
enumFromThen :: DbReservationStatus -> DbReservationStatus -> [DbReservationStatus]
$cenumFromTo :: DbReservationStatus -> DbReservationStatus -> [DbReservationStatus]
enumFromTo :: DbReservationStatus -> DbReservationStatus -> [DbReservationStatus]
$cenumFromThenTo :: DbReservationStatus
-> DbReservationStatus
-> DbReservationStatus
-> [DbReservationStatus]
enumFromThenTo :: DbReservationStatus
-> DbReservationStatus
-> DbReservationStatus
-> [DbReservationStatus]
Enum, ReadPrec [DbReservationStatus]
ReadPrec DbReservationStatus
Int -> ReadS DbReservationStatus
ReadS [DbReservationStatus]
(Int -> ReadS DbReservationStatus)
-> ReadS [DbReservationStatus]
-> ReadPrec DbReservationStatus
-> ReadPrec [DbReservationStatus]
-> Read DbReservationStatus
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DbReservationStatus
readsPrec :: Int -> ReadS DbReservationStatus
$creadList :: ReadS [DbReservationStatus]
readList :: ReadS [DbReservationStatus]
$creadPrec :: ReadPrec DbReservationStatus
readPrec :: ReadPrec DbReservationStatus
$creadListPrec :: ReadPrec [DbReservationStatus]
readListPrec :: ReadPrec [DbReservationStatus]
Read, Int -> DbReservationStatus -> ShowS
[DbReservationStatus] -> ShowS
DbReservationStatus -> String
(Int -> DbReservationStatus -> ShowS)
-> (DbReservationStatus -> String)
-> ([DbReservationStatus] -> ShowS)
-> Show DbReservationStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DbReservationStatus -> ShowS
showsPrec :: Int -> DbReservationStatus -> ShowS
$cshow :: DbReservationStatus -> String
show :: DbReservationStatus -> String
$cshowList :: [DbReservationStatus] -> ShowS
showList :: [DbReservationStatus] -> ShowS
Show)
  deriving (Bounded DbReservationStatus
Enum DbReservationStatus
Typeable DbReservationStatus
(Typeable DbReservationStatus, Bounded DbReservationStatus,
 Enum DbReservationStatus) =>
(DbReservationStatus -> Text)
-> (Text -> DbReservationStatus) -> SqlEnum DbReservationStatus
Text -> DbReservationStatus
DbReservationStatus -> Text
forall a.
(Typeable a, Bounded a, Enum a) =>
(a -> Text) -> (Text -> a) -> SqlEnum a
$ctoText :: DbReservationStatus -> Text
toText :: DbReservationStatus -> Text
$cfromText :: Text -> DbReservationStatus
fromText :: Text -> DbReservationStatus
Selda.SqlEnum) via (SqlEnumStripPrefix "MkDbReservationStatus_" DbReservationStatus)
  deriving anyclass (Typeable DbReservationStatus
Lit DbReservationStatus
Typeable DbReservationStatus =>
(DbReservationStatus -> Lit DbReservationStatus)
-> (Proxy DbReservationStatus -> SqlTypeRep)
-> (SqlValue -> DbReservationStatus)
-> Lit DbReservationStatus
-> SqlType DbReservationStatus
Proxy DbReservationStatus -> SqlTypeRep
SqlValue -> DbReservationStatus
DbReservationStatus -> Lit DbReservationStatus
forall a.
Typeable a =>
(a -> Lit a)
-> (Proxy a -> SqlTypeRep) -> (SqlValue -> a) -> Lit a -> SqlType a
$cmkLit :: DbReservationStatus -> Lit DbReservationStatus
mkLit :: DbReservationStatus -> Lit DbReservationStatus
$csqlType :: Proxy DbReservationStatus -> SqlTypeRep
sqlType :: Proxy DbReservationStatus -> SqlTypeRep
$cfromSql :: SqlValue -> DbReservationStatus
fromSql :: SqlValue -> DbReservationStatus
$cdefaultValue :: Lit DbReservationStatus
defaultValue :: Lit DbReservationStatus
Selda.SqlType)

-- TODO: Some assumptions are currently not checked by the database:
--   - Start and end are ordered:
--       `CHECK (time_begin < time_end)`
--   - Two active reservations (x and y) cannot overlap at any time.
tableReservation :: Selda.Table DbReservation
tableReservation :: Table DbReservation
tableReservation =
  TableName
-> [Attr DbReservation] -> (Text -> Text) -> Table DbReservation
forall a.
Relational a =>
TableName -> [Attr a] -> (Text -> Text) -> Table a
Selda.tableFieldMod
    TableName
"reservation"
    [ Selector DbReservation (ID DbReservation)
#dbReservation_id Selector DbReservation (ID DbReservation)
-> Attribute Selector DbReservation (ID DbReservation)
-> Attr DbReservation
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Attribute Selector DbReservation (ID DbReservation)
forall t. Attribute Selector t (ID t)
Selda.autoPrimary
    , Selector DbReservation (ID DbDesk)
#dbReservation_desk Selector DbReservation (ID DbDesk)
-> Attribute Selector DbReservation (ID DbDesk)
-> Attr DbReservation
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Table DbDesk
-> Selector DbDesk (ID DbDesk)
-> Attribute Selector DbReservation (ID DbDesk)
forall t self.
Table t
-> Selector t (ID DbDesk) -> Attribute Selector self (ID DbDesk)
forall a b t self.
ForeignKey a b =>
Table t -> Selector t a -> Attribute Selector self b
Selda.foreignKey Table DbDesk
tableDesk Selector DbDesk (ID DbDesk)
#dbDesk_id
    , Selector DbReservation (ID DbUser)
#dbReservation_user Selector DbReservation (ID DbUser)
-> Attribute Selector DbReservation (ID DbUser)
-> Attr DbReservation
forall (g :: * -> * -> *) a a1.
SelectorLike g =>
g a a1 -> Attribute g a a1 -> Attr a
Selda.:- Table DbUser
-> Selector DbUser (ID DbUser)
-> Attribute Selector DbReservation (ID DbUser)
forall t self.
Table t
-> Selector t (ID DbUser) -> Attribute Selector self (ID DbUser)
forall a b t self.
ForeignKey a b =>
Table t -> Selector t a -> Attribute Selector self b
Selda.foreignKey Table DbUser
tableUser Selector DbUser (ID DbUser)
#dbUser_id
    ]
    (Maybe Text -> Text
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Text -> Text) -> (Text -> Maybe Text) -> Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text -> Maybe Text
T.stripPrefix Text
"dbReservation_")