module IHP.IDE.ToolServer.Types where

import IHP.Prelude
import qualified IHP.Controller.Session as Session
import qualified IHP.ControllerSupport as ControllerSupport
import qualified IHP.ViewSupport as ViewSupport
import IHP.FrameworkConfig
import IHP.Environment
import qualified IHP.IDE.Types as DevServer
import IHP.FlashMessages.Types

data ToolServerApplication = ToolServerApplication { ToolServerApplication -> Context
devServerContext :: DevServer.Context }

data SchemaController
    = PushToDbAction
    | DumpDbAction
    | UpdateDbAction
    | ShowCodeAction
    | SaveCodeAction
    | ShowGeneratedCodeAction { SchemaController -> Text
statementName :: Text }
    deriving (SchemaController -> SchemaController -> Bool
(SchemaController -> SchemaController -> Bool)
-> (SchemaController -> SchemaController -> Bool)
-> Eq SchemaController
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SchemaController -> SchemaController -> Bool
$c/= :: SchemaController -> SchemaController -> Bool
== :: SchemaController -> SchemaController -> Bool
$c== :: SchemaController -> SchemaController -> Bool
Eq, Int -> SchemaController -> ShowS
[SchemaController] -> ShowS
SchemaController -> String
(Int -> SchemaController -> ShowS)
-> (SchemaController -> String)
-> ([SchemaController] -> ShowS)
-> Show SchemaController
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SchemaController] -> ShowS
$cshowList :: [SchemaController] -> ShowS
show :: SchemaController -> String
$cshow :: SchemaController -> String
showsPrec :: Int -> SchemaController -> ShowS
$cshowsPrec :: Int -> SchemaController -> ShowS
Show, Typeable SchemaController
Constr
DataType
Typeable SchemaController
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> SchemaController -> c SchemaController)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SchemaController)
-> (SchemaController -> Constr)
-> (SchemaController -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SchemaController))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SchemaController))
-> ((forall b. Data b => b -> b)
    -> SchemaController -> SchemaController)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SchemaController -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SchemaController -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> SchemaController -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SchemaController -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SchemaController -> m SchemaController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SchemaController -> m SchemaController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SchemaController -> m SchemaController)
-> Data SchemaController
SchemaController -> Constr
SchemaController -> DataType
(forall b. Data b => b -> b)
-> SchemaController -> SchemaController
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemaController -> c SchemaController
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemaController
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> SchemaController -> u
forall u. (forall d. Data d => d -> u) -> SchemaController -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaController -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaController -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SchemaController -> m SchemaController
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SchemaController -> m SchemaController
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemaController
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemaController -> c SchemaController
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SchemaController)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SchemaController)
$cShowGeneratedCodeAction :: Constr
$cSaveCodeAction :: Constr
$cShowCodeAction :: Constr
$cUpdateDbAction :: Constr
$cDumpDbAction :: Constr
$cPushToDbAction :: Constr
$tSchemaController :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> SchemaController -> m SchemaController
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SchemaController -> m SchemaController
gmapMp :: (forall d. Data d => d -> m d)
-> SchemaController -> m SchemaController
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SchemaController -> m SchemaController
gmapM :: (forall d. Data d => d -> m d)
-> SchemaController -> m SchemaController
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SchemaController -> m SchemaController
gmapQi :: Int -> (forall d. Data d => d -> u) -> SchemaController -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SchemaController -> u
gmapQ :: (forall d. Data d => d -> u) -> SchemaController -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SchemaController -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaController -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaController -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaController -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaController -> r
gmapT :: (forall b. Data b => b -> b)
-> SchemaController -> SchemaController
$cgmapT :: (forall b. Data b => b -> b)
-> SchemaController -> SchemaController
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SchemaController)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SchemaController)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SchemaController)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SchemaController)
dataTypeOf :: SchemaController -> DataType
$cdataTypeOf :: SchemaController -> DataType
toConstr :: SchemaController -> Constr
$ctoConstr :: SchemaController -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemaController
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemaController
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemaController -> c SchemaController
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemaController -> c SchemaController
$cp1Data :: Typeable SchemaController
Data)

data TablesController
    = TablesAction
    | ShowTableAction { TablesController -> Text
tableName :: Text }
    | NewTableAction
    | CreateTableAction
    | EditTableAction { tableName :: Text, TablesController -> Int
tableId :: Int }
    | UpdateTableAction
    | DeleteTableAction { tableId :: Int, tableName :: Text }
    deriving (TablesController -> TablesController -> Bool
(TablesController -> TablesController -> Bool)
-> (TablesController -> TablesController -> Bool)
-> Eq TablesController
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TablesController -> TablesController -> Bool
$c/= :: TablesController -> TablesController -> Bool
== :: TablesController -> TablesController -> Bool
$c== :: TablesController -> TablesController -> Bool
Eq, Int -> TablesController -> ShowS
[TablesController] -> ShowS
TablesController -> String
(Int -> TablesController -> ShowS)
-> (TablesController -> String)
-> ([TablesController] -> ShowS)
-> Show TablesController
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TablesController] -> ShowS
$cshowList :: [TablesController] -> ShowS
show :: TablesController -> String
$cshow :: TablesController -> String
showsPrec :: Int -> TablesController -> ShowS
$cshowsPrec :: Int -> TablesController -> ShowS
Show, Typeable TablesController
Constr
DataType
Typeable TablesController
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TablesController -> c TablesController)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TablesController)
-> (TablesController -> Constr)
-> (TablesController -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TablesController))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TablesController))
-> ((forall b. Data b => b -> b)
    -> TablesController -> TablesController)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TablesController -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TablesController -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> TablesController -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TablesController -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> TablesController -> m TablesController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TablesController -> m TablesController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TablesController -> m TablesController)
-> Data TablesController
TablesController -> Constr
TablesController -> DataType
(forall b. Data b => b -> b)
-> TablesController -> TablesController
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TablesController -> c TablesController
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TablesController
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> TablesController -> u
forall u. (forall d. Data d => d -> u) -> TablesController -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TablesController -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TablesController -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TablesController -> m TablesController
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TablesController -> m TablesController
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TablesController
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TablesController -> c TablesController
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TablesController)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TablesController)
$cDeleteTableAction :: Constr
$cUpdateTableAction :: Constr
$cEditTableAction :: Constr
$cCreateTableAction :: Constr
$cNewTableAction :: Constr
$cShowTableAction :: Constr
$cTablesAction :: Constr
$tTablesController :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> TablesController -> m TablesController
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TablesController -> m TablesController
gmapMp :: (forall d. Data d => d -> m d)
-> TablesController -> m TablesController
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TablesController -> m TablesController
gmapM :: (forall d. Data d => d -> m d)
-> TablesController -> m TablesController
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TablesController -> m TablesController
gmapQi :: Int -> (forall d. Data d => d -> u) -> TablesController -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> TablesController -> u
gmapQ :: (forall d. Data d => d -> u) -> TablesController -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TablesController -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TablesController -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TablesController -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TablesController -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TablesController -> r
gmapT :: (forall b. Data b => b -> b)
-> TablesController -> TablesController
$cgmapT :: (forall b. Data b => b -> b)
-> TablesController -> TablesController
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TablesController)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TablesController)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TablesController)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TablesController)
dataTypeOf :: TablesController -> DataType
$cdataTypeOf :: TablesController -> DataType
toConstr :: TablesController -> Constr
$ctoConstr :: TablesController -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TablesController
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TablesController
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TablesController -> c TablesController
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TablesController -> c TablesController
$cp1Data :: Typeable TablesController
Data)

data ColumnsController
    = NewColumnAction { ColumnsController -> Text
tableName :: Text }
    | CreateColumnAction
    | EditColumnAction { tableName :: Text, ColumnsController -> Int
columnId :: Int }
    | UpdateColumnAction
    | DeleteColumnAction { tableName :: Text, columnId :: Int, ColumnsController -> Text
columnName :: Text }
    | ToggleColumnUniqueAction { tableName :: Text, columnId :: Int }
    | NewForeignKeyAction { tableName :: Text, columnName :: Text }
    | CreateForeignKeyAction
    | EditForeignKeyAction { tableName :: Text, columnName :: Text, ColumnsController -> Text
constraintName :: Text, ColumnsController -> Text
referenceTable :: Text }
    | UpdateForeignKeyAction
    | DeleteForeignKeyAction { constraintName :: Text, tableName :: Text }
    deriving (ColumnsController -> ColumnsController -> Bool
(ColumnsController -> ColumnsController -> Bool)
-> (ColumnsController -> ColumnsController -> Bool)
-> Eq ColumnsController
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ColumnsController -> ColumnsController -> Bool
$c/= :: ColumnsController -> ColumnsController -> Bool
== :: ColumnsController -> ColumnsController -> Bool
$c== :: ColumnsController -> ColumnsController -> Bool
Eq, Int -> ColumnsController -> ShowS
[ColumnsController] -> ShowS
ColumnsController -> String
(Int -> ColumnsController -> ShowS)
-> (ColumnsController -> String)
-> ([ColumnsController] -> ShowS)
-> Show ColumnsController
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ColumnsController] -> ShowS
$cshowList :: [ColumnsController] -> ShowS
show :: ColumnsController -> String
$cshow :: ColumnsController -> String
showsPrec :: Int -> ColumnsController -> ShowS
$cshowsPrec :: Int -> ColumnsController -> ShowS
Show, Typeable ColumnsController
Constr
DataType
Typeable ColumnsController
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> ColumnsController
    -> c ColumnsController)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ColumnsController)
-> (ColumnsController -> Constr)
-> (ColumnsController -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ColumnsController))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ColumnsController))
-> ((forall b. Data b => b -> b)
    -> ColumnsController -> ColumnsController)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ColumnsController -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ColumnsController -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ColumnsController -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ColumnsController -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ColumnsController -> m ColumnsController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ColumnsController -> m ColumnsController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ColumnsController -> m ColumnsController)
-> Data ColumnsController
ColumnsController -> Constr
ColumnsController -> DataType
(forall b. Data b => b -> b)
-> ColumnsController -> ColumnsController
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ColumnsController -> c ColumnsController
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ColumnsController
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> ColumnsController -> u
forall u. (forall d. Data d => d -> u) -> ColumnsController -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ColumnsController -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ColumnsController -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ColumnsController -> m ColumnsController
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ColumnsController -> m ColumnsController
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ColumnsController
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ColumnsController -> c ColumnsController
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ColumnsController)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ColumnsController)
$cDeleteForeignKeyAction :: Constr
$cUpdateForeignKeyAction :: Constr
$cEditForeignKeyAction :: Constr
$cCreateForeignKeyAction :: Constr
$cNewForeignKeyAction :: Constr
$cToggleColumnUniqueAction :: Constr
$cDeleteColumnAction :: Constr
$cUpdateColumnAction :: Constr
$cEditColumnAction :: Constr
$cCreateColumnAction :: Constr
$cNewColumnAction :: Constr
$tColumnsController :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> ColumnsController -> m ColumnsController
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ColumnsController -> m ColumnsController
gmapMp :: (forall d. Data d => d -> m d)
-> ColumnsController -> m ColumnsController
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ColumnsController -> m ColumnsController
gmapM :: (forall d. Data d => d -> m d)
-> ColumnsController -> m ColumnsController
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ColumnsController -> m ColumnsController
gmapQi :: Int -> (forall d. Data d => d -> u) -> ColumnsController -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ColumnsController -> u
gmapQ :: (forall d. Data d => d -> u) -> ColumnsController -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ColumnsController -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ColumnsController -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ColumnsController -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ColumnsController -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ColumnsController -> r
gmapT :: (forall b. Data b => b -> b)
-> ColumnsController -> ColumnsController
$cgmapT :: (forall b. Data b => b -> b)
-> ColumnsController -> ColumnsController
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ColumnsController)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ColumnsController)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ColumnsController)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ColumnsController)
dataTypeOf :: ColumnsController -> DataType
$cdataTypeOf :: ColumnsController -> DataType
toConstr :: ColumnsController -> Constr
$ctoConstr :: ColumnsController -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ColumnsController
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ColumnsController
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ColumnsController -> c ColumnsController
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ColumnsController -> c ColumnsController
$cp1Data :: Typeable ColumnsController
Data)

data EnumsController
    = ShowEnumAction { EnumsController -> Text
enumName :: Text }
    | NewEnumAction
    | CreateEnumAction
    | EditEnumAction { enumName :: Text, EnumsController -> Int
enumId :: Int }
    | UpdateEnumAction
    | DeleteEnumAction { EnumsController -> Int
tableId :: Int }
    deriving (EnumsController -> EnumsController -> Bool
(EnumsController -> EnumsController -> Bool)
-> (EnumsController -> EnumsController -> Bool)
-> Eq EnumsController
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EnumsController -> EnumsController -> Bool
$c/= :: EnumsController -> EnumsController -> Bool
== :: EnumsController -> EnumsController -> Bool
$c== :: EnumsController -> EnumsController -> Bool
Eq, Int -> EnumsController -> ShowS
[EnumsController] -> ShowS
EnumsController -> String
(Int -> EnumsController -> ShowS)
-> (EnumsController -> String)
-> ([EnumsController] -> ShowS)
-> Show EnumsController
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EnumsController] -> ShowS
$cshowList :: [EnumsController] -> ShowS
show :: EnumsController -> String
$cshow :: EnumsController -> String
showsPrec :: Int -> EnumsController -> ShowS
$cshowsPrec :: Int -> EnumsController -> ShowS
Show, Typeable EnumsController
Constr
DataType
Typeable EnumsController
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EnumsController -> c EnumsController)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EnumsController)
-> (EnumsController -> Constr)
-> (EnumsController -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EnumsController))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c EnumsController))
-> ((forall b. Data b => b -> b)
    -> EnumsController -> EnumsController)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EnumsController -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EnumsController -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> EnumsController -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> EnumsController -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> EnumsController -> m EnumsController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> EnumsController -> m EnumsController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> EnumsController -> m EnumsController)
-> Data EnumsController
EnumsController -> Constr
EnumsController -> DataType
(forall b. Data b => b -> b) -> EnumsController -> EnumsController
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumsController -> c EnumsController
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumsController
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> EnumsController -> u
forall u. (forall d. Data d => d -> u) -> EnumsController -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumsController -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumsController -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> EnumsController -> m EnumsController
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EnumsController -> m EnumsController
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumsController
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumsController -> c EnumsController
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnumsController)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EnumsController)
$cDeleteEnumAction :: Constr
$cUpdateEnumAction :: Constr
$cEditEnumAction :: Constr
$cCreateEnumAction :: Constr
$cNewEnumAction :: Constr
$cShowEnumAction :: Constr
$tEnumsController :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> EnumsController -> m EnumsController
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EnumsController -> m EnumsController
gmapMp :: (forall d. Data d => d -> m d)
-> EnumsController -> m EnumsController
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EnumsController -> m EnumsController
gmapM :: (forall d. Data d => d -> m d)
-> EnumsController -> m EnumsController
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> EnumsController -> m EnumsController
gmapQi :: Int -> (forall d. Data d => d -> u) -> EnumsController -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> EnumsController -> u
gmapQ :: (forall d. Data d => d -> u) -> EnumsController -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> EnumsController -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumsController -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumsController -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumsController -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumsController -> r
gmapT :: (forall b. Data b => b -> b) -> EnumsController -> EnumsController
$cgmapT :: (forall b. Data b => b -> b) -> EnumsController -> EnumsController
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EnumsController)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EnumsController)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c EnumsController)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnumsController)
dataTypeOf :: EnumsController -> DataType
$cdataTypeOf :: EnumsController -> DataType
toConstr :: EnumsController -> Constr
$ctoConstr :: EnumsController -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumsController
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumsController
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumsController -> c EnumsController
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumsController -> c EnumsController
$cp1Data :: Typeable EnumsController
Data)

data EnumValuesController
    = NewEnumValueAction { EnumValuesController -> Text
enumName :: Text }
    | CreateEnumValueAction
    | EditEnumValueAction { enumName :: Text, EnumValuesController -> Int
valueId :: Int }
    | UpdateEnumValueAction
    | DeleteEnumValueAction { enumName :: Text, valueId :: Int }
    deriving (EnumValuesController -> EnumValuesController -> Bool
(EnumValuesController -> EnumValuesController -> Bool)
-> (EnumValuesController -> EnumValuesController -> Bool)
-> Eq EnumValuesController
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EnumValuesController -> EnumValuesController -> Bool
$c/= :: EnumValuesController -> EnumValuesController -> Bool
== :: EnumValuesController -> EnumValuesController -> Bool
$c== :: EnumValuesController -> EnumValuesController -> Bool
Eq, Int -> EnumValuesController -> ShowS
[EnumValuesController] -> ShowS
EnumValuesController -> String
(Int -> EnumValuesController -> ShowS)
-> (EnumValuesController -> String)
-> ([EnumValuesController] -> ShowS)
-> Show EnumValuesController
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EnumValuesController] -> ShowS
$cshowList :: [EnumValuesController] -> ShowS
show :: EnumValuesController -> String
$cshow :: EnumValuesController -> String
showsPrec :: Int -> EnumValuesController -> ShowS
$cshowsPrec :: Int -> EnumValuesController -> ShowS
Show, Typeable EnumValuesController
Constr
DataType
Typeable EnumValuesController
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> EnumValuesController
    -> c EnumValuesController)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EnumValuesController)
-> (EnumValuesController -> Constr)
-> (EnumValuesController -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EnumValuesController))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c EnumValuesController))
-> ((forall b. Data b => b -> b)
    -> EnumValuesController -> EnumValuesController)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EnumValuesController -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EnumValuesController -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> EnumValuesController -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> EnumValuesController -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> EnumValuesController -> m EnumValuesController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> EnumValuesController -> m EnumValuesController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> EnumValuesController -> m EnumValuesController)
-> Data EnumValuesController
EnumValuesController -> Constr
EnumValuesController -> DataType
(forall b. Data b => b -> b)
-> EnumValuesController -> EnumValuesController
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> EnumValuesController
-> c EnumValuesController
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumValuesController
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> EnumValuesController -> u
forall u.
(forall d. Data d => d -> u) -> EnumValuesController -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumValuesController -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumValuesController -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> EnumValuesController -> m EnumValuesController
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EnumValuesController -> m EnumValuesController
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumValuesController
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> EnumValuesController
-> c EnumValuesController
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnumValuesController)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EnumValuesController)
$cDeleteEnumValueAction :: Constr
$cUpdateEnumValueAction :: Constr
$cEditEnumValueAction :: Constr
$cCreateEnumValueAction :: Constr
$cNewEnumValueAction :: Constr
$tEnumValuesController :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> EnumValuesController -> m EnumValuesController
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EnumValuesController -> m EnumValuesController
gmapMp :: (forall d. Data d => d -> m d)
-> EnumValuesController -> m EnumValuesController
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EnumValuesController -> m EnumValuesController
gmapM :: (forall d. Data d => d -> m d)
-> EnumValuesController -> m EnumValuesController
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> EnumValuesController -> m EnumValuesController
gmapQi :: Int -> (forall d. Data d => d -> u) -> EnumValuesController -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> EnumValuesController -> u
gmapQ :: (forall d. Data d => d -> u) -> EnumValuesController -> [u]
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> EnumValuesController -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumValuesController -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumValuesController -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumValuesController -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumValuesController -> r
gmapT :: (forall b. Data b => b -> b)
-> EnumValuesController -> EnumValuesController
$cgmapT :: (forall b. Data b => b -> b)
-> EnumValuesController -> EnumValuesController
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EnumValuesController)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EnumValuesController)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c EnumValuesController)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnumValuesController)
dataTypeOf :: EnumValuesController -> DataType
$cdataTypeOf :: EnumValuesController -> DataType
toConstr :: EnumValuesController -> Constr
$ctoConstr :: EnumValuesController -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumValuesController
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumValuesController
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> EnumValuesController
-> c EnumValuesController
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> EnumValuesController
-> c EnumValuesController
$cp1Data :: Typeable EnumValuesController
Data)


data DataController
    = ShowDatabaseAction
    | ShowTableRowsAction { DataController -> Text
tableName :: Text }
    | ShowQueryAction
    | DeleteEntryAction { DataController -> Text
primaryKey :: Text, tableName :: Text }
    | CreateRowAction
    | NewRowAction { tableName :: Text }
    | EditRowAction { tableName :: Text, DataController -> Text
targetPrimaryKey :: Text }
    | UpdateRowAction
    | EditRowValueAction { tableName :: Text, DataController -> Text
targetName :: Text, DataController -> Text
id :: Text }
    | ToggleBooleanFieldAction { tableName :: Text, targetName :: Text, targetPrimaryKey :: Text }
    | UpdateValueAction
    deriving (DataController -> DataController -> Bool
(DataController -> DataController -> Bool)
-> (DataController -> DataController -> Bool) -> Eq DataController
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DataController -> DataController -> Bool
$c/= :: DataController -> DataController -> Bool
== :: DataController -> DataController -> Bool
$c== :: DataController -> DataController -> Bool
Eq, Int -> DataController -> ShowS
[DataController] -> ShowS
DataController -> String
(Int -> DataController -> ShowS)
-> (DataController -> String)
-> ([DataController] -> ShowS)
-> Show DataController
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DataController] -> ShowS
$cshowList :: [DataController] -> ShowS
show :: DataController -> String
$cshow :: DataController -> String
showsPrec :: Int -> DataController -> ShowS
$cshowsPrec :: Int -> DataController -> ShowS
Show, Typeable DataController
Constr
DataType
Typeable DataController
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DataController -> c DataController)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DataController)
-> (DataController -> Constr)
-> (DataController -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DataController))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DataController))
-> ((forall b. Data b => b -> b)
    -> DataController -> DataController)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataController -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataController -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DataController -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DataController -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DataController -> m DataController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DataController -> m DataController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DataController -> m DataController)
-> Data DataController
DataController -> Constr
DataController -> DataType
(forall b. Data b => b -> b) -> DataController -> DataController
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataController -> c DataController
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataController
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> DataController -> u
forall u. (forall d. Data d => d -> u) -> DataController -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataController -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataController -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DataController -> m DataController
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DataController -> m DataController
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataController
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataController -> c DataController
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataController)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DataController)
$cUpdateValueAction :: Constr
$cToggleBooleanFieldAction :: Constr
$cEditRowValueAction :: Constr
$cUpdateRowAction :: Constr
$cEditRowAction :: Constr
$cNewRowAction :: Constr
$cCreateRowAction :: Constr
$cDeleteEntryAction :: Constr
$cShowQueryAction :: Constr
$cShowTableRowsAction :: Constr
$cShowDatabaseAction :: Constr
$tDataController :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> DataController -> m DataController
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DataController -> m DataController
gmapMp :: (forall d. Data d => d -> m d)
-> DataController -> m DataController
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DataController -> m DataController
gmapM :: (forall d. Data d => d -> m d)
-> DataController -> m DataController
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DataController -> m DataController
gmapQi :: Int -> (forall d. Data d => d -> u) -> DataController -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DataController -> u
gmapQ :: (forall d. Data d => d -> u) -> DataController -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DataController -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataController -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataController -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataController -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataController -> r
gmapT :: (forall b. Data b => b -> b) -> DataController -> DataController
$cgmapT :: (forall b. Data b => b -> b) -> DataController -> DataController
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DataController)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DataController)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DataController)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataController)
dataTypeOf :: DataController -> DataType
$cdataTypeOf :: DataController -> DataType
toConstr :: DataController -> Constr
$ctoConstr :: DataController -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataController
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataController
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataController -> c DataController
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataController -> c DataController
$cp1Data :: Typeable DataController
Data)

data LogsController
    = AppLogsAction
    | PostgresLogsAction
    | OpenEditorAction
    deriving (LogsController -> LogsController -> Bool
(LogsController -> LogsController -> Bool)
-> (LogsController -> LogsController -> Bool) -> Eq LogsController
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LogsController -> LogsController -> Bool
$c/= :: LogsController -> LogsController -> Bool
== :: LogsController -> LogsController -> Bool
$c== :: LogsController -> LogsController -> Bool
Eq, Int -> LogsController -> ShowS
[LogsController] -> ShowS
LogsController -> String
(Int -> LogsController -> ShowS)
-> (LogsController -> String)
-> ([LogsController] -> ShowS)
-> Show LogsController
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LogsController] -> ShowS
$cshowList :: [LogsController] -> ShowS
show :: LogsController -> String
$cshow :: LogsController -> String
showsPrec :: Int -> LogsController -> ShowS
$cshowsPrec :: Int -> LogsController -> ShowS
Show, Typeable LogsController
Constr
DataType
Typeable LogsController
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> LogsController -> c LogsController)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c LogsController)
-> (LogsController -> Constr)
-> (LogsController -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c LogsController))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c LogsController))
-> ((forall b. Data b => b -> b)
    -> LogsController -> LogsController)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> LogsController -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> LogsController -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> LogsController -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> LogsController -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> LogsController -> m LogsController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> LogsController -> m LogsController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> LogsController -> m LogsController)
-> Data LogsController
LogsController -> Constr
LogsController -> DataType
(forall b. Data b => b -> b) -> LogsController -> LogsController
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LogsController -> c LogsController
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LogsController
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> LogsController -> u
forall u. (forall d. Data d => d -> u) -> LogsController -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LogsController -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LogsController -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> LogsController -> m LogsController
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> LogsController -> m LogsController
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LogsController
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LogsController -> c LogsController
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LogsController)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c LogsController)
$cOpenEditorAction :: Constr
$cPostgresLogsAction :: Constr
$cAppLogsAction :: Constr
$tLogsController :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> LogsController -> m LogsController
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> LogsController -> m LogsController
gmapMp :: (forall d. Data d => d -> m d)
-> LogsController -> m LogsController
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> LogsController -> m LogsController
gmapM :: (forall d. Data d => d -> m d)
-> LogsController -> m LogsController
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> LogsController -> m LogsController
gmapQi :: Int -> (forall d. Data d => d -> u) -> LogsController -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> LogsController -> u
gmapQ :: (forall d. Data d => d -> u) -> LogsController -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> LogsController -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LogsController -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LogsController -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LogsController -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LogsController -> r
gmapT :: (forall b. Data b => b -> b) -> LogsController -> LogsController
$cgmapT :: (forall b. Data b => b -> b) -> LogsController -> LogsController
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c LogsController)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c LogsController)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c LogsController)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LogsController)
dataTypeOf :: LogsController -> DataType
$cdataTypeOf :: LogsController -> DataType
toConstr :: LogsController -> Constr
$ctoConstr :: LogsController -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LogsController
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LogsController
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LogsController -> c LogsController
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LogsController -> c LogsController
$cp1Data :: Typeable LogsController
Data)

data CodeGenController
    = GeneratorsAction
    | NewControllerAction
    | NewScriptAction
    | NewViewAction
    | NewMailAction
    | NewActionAction
    | NewApplicationAction
    | NewMigrationAction
    | NewJobAction
    | CreateControllerAction
    | CreateScriptAction
    | CreateViewAction
    | CreateMailAction
    | CreateActionAction
    | CreateApplicationAction
    | CreateMigrationAction
    | CreateJobAction
    | OpenControllerAction
    deriving (CodeGenController -> CodeGenController -> Bool
(CodeGenController -> CodeGenController -> Bool)
-> (CodeGenController -> CodeGenController -> Bool)
-> Eq CodeGenController
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CodeGenController -> CodeGenController -> Bool
$c/= :: CodeGenController -> CodeGenController -> Bool
== :: CodeGenController -> CodeGenController -> Bool
$c== :: CodeGenController -> CodeGenController -> Bool
Eq, Int -> CodeGenController -> ShowS
[CodeGenController] -> ShowS
CodeGenController -> String
(Int -> CodeGenController -> ShowS)
-> (CodeGenController -> String)
-> ([CodeGenController] -> ShowS)
-> Show CodeGenController
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CodeGenController] -> ShowS
$cshowList :: [CodeGenController] -> ShowS
show :: CodeGenController -> String
$cshow :: CodeGenController -> String
showsPrec :: Int -> CodeGenController -> ShowS
$cshowsPrec :: Int -> CodeGenController -> ShowS
Show, Typeable CodeGenController
Constr
DataType
Typeable CodeGenController
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> CodeGenController
    -> c CodeGenController)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CodeGenController)
-> (CodeGenController -> Constr)
-> (CodeGenController -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CodeGenController))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CodeGenController))
-> ((forall b. Data b => b -> b)
    -> CodeGenController -> CodeGenController)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CodeGenController -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CodeGenController -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> CodeGenController -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CodeGenController -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> CodeGenController -> m CodeGenController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CodeGenController -> m CodeGenController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CodeGenController -> m CodeGenController)
-> Data CodeGenController
CodeGenController -> Constr
CodeGenController -> DataType
(forall b. Data b => b -> b)
-> CodeGenController -> CodeGenController
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CodeGenController -> c CodeGenController
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CodeGenController
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> CodeGenController -> u
forall u. (forall d. Data d => d -> u) -> CodeGenController -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CodeGenController -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CodeGenController -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CodeGenController -> m CodeGenController
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CodeGenController -> m CodeGenController
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CodeGenController
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CodeGenController -> c CodeGenController
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CodeGenController)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CodeGenController)
$cOpenControllerAction :: Constr
$cCreateJobAction :: Constr
$cCreateMigrationAction :: Constr
$cCreateApplicationAction :: Constr
$cCreateActionAction :: Constr
$cCreateMailAction :: Constr
$cCreateViewAction :: Constr
$cCreateScriptAction :: Constr
$cCreateControllerAction :: Constr
$cNewJobAction :: Constr
$cNewMigrationAction :: Constr
$cNewApplicationAction :: Constr
$cNewActionAction :: Constr
$cNewMailAction :: Constr
$cNewViewAction :: Constr
$cNewScriptAction :: Constr
$cNewControllerAction :: Constr
$cGeneratorsAction :: Constr
$tCodeGenController :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> CodeGenController -> m CodeGenController
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CodeGenController -> m CodeGenController
gmapMp :: (forall d. Data d => d -> m d)
-> CodeGenController -> m CodeGenController
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CodeGenController -> m CodeGenController
gmapM :: (forall d. Data d => d -> m d)
-> CodeGenController -> m CodeGenController
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CodeGenController -> m CodeGenController
gmapQi :: Int -> (forall d. Data d => d -> u) -> CodeGenController -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CodeGenController -> u
gmapQ :: (forall d. Data d => d -> u) -> CodeGenController -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CodeGenController -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CodeGenController -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CodeGenController -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CodeGenController -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CodeGenController -> r
gmapT :: (forall b. Data b => b -> b)
-> CodeGenController -> CodeGenController
$cgmapT :: (forall b. Data b => b -> b)
-> CodeGenController -> CodeGenController
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CodeGenController)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CodeGenController)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c CodeGenController)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CodeGenController)
dataTypeOf :: CodeGenController -> DataType
$cdataTypeOf :: CodeGenController -> DataType
toConstr :: CodeGenController -> Constr
$ctoConstr :: CodeGenController -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CodeGenController
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CodeGenController
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CodeGenController -> c CodeGenController
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CodeGenController -> c CodeGenController
$cp1Data :: Typeable CodeGenController
Data)


data DynamicField = DynamicField
    { DynamicField -> Maybe ByteString
fieldValue :: Maybe ByteString
    , DynamicField -> ByteString
fieldName :: ByteString
    } deriving (Int -> DynamicField -> ShowS
[DynamicField] -> ShowS
DynamicField -> String
(Int -> DynamicField -> ShowS)
-> (DynamicField -> String)
-> ([DynamicField] -> ShowS)
-> Show DynamicField
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DynamicField] -> ShowS
$cshowList :: [DynamicField] -> ShowS
show :: DynamicField -> String
$cshow :: DynamicField -> String
showsPrec :: Int -> DynamicField -> ShowS
$cshowsPrec :: Int -> DynamicField -> ShowS
Show)

data ColumnDefinition = ColumnDefinition
    { ColumnDefinition -> Text
columnName :: Text
    , ColumnDefinition -> Text
columnType :: Text
    , ColumnDefinition -> Maybe Text
columnDefault :: Maybe Text
    , ColumnDefinition -> Bool
isNullable :: Bool
    } deriving (Int -> ColumnDefinition -> ShowS
[ColumnDefinition] -> ShowS
ColumnDefinition -> String
(Int -> ColumnDefinition -> ShowS)
-> (ColumnDefinition -> String)
-> ([ColumnDefinition] -> ShowS)
-> Show ColumnDefinition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ColumnDefinition] -> ShowS
$cshowList :: [ColumnDefinition] -> ShowS
show :: ColumnDefinition -> String
$cshow :: ColumnDefinition -> String
showsPrec :: Int -> ColumnDefinition -> ShowS
$cshowsPrec :: Int -> ColumnDefinition -> ShowS
Show)


-- | Keeps track of all all available apps in the projects. Used to display 
-- the apps inside the sidebar navigation
--
-- Usually this list is like: @["Web"]@ or @["Web", "Admin"]@
newtype AvailableApps = AvailableApps [Text]

-- | Wrapper to pass the app url to the layout.
-- Usually "http://localhost:8000"
newtype AppUrl = AppUrl Text

-- | List of all controllers. Used inside e.g. the Schema Designer to decide whether to display
-- the 'Generate Controller' option
newtype WebControllers = WebControllers [Text]