module PGIP.GraphQL.Resolver.OMS (resolve) where

import PGIP.GraphQL.Resolver.ToResult

import PGIP.GraphQL.Result as GraphQLResult
import PGIP.GraphQL.Result.Action as GraphQLResultAction
import PGIP.GraphQL.Result.Mapping as GraphQLResultMapping
import PGIP.GraphQL.Result.PremiseSelection as GraphQLResultPremiseSelection
import PGIP.GraphQL.Result.ReasonerConfiguration as GraphQLResultReasonerConfiguration
import PGIP.GraphQL.Result.ReasoningAttempt as GraphQLResultReasoningAttempt
import PGIP.GraphQL.Result.Sentence as GraphQLResultSentence
import PGIP.GraphQL.Result.StringReference (StringReference (..))
import PGIP.GraphQL.Result.Symbol as GraphQLResultSymbol

import PGIP.Shared

import Driver.Options
import Persistence.Database
import Persistence.Schema as DatabaseSchema
import Persistence.Utils

import Database.Esqueleto

import Control.Monad.IO.Class (MonadIO (..))
import Control.Monad.Fail ()

resolve :: HetcatsOpts -> Cache -> String -> IO (Maybe GraphQLResult.Result)
resolve :: HetcatsOpts -> Cache -> String -> IO (Maybe Result)
resolve opts :: HetcatsOpts
opts _ locIdVar :: String
locIdVar =
  DBConfig
-> DBMonad (NoLoggingT IO) (Maybe Result) -> IO (Maybe Result)
forall (m :: * -> *) a.
(MonadIO m, MonadBaseControl IO m, MonadUnliftIO m, MonadFail m) =>
DBConfig -> DBMonad (NoLoggingT m) a -> m a
onDatabase (HetcatsOpts -> DBConfig
databaseConfig HetcatsOpts
opts) (DBMonad (NoLoggingT IO) (Maybe Result) -> IO (Maybe Result))
-> DBMonad (NoLoggingT IO) (Maybe Result) -> IO (Maybe Result)
forall a b. (a -> b) -> a -> b
$ String -> DBMonad (NoLoggingT IO) (Maybe Result)
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
String -> DBMonad m (Maybe Result)
resolveDB String
locIdVar

resolveDB :: (MonadIO m, MonadFail m) => String -> DBMonad m (Maybe GraphQLResult.Result)
resolveDB :: String -> DBMonad m (Maybe Result)
resolveDB locIdVar :: String
locIdVar = do
  [(Entity OMS, Entity LocIdBase, Entity ConservativityStatus,
  Maybe (Entity FileRange), Maybe (Entity LocIdBase),
  Maybe (Entity SignatureMorphism), Entity Language, Entity Logic,
  Maybe (Entity LocIdBase), Maybe (Entity SignatureMorphism))]
omsL <-
    SqlQuery
  (SqlExpr (Entity OMS), SqlExpr (Entity LocIdBase),
   SqlExpr (Entity ConservativityStatus),
   SqlExpr (Maybe (Entity FileRange)),
   SqlExpr (Maybe (Entity LocIdBase)),
   SqlExpr (Maybe (Entity SignatureMorphism)),
   SqlExpr (Entity Language), SqlExpr (Entity Logic),
   SqlExpr (Maybe (Entity LocIdBase)),
   SqlExpr (Maybe (Entity SignatureMorphism)))
-> ReaderT
     SqlBackend
     m
     [(Entity OMS, Entity LocIdBase, Entity ConservativityStatus,
       Maybe (Entity FileRange), Maybe (Entity LocIdBase),
       Maybe (Entity SignatureMorphism), Entity Language, Entity Logic,
       Maybe (Entity LocIdBase), Maybe (Entity SignatureMorphism))]
forall a r (m :: * -> *).
(SqlSelect a r, MonadIO m) =>
SqlQuery a -> SqlReadT m [r]
select (SqlQuery
   (SqlExpr (Entity OMS), SqlExpr (Entity LocIdBase),
    SqlExpr (Entity ConservativityStatus),
    SqlExpr (Maybe (Entity FileRange)),
    SqlExpr (Maybe (Entity LocIdBase)),
    SqlExpr (Maybe (Entity SignatureMorphism)),
    SqlExpr (Entity Language), SqlExpr (Entity Logic),
    SqlExpr (Maybe (Entity LocIdBase)),
    SqlExpr (Maybe (Entity SignatureMorphism)))
 -> ReaderT
      SqlBackend
      m
      [(Entity OMS, Entity LocIdBase, Entity ConservativityStatus,
        Maybe (Entity FileRange), Maybe (Entity LocIdBase),
        Maybe (Entity SignatureMorphism), Entity Language, Entity Logic,
        Maybe (Entity LocIdBase), Maybe (Entity SignatureMorphism))])
-> SqlQuery
     (SqlExpr (Entity OMS), SqlExpr (Entity LocIdBase),
      SqlExpr (Entity ConservativityStatus),
      SqlExpr (Maybe (Entity FileRange)),
      SqlExpr (Maybe (Entity LocIdBase)),
      SqlExpr (Maybe (Entity SignatureMorphism)),
      SqlExpr (Entity Language), SqlExpr (Entity Logic),
      SqlExpr (Maybe (Entity LocIdBase)),
      SqlExpr (Maybe (Entity SignatureMorphism)))
-> ReaderT
     SqlBackend
     m
     [(Entity OMS, Entity LocIdBase, Entity ConservativityStatus,
       Maybe (Entity FileRange), Maybe (Entity LocIdBase),
       Maybe (Entity SignatureMorphism), Entity Language, Entity Logic,
       Maybe (Entity LocIdBase), Maybe (Entity SignatureMorphism))]
forall a b. (a -> b) -> a -> b
$ (LeftOuterJoin
   (LeftOuterJoin
      (InnerJoin
         (InnerJoin
            (LeftOuterJoin
               (LeftOuterJoin
                  (LeftOuterJoin
                     (InnerJoin
                        (InnerJoin (SqlExpr (Entity OMS)) (SqlExpr (Entity LocIdBase)))
                        (SqlExpr (Entity ConservativityStatus)))
                     (SqlExpr (Maybe (Entity FileRange))))
                  (SqlExpr (Maybe (Entity LocIdBase))))
               (SqlExpr (Maybe (Entity SignatureMorphism))))
            (SqlExpr (Entity Language)))
         (SqlExpr (Entity Logic)))
      (SqlExpr (Maybe (Entity LocIdBase))))
   (SqlExpr (Maybe (Entity SignatureMorphism)))
 -> SqlQuery
      (SqlExpr (Entity OMS), SqlExpr (Entity LocIdBase),
       SqlExpr (Entity ConservativityStatus),
       SqlExpr (Maybe (Entity FileRange)),
       SqlExpr (Maybe (Entity LocIdBase)),
       SqlExpr (Maybe (Entity SignatureMorphism)),
       SqlExpr (Entity Language), SqlExpr (Entity Logic),
       SqlExpr (Maybe (Entity LocIdBase)),
       SqlExpr (Maybe (Entity SignatureMorphism))))
-> SqlQuery
     (SqlExpr (Entity OMS), SqlExpr (Entity LocIdBase),
      SqlExpr (Entity ConservativityStatus),
      SqlExpr (Maybe (Entity FileRange)),
      SqlExpr (Maybe (Entity LocIdBase)),
      SqlExpr (Maybe (Entity SignatureMorphism)),
      SqlExpr (Entity Language), SqlExpr (Entity Logic),
      SqlExpr (Maybe (Entity LocIdBase)),
      SqlExpr (Maybe (Entity SignatureMorphism)))
forall a b. From a => (a -> SqlQuery b) -> SqlQuery b
from ((LeftOuterJoin
    (LeftOuterJoin
       (InnerJoin
          (InnerJoin
             (LeftOuterJoin
                (LeftOuterJoin
                   (LeftOuterJoin
                      (InnerJoin
                         (InnerJoin (SqlExpr (Entity OMS)) (SqlExpr (Entity LocIdBase)))
                         (SqlExpr (Entity ConservativityStatus)))
                      (SqlExpr (Maybe (Entity FileRange))))
                   (SqlExpr (Maybe (Entity LocIdBase))))
                (SqlExpr (Maybe (Entity SignatureMorphism))))
             (SqlExpr (Entity Language)))
          (SqlExpr (Entity Logic)))
       (SqlExpr (Maybe (Entity LocIdBase))))
    (SqlExpr (Maybe (Entity SignatureMorphism)))
  -> SqlQuery
       (SqlExpr (Entity OMS), SqlExpr (Entity LocIdBase),
        SqlExpr (Entity ConservativityStatus),
        SqlExpr (Maybe (Entity FileRange)),
        SqlExpr (Maybe (Entity LocIdBase)),
        SqlExpr (Maybe (Entity SignatureMorphism)),
        SqlExpr (Entity Language), SqlExpr (Entity Logic),
        SqlExpr (Maybe (Entity LocIdBase)),
        SqlExpr (Maybe (Entity SignatureMorphism))))
 -> SqlQuery
      (SqlExpr (Entity OMS), SqlExpr (Entity LocIdBase),
       SqlExpr (Entity ConservativityStatus),
       SqlExpr (Maybe (Entity FileRange)),
       SqlExpr (Maybe (Entity LocIdBase)),
       SqlExpr (Maybe (Entity SignatureMorphism)),
       SqlExpr (Entity Language), SqlExpr (Entity Logic),
       SqlExpr (Maybe (Entity LocIdBase)),
       SqlExpr (Maybe (Entity SignatureMorphism))))
-> (LeftOuterJoin
      (LeftOuterJoin
         (InnerJoin
            (InnerJoin
               (LeftOuterJoin
                  (LeftOuterJoin
                     (LeftOuterJoin
                        (InnerJoin
                           (InnerJoin (SqlExpr (Entity OMS)) (SqlExpr (Entity LocIdBase)))
                           (SqlExpr (Entity ConservativityStatus)))
                        (SqlExpr (Maybe (Entity FileRange))))
                     (SqlExpr (Maybe (Entity LocIdBase))))
                  (SqlExpr (Maybe (Entity SignatureMorphism))))
               (SqlExpr (Entity Language)))
            (SqlExpr (Entity Logic)))
         (SqlExpr (Maybe (Entity LocIdBase))))
      (SqlExpr (Maybe (Entity SignatureMorphism)))
    -> SqlQuery
         (SqlExpr (Entity OMS), SqlExpr (Entity LocIdBase),
          SqlExpr (Entity ConservativityStatus),
          SqlExpr (Maybe (Entity FileRange)),
          SqlExpr (Maybe (Entity LocIdBase)),
          SqlExpr (Maybe (Entity SignatureMorphism)),
          SqlExpr (Entity Language), SqlExpr (Entity Logic),
          SqlExpr (Maybe (Entity LocIdBase)),
          SqlExpr (Maybe (Entity SignatureMorphism))))
-> SqlQuery
     (SqlExpr (Entity OMS), SqlExpr (Entity LocIdBase),
      SqlExpr (Entity ConservativityStatus),
      SqlExpr (Maybe (Entity FileRange)),
      SqlExpr (Maybe (Entity LocIdBase)),
      SqlExpr (Maybe (Entity SignatureMorphism)),
      SqlExpr (Entity Language), SqlExpr (Entity Logic),
      SqlExpr (Maybe (Entity LocIdBase)),
      SqlExpr (Maybe (Entity SignatureMorphism)))
forall a b. (a -> b) -> a -> b
$ \(oms :: SqlExpr (Entity OMS)
oms `InnerJoin` loc_id_bases :: SqlExpr (Entity LocIdBase)
loc_id_bases
                          `InnerJoin` conservativity_statuses :: SqlExpr (Entity ConservativityStatus)
conservativity_statuses
                          `LeftOuterJoin` file_ranges :: SqlExpr (Maybe (Entity FileRange))
file_ranges
                          `LeftOuterJoin` loc_id_basesFreeNormalForm :: SqlExpr (Maybe (Entity LocIdBase))
loc_id_basesFreeNormalForm
                          `LeftOuterJoin` signature_morphismsFreeNormalForm :: SqlExpr (Maybe (Entity SignatureMorphism))
signature_morphismsFreeNormalForm
                          `InnerJoin` languages :: SqlExpr (Entity Language)
languages
                          `InnerJoin` logics :: SqlExpr (Entity Logic)
logics
                          `LeftOuterJoin` loc_id_basesNormalForm :: SqlExpr (Maybe (Entity LocIdBase))
loc_id_basesNormalForm
                          `LeftOuterJoin` signature_morphismsNormalForm :: SqlExpr (Maybe (Entity SignatureMorphism))
signature_morphismsNormalForm) -> do
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Maybe (Entity SignatureMorphism))
signature_morphismsNormalForm SqlExpr (Maybe (Entity SignatureMorphism))
-> EntityField SignatureMorphism (Key SignatureMorphism)
-> SqlExpr (Value (Maybe (Key SignatureMorphism)))
forall val typ.
(PersistEntity val, PersistField typ) =>
SqlExpr (Maybe (Entity val))
-> EntityField val typ -> SqlExpr (Value (Maybe typ))
?. EntityField SignatureMorphism (Key SignatureMorphism)
forall typ.
(typ ~ Key SignatureMorphism) =>
EntityField SignatureMorphism typ
SignatureMorphismId SqlExpr (Value (Maybe (Key SignatureMorphism)))
-> SqlExpr (Value (Maybe (Key SignatureMorphism)))
-> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==. SqlExpr (Entity OMS)
oms SqlExpr (Entity OMS)
-> EntityField OMS (Maybe (Key SignatureMorphism))
-> SqlExpr (Value (Maybe (Key SignatureMorphism)))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField OMS (Maybe (Key SignatureMorphism))
forall typ.
(typ ~ Maybe (Key SignatureMorphism)) =>
EntityField OMS typ
OMSNormalFormSignatureMorphismId)
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Maybe (Entity LocIdBase))
loc_id_basesNormalForm SqlExpr (Maybe (Entity LocIdBase))
-> EntityField LocIdBase (Key LocIdBase)
-> SqlExpr (Value (Maybe (Key LocIdBase)))
forall val typ.
(PersistEntity val, PersistField typ) =>
SqlExpr (Maybe (Entity val))
-> EntityField val typ -> SqlExpr (Value (Maybe typ))
?. EntityField LocIdBase (Key LocIdBase)
forall typ. (typ ~ Key LocIdBase) => EntityField LocIdBase typ
LocIdBaseId SqlExpr (Value (Maybe (Key LocIdBase)))
-> SqlExpr (Value (Maybe (Key LocIdBase))) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==. SqlExpr (Value (Maybe (Key LocIdBase)))
-> SqlExpr (Value (Maybe (Key LocIdBase)))
forall a b. SqlExpr (Value a) -> SqlExpr (Value b)
coerceId (SqlExpr (Entity OMS)
oms SqlExpr (Entity OMS)
-> EntityField OMS (Maybe (Key LocIdBase))
-> SqlExpr (Value (Maybe (Key LocIdBase)))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField OMS (Maybe (Key LocIdBase))
forall typ. (typ ~ Maybe (Key LocIdBase)) => EntityField OMS typ
OMSNormalFormId))
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Entity Logic)
logics SqlExpr (Entity Logic)
-> EntityField Logic (Key Logic) -> SqlExpr (Value (Key Logic))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField Logic (Key Logic)
forall typ. (typ ~ Key Logic) => EntityField Logic typ
LogicId SqlExpr (Value (Key Logic))
-> SqlExpr (Value (Key Logic)) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==. SqlExpr (Entity OMS)
oms SqlExpr (Entity OMS)
-> EntityField OMS (Key Logic) -> SqlExpr (Value (Key Logic))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField OMS (Key Logic)
forall typ. (typ ~ Key Logic) => EntityField OMS typ
OMSLogicId)
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Entity Language)
languages SqlExpr (Entity Language)
-> EntityField Language (Key Language)
-> SqlExpr (Value (Key Language))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField Language (Key Language)
forall typ. (typ ~ Key Language) => EntityField Language typ
LanguageId SqlExpr (Value (Key Language))
-> SqlExpr (Value (Key Language)) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==. SqlExpr (Entity OMS)
oms SqlExpr (Entity OMS)
-> EntityField OMS (Key Language) -> SqlExpr (Value (Key Language))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField OMS (Key Language)
forall typ. (typ ~ Key Language) => EntityField OMS typ
OMSLanguageId)
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Maybe (Entity SignatureMorphism))
signature_morphismsFreeNormalForm SqlExpr (Maybe (Entity SignatureMorphism))
-> EntityField SignatureMorphism (Key SignatureMorphism)
-> SqlExpr (Value (Maybe (Key SignatureMorphism)))
forall val typ.
(PersistEntity val, PersistField typ) =>
SqlExpr (Maybe (Entity val))
-> EntityField val typ -> SqlExpr (Value (Maybe typ))
?. EntityField SignatureMorphism (Key SignatureMorphism)
forall typ.
(typ ~ Key SignatureMorphism) =>
EntityField SignatureMorphism typ
SignatureMorphismId SqlExpr (Value (Maybe (Key SignatureMorphism)))
-> SqlExpr (Value (Maybe (Key SignatureMorphism)))
-> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==. SqlExpr (Entity OMS)
oms SqlExpr (Entity OMS)
-> EntityField OMS (Maybe (Key SignatureMorphism))
-> SqlExpr (Value (Maybe (Key SignatureMorphism)))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField OMS (Maybe (Key SignatureMorphism))
forall typ.
(typ ~ Maybe (Key SignatureMorphism)) =>
EntityField OMS typ
OMSFreeNormalFormSignatureMorphismId)
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Maybe (Entity LocIdBase))
loc_id_basesFreeNormalForm SqlExpr (Maybe (Entity LocIdBase))
-> EntityField LocIdBase (Key LocIdBase)
-> SqlExpr (Value (Maybe (Key LocIdBase)))
forall val typ.
(PersistEntity val, PersistField typ) =>
SqlExpr (Maybe (Entity val))
-> EntityField val typ -> SqlExpr (Value (Maybe typ))
?. EntityField LocIdBase (Key LocIdBase)
forall typ. (typ ~ Key LocIdBase) => EntityField LocIdBase typ
LocIdBaseId SqlExpr (Value (Maybe (Key LocIdBase)))
-> SqlExpr (Value (Maybe (Key LocIdBase))) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==. SqlExpr (Value (Maybe (Key LocIdBase)))
-> SqlExpr (Value (Maybe (Key LocIdBase)))
forall a b. SqlExpr (Value a) -> SqlExpr (Value b)
coerceId (SqlExpr (Entity OMS)
oms SqlExpr (Entity OMS)
-> EntityField OMS (Maybe (Key LocIdBase))
-> SqlExpr (Value (Maybe (Key LocIdBase)))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField OMS (Maybe (Key LocIdBase))
forall typ. (typ ~ Maybe (Key LocIdBase)) => EntityField OMS typ
OMSFreeNormalFormId))
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Maybe (Entity FileRange))
file_ranges SqlExpr (Maybe (Entity FileRange))
-> EntityField FileRange (Key FileRange)
-> SqlExpr (Value (Maybe (Key FileRange)))
forall val typ.
(PersistEntity val, PersistField typ) =>
SqlExpr (Maybe (Entity val))
-> EntityField val typ -> SqlExpr (Value (Maybe typ))
?. EntityField FileRange (Key FileRange)
forall typ. (typ ~ Key FileRange) => EntityField FileRange typ
FileRangeId SqlExpr (Value (Maybe (Key FileRange)))
-> SqlExpr (Value (Maybe (Key FileRange))) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==. SqlExpr (Entity OMS)
oms SqlExpr (Entity OMS)
-> EntityField OMS (Maybe (Key FileRange))
-> SqlExpr (Value (Maybe (Key FileRange)))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField OMS (Maybe (Key FileRange))
forall typ. (typ ~ Maybe (Key FileRange)) => EntityField OMS typ
OMSNameFileRangeId)
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Entity ConservativityStatus)
conservativity_statuses SqlExpr (Entity ConservativityStatus)
-> EntityField ConservativityStatus (Key ConservativityStatus)
-> SqlExpr (Value (Key ConservativityStatus))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField ConservativityStatus (Key ConservativityStatus)
forall typ.
(typ ~ Key ConservativityStatus) =>
EntityField ConservativityStatus typ
ConservativityStatusId SqlExpr (Value (Key ConservativityStatus))
-> SqlExpr (Value (Key ConservativityStatus))
-> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==. SqlExpr (Entity OMS)
oms SqlExpr (Entity OMS)
-> EntityField OMS (Key ConservativityStatus)
-> SqlExpr (Value (Key ConservativityStatus))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField OMS (Key ConservativityStatus)
forall typ. (typ ~ Key ConservativityStatus) => EntityField OMS typ
OMSConservativityStatusId)
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Entity LocIdBase)
loc_id_bases SqlExpr (Entity LocIdBase)
-> EntityField LocIdBase (Key LocIdBase)
-> SqlExpr (Value (Key LocIdBase))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField LocIdBase (Key LocIdBase)
forall typ. (typ ~ Key LocIdBase) => EntityField LocIdBase typ
LocIdBaseId SqlExpr (Value (Key LocIdBase))
-> SqlExpr (Value (Key LocIdBase)) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==. SqlExpr (Value (Key OMS)) -> SqlExpr (Value (Key LocIdBase))
forall a b. SqlExpr (Value a) -> SqlExpr (Value b)
coerceId (SqlExpr (Entity OMS)
oms SqlExpr (Entity OMS)
-> EntityField OMS (Key OMS) -> SqlExpr (Value (Key OMS))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField OMS (Key OMS)
forall typ. (typ ~ Key OMS) => EntityField OMS typ
OMSId))
      SqlExpr (Value Bool) -> SqlQuery ()
where_ (SqlExpr (Entity LocIdBase)
loc_id_bases SqlExpr (Entity LocIdBase)
-> EntityField LocIdBase String -> SqlExpr (Value String)
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField LocIdBase String
forall typ. (typ ~ String) => EntityField LocIdBase typ
LocIdBaseLocId SqlExpr (Value String)
-> SqlExpr (Value String) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==. String -> SqlExpr (Value String)
forall typ. PersistField typ => typ -> SqlExpr (Value typ)
val String
locIdVar)
      (SqlExpr (Entity OMS), SqlExpr (Entity LocIdBase),
 SqlExpr (Entity ConservativityStatus),
 SqlExpr (Maybe (Entity FileRange)),
 SqlExpr (Maybe (Entity LocIdBase)),
 SqlExpr (Maybe (Entity SignatureMorphism)),
 SqlExpr (Entity Language), SqlExpr (Entity Logic),
 SqlExpr (Maybe (Entity LocIdBase)),
 SqlExpr (Maybe (Entity SignatureMorphism)))
-> SqlQuery
     (SqlExpr (Entity OMS), SqlExpr (Entity LocIdBase),
      SqlExpr (Entity ConservativityStatus),
      SqlExpr (Maybe (Entity FileRange)),
      SqlExpr (Maybe (Entity LocIdBase)),
      SqlExpr (Maybe (Entity SignatureMorphism)),
      SqlExpr (Entity Language), SqlExpr (Entity Logic),
      SqlExpr (Maybe (Entity LocIdBase)),
      SqlExpr (Maybe (Entity SignatureMorphism)))
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlExpr (Entity OMS)
oms, SqlExpr (Entity LocIdBase)
loc_id_bases, SqlExpr (Entity ConservativityStatus)
conservativity_statuses, SqlExpr (Maybe (Entity FileRange))
file_ranges,
              SqlExpr (Maybe (Entity LocIdBase))
loc_id_basesFreeNormalForm, SqlExpr (Maybe (Entity SignatureMorphism))
signature_morphismsFreeNormalForm,
              SqlExpr (Entity Language)
languages, SqlExpr (Entity Logic)
logics,
              SqlExpr (Maybe (Entity LocIdBase))
loc_id_basesNormalForm, SqlExpr (Maybe (Entity SignatureMorphism))
signature_morphismsNormalForm)
  case [(Entity OMS, Entity LocIdBase, Entity ConservativityStatus,
  Maybe (Entity FileRange), Maybe (Entity LocIdBase),
  Maybe (Entity SignatureMorphism), Entity Language, Entity Logic,
  Maybe (Entity LocIdBase), Maybe (Entity SignatureMorphism))]
omsL of
    [] -> Maybe Result -> DBMonad m (Maybe Result)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Result
forall a. Maybe a
Nothing
    (omsEntity :: Entity OMS
omsEntity, locIdBaseOMS :: Entity LocIdBase
locIdBaseOMS@(Entity omsKey :: Key LocIdBase
omsKey _ ), conservativityStatusEntity :: Entity ConservativityStatus
conservativityStatusEntity, fileRangeM :: Maybe (Entity FileRange)
fileRangeM,
     freeNormalFormLocIdBaseM :: Maybe (Entity LocIdBase)
freeNormalFormLocIdBaseM, freeNormalFormSignatureMorphismM :: Maybe (Entity SignatureMorphism)
freeNormalFormSignatureMorphismM,
     languageEntity :: Entity Language
languageEntity, logicEntity :: Entity Logic
logicEntity,
     normalFormLocIdBaseM :: Maybe (Entity LocIdBase)
normalFormLocIdBaseM, normalFormSignatureMorphismM :: Maybe (Entity SignatureMorphism)
normalFormSignatureMorphismM) : _ -> do
       [ReasoningAttempt]
consistencyCheckAttemptResults <- Key LocIdBase -> DBMonad m [ReasoningAttempt]
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
Key LocIdBase -> DBMonad m [ReasoningAttempt]
resolveConsistencyChecks Key LocIdBase
omsKey
       [Mapping]
mappingSourceResults <- Key LocIdBase
-> EntityField Mapping (Key LocIdBase) -> DBMonad m [Mapping]
forall (m :: * -> *).
MonadIO m =>
Key LocIdBase
-> EntityField Mapping (Key LocIdBase) -> DBMonad m [Mapping]
resolveMappings Key LocIdBase
omsKey EntityField Mapping (Key LocIdBase)
forall typ. (typ ~ Key LocIdBase) => EntityField Mapping typ
MappingSourceId
       [Mapping]
mappingTargetResults <- Key LocIdBase
-> EntityField Mapping (Key LocIdBase) -> DBMonad m [Mapping]
forall (m :: * -> *).
MonadIO m =>
Key LocIdBase
-> EntityField Mapping (Key LocIdBase) -> DBMonad m [Mapping]
resolveMappings Key LocIdBase
omsKey EntityField Mapping (Key LocIdBase)
forall typ. (typ ~ Key LocIdBase) => EntityField Mapping typ
MappingTargetId
       [Sentence]
sentenceResults <- Key LocIdBase -> DBMonad m [Sentence]
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
Key LocIdBase -> DBMonad m [Sentence]
resolveSentences Key LocIdBase
omsKey
       Maybe StringReference
serializationResult <- case OMS -> Maybe (Key Serialization)
oMSSerializationId (OMS -> Maybe (Key Serialization))
-> OMS -> Maybe (Key Serialization)
forall a b. (a -> b) -> a -> b
$ Entity OMS -> OMS
forall record. Entity record -> record
entityVal Entity OMS
omsEntity of
         Nothing -> Maybe StringReference
-> ReaderT SqlBackend m (Maybe StringReference)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe StringReference
forall a. Maybe a
Nothing
         Just serializationKey :: Key Serialization
serializationKey -> Key Serialization -> ReaderT SqlBackend m (Maybe StringReference)
forall (m :: * -> *).
MonadIO m =>
Key Serialization -> DBMonad m (Maybe StringReference)
resolveSerialization Key Serialization
serializationKey
       Maybe Result -> DBMonad m (Maybe Result)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Result -> DBMonad m (Maybe Result))
-> Maybe Result -> DBMonad m (Maybe Result)
forall a b. (a -> b) -> a -> b
$ Result -> Maybe Result
forall a. a -> Maybe a
Just (Result -> Maybe Result) -> Result -> Maybe Result
forall a b. (a -> b) -> a -> b
$ OMS -> Result
GraphQLResult.OMSResult (OMS -> Result) -> OMS -> Result
forall a b. (a -> b) -> a -> b
$
         Entity OMS
-> Entity LocIdBase
-> Entity ConservativityStatus
-> Maybe (Entity FileRange)
-> Maybe (Entity LocIdBase)
-> Maybe (Entity SignatureMorphism)
-> Entity Language
-> Entity Logic
-> Maybe (Entity LocIdBase)
-> Maybe (Entity SignatureMorphism)
-> [ReasoningAttempt]
-> [Mapping]
-> [Mapping]
-> [Sentence]
-> Maybe StringReference
-> OMS
omsToResult Entity OMS
omsEntity Entity LocIdBase
locIdBaseOMS Entity ConservativityStatus
conservativityStatusEntity
           Maybe (Entity FileRange)
fileRangeM Maybe (Entity LocIdBase)
freeNormalFormLocIdBaseM Maybe (Entity SignatureMorphism)
freeNormalFormSignatureMorphismM
           Entity Language
languageEntity Entity Logic
logicEntity
           Maybe (Entity LocIdBase)
normalFormLocIdBaseM Maybe (Entity SignatureMorphism)
normalFormSignatureMorphismM
           [ReasoningAttempt]
consistencyCheckAttemptResults [Mapping]
mappingSourceResults [Mapping]
mappingTargetResults
           [Sentence]
sentenceResults Maybe StringReference
serializationResult

resolveConsistencyChecks :: (MonadIO m, MonadFail m)
                         => LocIdBaseId -- of the OMS
                         -> DBMonad m [GraphQLResultReasoningAttempt.ReasoningAttempt]
resolveConsistencyChecks :: Key LocIdBase -> DBMonad m [ReasoningAttempt]
resolveConsistencyChecks omsKey :: Key LocIdBase
omsKey = do
  [(Entity ReasoningAttempt, Maybe (Entity Reasoner),
  Entity ReasonerConfiguration)]
consistencyCheckAttemptL <-
    SqlQuery
  (SqlExpr (Entity ReasoningAttempt),
   SqlExpr (Maybe (Entity Reasoner)),
   SqlExpr (Entity ReasonerConfiguration))
-> ReaderT
     SqlBackend
     m
     [(Entity ReasoningAttempt, Maybe (Entity Reasoner),
       Entity ReasonerConfiguration)]
forall a r (m :: * -> *).
(SqlSelect a r, MonadIO m) =>
SqlQuery a -> SqlReadT m [r]
select (SqlQuery
   (SqlExpr (Entity ReasoningAttempt),
    SqlExpr (Maybe (Entity Reasoner)),
    SqlExpr (Entity ReasonerConfiguration))
 -> ReaderT
      SqlBackend
      m
      [(Entity ReasoningAttempt, Maybe (Entity Reasoner),
        Entity ReasonerConfiguration)])
-> SqlQuery
     (SqlExpr (Entity ReasoningAttempt),
      SqlExpr (Maybe (Entity Reasoner)),
      SqlExpr (Entity ReasonerConfiguration))
-> ReaderT
     SqlBackend
     m
     [(Entity ReasoningAttempt, Maybe (Entity Reasoner),
       Entity ReasonerConfiguration)]
forall a b. (a -> b) -> a -> b
$ (LeftOuterJoin
   (InnerJoin
      (InnerJoin
         (SqlExpr (Entity ReasoningAttempt))
         (SqlExpr (Entity ConsistencyCheckAttempt)))
      (SqlExpr (Entity ReasonerConfiguration)))
   (SqlExpr (Maybe (Entity Reasoner)))
 -> SqlQuery
      (SqlExpr (Entity ReasoningAttempt),
       SqlExpr (Maybe (Entity Reasoner)),
       SqlExpr (Entity ReasonerConfiguration)))
-> SqlQuery
     (SqlExpr (Entity ReasoningAttempt),
      SqlExpr (Maybe (Entity Reasoner)),
      SqlExpr (Entity ReasonerConfiguration))
forall a b. From a => (a -> SqlQuery b) -> SqlQuery b
from ((LeftOuterJoin
    (InnerJoin
       (InnerJoin
          (SqlExpr (Entity ReasoningAttempt))
          (SqlExpr (Entity ConsistencyCheckAttempt)))
       (SqlExpr (Entity ReasonerConfiguration)))
    (SqlExpr (Maybe (Entity Reasoner)))
  -> SqlQuery
       (SqlExpr (Entity ReasoningAttempt),
        SqlExpr (Maybe (Entity Reasoner)),
        SqlExpr (Entity ReasonerConfiguration)))
 -> SqlQuery
      (SqlExpr (Entity ReasoningAttempt),
       SqlExpr (Maybe (Entity Reasoner)),
       SqlExpr (Entity ReasonerConfiguration)))
-> (LeftOuterJoin
      (InnerJoin
         (InnerJoin
            (SqlExpr (Entity ReasoningAttempt))
            (SqlExpr (Entity ConsistencyCheckAttempt)))
         (SqlExpr (Entity ReasonerConfiguration)))
      (SqlExpr (Maybe (Entity Reasoner)))
    -> SqlQuery
         (SqlExpr (Entity ReasoningAttempt),
          SqlExpr (Maybe (Entity Reasoner)),
          SqlExpr (Entity ReasonerConfiguration)))
-> SqlQuery
     (SqlExpr (Entity ReasoningAttempt),
      SqlExpr (Maybe (Entity Reasoner)),
      SqlExpr (Entity ReasonerConfiguration))
forall a b. (a -> b) -> a -> b
$ \(reasoning_attempts :: SqlExpr (Entity ReasoningAttempt)
reasoning_attempts `InnerJoin` consistency_check_attempts :: SqlExpr (Entity ConsistencyCheckAttempt)
consistency_check_attempts
                                         `InnerJoin` reasoner_configurations :: SqlExpr (Entity ReasonerConfiguration)
reasoner_configurations
                                         `LeftOuterJoin` reasoners :: SqlExpr (Maybe (Entity Reasoner))
reasoners) -> do
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Maybe (Entity Reasoner))
reasoners SqlExpr (Maybe (Entity Reasoner))
-> EntityField Reasoner (Key Reasoner)
-> SqlExpr (Value (Maybe (Key Reasoner)))
forall val typ.
(PersistEntity val, PersistField typ) =>
SqlExpr (Maybe (Entity val))
-> EntityField val typ -> SqlExpr (Value (Maybe typ))
?. EntityField Reasoner (Key Reasoner)
forall typ. (typ ~ Key Reasoner) => EntityField Reasoner typ
ReasonerId SqlExpr (Value (Maybe (Key Reasoner)))
-> SqlExpr (Value (Maybe (Key Reasoner))) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==. SqlExpr (Entity ReasoningAttempt)
reasoning_attempts SqlExpr (Entity ReasoningAttempt)
-> EntityField ReasoningAttempt (Maybe (Key Reasoner))
-> SqlExpr (Value (Maybe (Key Reasoner)))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField ReasoningAttempt (Maybe (Key Reasoner))
forall typ.
(typ ~ Maybe (Key Reasoner)) =>
EntityField ReasoningAttempt typ
ReasoningAttemptUsedReasonerId)
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Entity ReasonerConfiguration)
reasoner_configurations SqlExpr (Entity ReasonerConfiguration)
-> EntityField ReasonerConfiguration (Key ReasonerConfiguration)
-> SqlExpr (Value (Key ReasonerConfiguration))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField ReasonerConfiguration (Key ReasonerConfiguration)
forall typ.
(typ ~ Key ReasonerConfiguration) =>
EntityField ReasonerConfiguration typ
ReasonerConfigurationId SqlExpr (Value (Key ReasonerConfiguration))
-> SqlExpr (Value (Key ReasonerConfiguration))
-> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==.
            SqlExpr (Entity ReasoningAttempt)
reasoning_attempts SqlExpr (Entity ReasoningAttempt)
-> EntityField ReasoningAttempt (Key ReasonerConfiguration)
-> SqlExpr (Value (Key ReasonerConfiguration))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField ReasoningAttempt (Key ReasonerConfiguration)
forall typ.
(typ ~ Key ReasonerConfiguration) =>
EntityField ReasoningAttempt typ
ReasoningAttemptReasonerConfigurationId)
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Value (Key ConsistencyCheckAttempt))
-> SqlExpr (Value (Key ReasoningAttempt))
forall a b. SqlExpr (Value a) -> SqlExpr (Value b)
coerceId (SqlExpr (Entity ConsistencyCheckAttempt)
consistency_check_attempts SqlExpr (Entity ConsistencyCheckAttempt)
-> EntityField
     ConsistencyCheckAttempt (Key ConsistencyCheckAttempt)
-> SqlExpr (Value (Key ConsistencyCheckAttempt))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField ConsistencyCheckAttempt (Key ConsistencyCheckAttempt)
forall typ.
(typ ~ Key ConsistencyCheckAttempt) =>
EntityField ConsistencyCheckAttempt typ
ConsistencyCheckAttemptId) SqlExpr (Value (Key ReasoningAttempt))
-> SqlExpr (Value (Key ReasoningAttempt)) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==.
            SqlExpr (Entity ReasoningAttempt)
reasoning_attempts SqlExpr (Entity ReasoningAttempt)
-> EntityField ReasoningAttempt (Key ReasoningAttempt)
-> SqlExpr (Value (Key ReasoningAttempt))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField ReasoningAttempt (Key ReasoningAttempt)
forall typ.
(typ ~ Key ReasoningAttempt) =>
EntityField ReasoningAttempt typ
ReasoningAttemptId)
      SqlExpr (Value Bool) -> SqlQuery ()
where_ (SqlExpr (Entity ConsistencyCheckAttempt)
consistency_check_attempts SqlExpr (Entity ConsistencyCheckAttempt)
-> EntityField ConsistencyCheckAttempt (Maybe (Key LocIdBase))
-> SqlExpr (Value (Maybe (Key LocIdBase)))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField ConsistencyCheckAttempt (Maybe (Key LocIdBase))
forall typ.
(typ ~ Maybe (Key LocIdBase)) =>
EntityField ConsistencyCheckAttempt typ
ConsistencyCheckAttemptOmsId SqlExpr (Value (Maybe (Key LocIdBase)))
-> SqlExpr (Value (Maybe (Key LocIdBase))) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==.
                SqlExpr (Value (Key LocIdBase))
-> SqlExpr (Value (Maybe (Key LocIdBase)))
forall typ. SqlExpr (Value typ) -> SqlExpr (Value (Maybe typ))
just (Key LocIdBase -> SqlExpr (Value (Key LocIdBase))
forall typ. PersistField typ => typ -> SqlExpr (Value typ)
val Key LocIdBase
omsKey))
      (SqlExpr (Entity ReasoningAttempt),
 SqlExpr (Maybe (Entity Reasoner)),
 SqlExpr (Entity ReasonerConfiguration))
-> SqlQuery
     (SqlExpr (Entity ReasoningAttempt),
      SqlExpr (Maybe (Entity Reasoner)),
      SqlExpr (Entity ReasonerConfiguration))
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlExpr (Entity ReasoningAttempt)
reasoning_attempts, SqlExpr (Maybe (Entity Reasoner))
reasoners, SqlExpr (Entity ReasonerConfiguration)
reasoner_configurations)
  ((Entity ReasoningAttempt, Maybe (Entity Reasoner),
  Entity ReasonerConfiguration)
 -> ReaderT SqlBackend m ReasoningAttempt)
-> [(Entity ReasoningAttempt, Maybe (Entity Reasoner),
     Entity ReasonerConfiguration)]
-> DBMonad m [ReasoningAttempt]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (Entity ReasoningAttempt, Maybe (Entity Reasoner),
 Entity ReasonerConfiguration)
-> ReaderT SqlBackend m ReasoningAttempt
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
(Entity ReasoningAttempt, Maybe (Entity Reasoner),
 Entity ReasonerConfiguration)
-> DBMonad m ReasoningAttempt
resolveReasoningAttempt [(Entity ReasoningAttempt, Maybe (Entity Reasoner),
  Entity ReasonerConfiguration)]
consistencyCheckAttemptL

resolveMappings :: MonadIO m
                => LocIdBaseId
                -> EntityField DatabaseSchema.Mapping LocIdBaseId
                -> DBMonad m [GraphQLResultMapping.Mapping]
resolveMappings :: Key LocIdBase
-> EntityField Mapping (Key LocIdBase) -> DBMonad m [Mapping]
resolveMappings omsKey :: Key LocIdBase
omsKey column :: EntityField Mapping (Key LocIdBase)
column = do
  [(Entity Mapping, Entity LocIdBase, Entity SignatureMorphism,
  Maybe (Entity ConservativityStatus), Entity LocIdBase,
  Entity LocIdBase, Maybe (Entity LocIdBase),
  Maybe (Entity Language))]
mappingData <-
    SqlQuery
  (SqlExpr (Entity Mapping), SqlExpr (Entity LocIdBase),
   SqlExpr (Entity SignatureMorphism),
   SqlExpr (Maybe (Entity ConservativityStatus)),
   SqlExpr (Entity LocIdBase), SqlExpr (Entity LocIdBase),
   SqlExpr (Maybe (Entity LocIdBase)),
   SqlExpr (Maybe (Entity Language)))
-> ReaderT
     SqlBackend
     m
     [(Entity Mapping, Entity LocIdBase, Entity SignatureMorphism,
       Maybe (Entity ConservativityStatus), Entity LocIdBase,
       Entity LocIdBase, Maybe (Entity LocIdBase),
       Maybe (Entity Language))]
forall a r (m :: * -> *).
(SqlSelect a r, MonadIO m) =>
SqlQuery a -> SqlReadT m [r]
select (SqlQuery
   (SqlExpr (Entity Mapping), SqlExpr (Entity LocIdBase),
    SqlExpr (Entity SignatureMorphism),
    SqlExpr (Maybe (Entity ConservativityStatus)),
    SqlExpr (Entity LocIdBase), SqlExpr (Entity LocIdBase),
    SqlExpr (Maybe (Entity LocIdBase)),
    SqlExpr (Maybe (Entity Language)))
 -> ReaderT
      SqlBackend
      m
      [(Entity Mapping, Entity LocIdBase, Entity SignatureMorphism,
        Maybe (Entity ConservativityStatus), Entity LocIdBase,
        Entity LocIdBase, Maybe (Entity LocIdBase),
        Maybe (Entity Language))])
-> SqlQuery
     (SqlExpr (Entity Mapping), SqlExpr (Entity LocIdBase),
      SqlExpr (Entity SignatureMorphism),
      SqlExpr (Maybe (Entity ConservativityStatus)),
      SqlExpr (Entity LocIdBase), SqlExpr (Entity LocIdBase),
      SqlExpr (Maybe (Entity LocIdBase)),
      SqlExpr (Maybe (Entity Language)))
-> ReaderT
     SqlBackend
     m
     [(Entity Mapping, Entity LocIdBase, Entity SignatureMorphism,
       Maybe (Entity ConservativityStatus), Entity LocIdBase,
       Entity LocIdBase, Maybe (Entity LocIdBase),
       Maybe (Entity Language))]
forall a b. (a -> b) -> a -> b
$ (LeftOuterJoin
   (LeftOuterJoin
      (InnerJoin
         (InnerJoin
            (LeftOuterJoin
               (InnerJoin
                  (InnerJoin (SqlExpr (Entity Mapping)) (SqlExpr (Entity LocIdBase)))
                  (SqlExpr (Entity SignatureMorphism)))
               (SqlExpr (Maybe (Entity ConservativityStatus))))
            (SqlExpr (Entity LocIdBase)))
         (SqlExpr (Entity LocIdBase)))
      (SqlExpr (Maybe (Entity LocIdBase))))
   (SqlExpr (Maybe (Entity Language)))
 -> SqlQuery
      (SqlExpr (Entity Mapping), SqlExpr (Entity LocIdBase),
       SqlExpr (Entity SignatureMorphism),
       SqlExpr (Maybe (Entity ConservativityStatus)),
       SqlExpr (Entity LocIdBase), SqlExpr (Entity LocIdBase),
       SqlExpr (Maybe (Entity LocIdBase)),
       SqlExpr (Maybe (Entity Language))))
-> SqlQuery
     (SqlExpr (Entity Mapping), SqlExpr (Entity LocIdBase),
      SqlExpr (Entity SignatureMorphism),
      SqlExpr (Maybe (Entity ConservativityStatus)),
      SqlExpr (Entity LocIdBase), SqlExpr (Entity LocIdBase),
      SqlExpr (Maybe (Entity LocIdBase)),
      SqlExpr (Maybe (Entity Language)))
forall a b. From a => (a -> SqlQuery b) -> SqlQuery b
from ((LeftOuterJoin
    (LeftOuterJoin
       (InnerJoin
          (InnerJoin
             (LeftOuterJoin
                (InnerJoin
                   (InnerJoin (SqlExpr (Entity Mapping)) (SqlExpr (Entity LocIdBase)))
                   (SqlExpr (Entity SignatureMorphism)))
                (SqlExpr (Maybe (Entity ConservativityStatus))))
             (SqlExpr (Entity LocIdBase)))
          (SqlExpr (Entity LocIdBase)))
       (SqlExpr (Maybe (Entity LocIdBase))))
    (SqlExpr (Maybe (Entity Language)))
  -> SqlQuery
       (SqlExpr (Entity Mapping), SqlExpr (Entity LocIdBase),
        SqlExpr (Entity SignatureMorphism),
        SqlExpr (Maybe (Entity ConservativityStatus)),
        SqlExpr (Entity LocIdBase), SqlExpr (Entity LocIdBase),
        SqlExpr (Maybe (Entity LocIdBase)),
        SqlExpr (Maybe (Entity Language))))
 -> SqlQuery
      (SqlExpr (Entity Mapping), SqlExpr (Entity LocIdBase),
       SqlExpr (Entity SignatureMorphism),
       SqlExpr (Maybe (Entity ConservativityStatus)),
       SqlExpr (Entity LocIdBase), SqlExpr (Entity LocIdBase),
       SqlExpr (Maybe (Entity LocIdBase)),
       SqlExpr (Maybe (Entity Language))))
-> (LeftOuterJoin
      (LeftOuterJoin
         (InnerJoin
            (InnerJoin
               (LeftOuterJoin
                  (InnerJoin
                     (InnerJoin (SqlExpr (Entity Mapping)) (SqlExpr (Entity LocIdBase)))
                     (SqlExpr (Entity SignatureMorphism)))
                  (SqlExpr (Maybe (Entity ConservativityStatus))))
               (SqlExpr (Entity LocIdBase)))
            (SqlExpr (Entity LocIdBase)))
         (SqlExpr (Maybe (Entity LocIdBase))))
      (SqlExpr (Maybe (Entity Language)))
    -> SqlQuery
         (SqlExpr (Entity Mapping), SqlExpr (Entity LocIdBase),
          SqlExpr (Entity SignatureMorphism),
          SqlExpr (Maybe (Entity ConservativityStatus)),
          SqlExpr (Entity LocIdBase), SqlExpr (Entity LocIdBase),
          SqlExpr (Maybe (Entity LocIdBase)),
          SqlExpr (Maybe (Entity Language))))
-> SqlQuery
     (SqlExpr (Entity Mapping), SqlExpr (Entity LocIdBase),
      SqlExpr (Entity SignatureMorphism),
      SqlExpr (Maybe (Entity ConservativityStatus)),
      SqlExpr (Entity LocIdBase), SqlExpr (Entity LocIdBase),
      SqlExpr (Maybe (Entity LocIdBase)),
      SqlExpr (Maybe (Entity Language)))
forall a b. (a -> b) -> a -> b
$ \(mappingsSql :: SqlExpr (Entity Mapping)
mappingsSql `InnerJoin` loc_id_bases :: SqlExpr (Entity LocIdBase)
loc_id_bases
                                  `InnerJoin` signature_morphisms :: SqlExpr (Entity SignatureMorphism)
signature_morphisms
                                  `LeftOuterJoin` conservativity_statuses :: SqlExpr (Maybe (Entity ConservativityStatus))
conservativity_statuses
                                  `InnerJoin` loc_id_basesSource :: SqlExpr (Entity LocIdBase)
loc_id_basesSource
                                  `InnerJoin` loc_id_basesTarget :: SqlExpr (Entity LocIdBase)
loc_id_basesTarget
                                  `LeftOuterJoin` loc_id_basesOMS :: SqlExpr (Maybe (Entity LocIdBase))
loc_id_basesOMS
                                  `LeftOuterJoin` languages :: SqlExpr (Maybe (Entity Language))
languages) -> do
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Maybe (Entity Language))
languages SqlExpr (Maybe (Entity Language))
-> EntityField Language (Key Language)
-> SqlExpr (Value (Maybe (Key Language)))
forall val typ.
(PersistEntity val, PersistField typ) =>
SqlExpr (Maybe (Entity val))
-> EntityField val typ -> SqlExpr (Value (Maybe typ))
?. EntityField Language (Key Language)
forall typ. (typ ~ Key Language) => EntityField Language typ
LanguageId SqlExpr (Value (Maybe (Key Language)))
-> SqlExpr (Value (Maybe (Key Language))) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==. SqlExpr (Entity Mapping)
mappingsSql SqlExpr (Entity Mapping)
-> EntityField Mapping (Maybe (Key Language))
-> SqlExpr (Value (Maybe (Key Language)))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField Mapping (Maybe (Key Language))
forall typ. (typ ~ Maybe (Key Language)) => EntityField Mapping typ
MappingFreenessParameterLanguageId)
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Maybe (Entity LocIdBase))
loc_id_basesOMS SqlExpr (Maybe (Entity LocIdBase))
-> EntityField LocIdBase (Key LocIdBase)
-> SqlExpr (Value (Maybe (Key LocIdBase)))
forall val typ.
(PersistEntity val, PersistField typ) =>
SqlExpr (Maybe (Entity val))
-> EntityField val typ -> SqlExpr (Value (Maybe typ))
?. EntityField LocIdBase (Key LocIdBase)
forall typ. (typ ~ Key LocIdBase) => EntityField LocIdBase typ
LocIdBaseId SqlExpr (Value (Maybe (Key LocIdBase)))
-> SqlExpr (Value (Maybe (Key LocIdBase))) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==. SqlExpr (Entity Mapping)
mappingsSql SqlExpr (Entity Mapping)
-> EntityField Mapping (Maybe (Key LocIdBase))
-> SqlExpr (Value (Maybe (Key LocIdBase)))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField Mapping (Maybe (Key LocIdBase))
forall typ.
(typ ~ Maybe (Key LocIdBase)) =>
EntityField Mapping typ
MappingFreenessParameterOMSId)
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Entity LocIdBase)
loc_id_basesTarget SqlExpr (Entity LocIdBase)
-> EntityField LocIdBase (Key LocIdBase)
-> SqlExpr (Value (Key LocIdBase))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField LocIdBase (Key LocIdBase)
forall typ. (typ ~ Key LocIdBase) => EntityField LocIdBase typ
LocIdBaseId SqlExpr (Value (Key LocIdBase))
-> SqlExpr (Value (Key LocIdBase)) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==. SqlExpr (Entity Mapping)
mappingsSql SqlExpr (Entity Mapping)
-> EntityField Mapping (Key LocIdBase)
-> SqlExpr (Value (Key LocIdBase))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField Mapping (Key LocIdBase)
forall typ. (typ ~ Key LocIdBase) => EntityField Mapping typ
MappingTargetId)
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Entity LocIdBase)
loc_id_basesSource SqlExpr (Entity LocIdBase)
-> EntityField LocIdBase (Key LocIdBase)
-> SqlExpr (Value (Key LocIdBase))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField LocIdBase (Key LocIdBase)
forall typ. (typ ~ Key LocIdBase) => EntityField LocIdBase typ
LocIdBaseId SqlExpr (Value (Key LocIdBase))
-> SqlExpr (Value (Key LocIdBase)) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==. SqlExpr (Entity Mapping)
mappingsSql SqlExpr (Entity Mapping)
-> EntityField Mapping (Key LocIdBase)
-> SqlExpr (Value (Key LocIdBase))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField Mapping (Key LocIdBase)
forall typ. (typ ~ Key LocIdBase) => EntityField Mapping typ
MappingSourceId)
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Maybe (Entity ConservativityStatus))
conservativity_statuses SqlExpr (Maybe (Entity ConservativityStatus))
-> EntityField ConservativityStatus (Key ConservativityStatus)
-> SqlExpr (Value (Maybe (Key ConservativityStatus)))
forall val typ.
(PersistEntity val, PersistField typ) =>
SqlExpr (Maybe (Entity val))
-> EntityField val typ -> SqlExpr (Value (Maybe typ))
?. EntityField ConservativityStatus (Key ConservativityStatus)
forall typ.
(typ ~ Key ConservativityStatus) =>
EntityField ConservativityStatus typ
ConservativityStatusId SqlExpr (Value (Maybe (Key ConservativityStatus)))
-> SqlExpr (Value (Maybe (Key ConservativityStatus)))
-> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==.
            SqlExpr (Entity Mapping)
mappingsSql SqlExpr (Entity Mapping)
-> EntityField Mapping (Maybe (Key ConservativityStatus))
-> SqlExpr (Value (Maybe (Key ConservativityStatus)))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField Mapping (Maybe (Key ConservativityStatus))
forall typ.
(typ ~ Maybe (Key ConservativityStatus)) =>
EntityField Mapping typ
MappingConservativityStatusId)
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Entity Mapping)
mappingsSql SqlExpr (Entity Mapping)
-> EntityField Mapping (Key SignatureMorphism)
-> SqlExpr (Value (Key SignatureMorphism))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField Mapping (Key SignatureMorphism)
forall typ.
(typ ~ Key SignatureMorphism) =>
EntityField Mapping typ
MappingSignatureMorphismId SqlExpr (Value (Key SignatureMorphism))
-> SqlExpr (Value (Key SignatureMorphism)) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==.
            SqlExpr (Entity SignatureMorphism)
signature_morphisms SqlExpr (Entity SignatureMorphism)
-> EntityField SignatureMorphism (Key SignatureMorphism)
-> SqlExpr (Value (Key SignatureMorphism))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField SignatureMorphism (Key SignatureMorphism)
forall typ.
(typ ~ Key SignatureMorphism) =>
EntityField SignatureMorphism typ
SignatureMorphismId)
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Entity LocIdBase)
loc_id_bases SqlExpr (Entity LocIdBase)
-> EntityField LocIdBase (Key LocIdBase)
-> SqlExpr (Value (Key LocIdBase))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField LocIdBase (Key LocIdBase)
forall typ. (typ ~ Key LocIdBase) => EntityField LocIdBase typ
LocIdBaseId SqlExpr (Value (Key LocIdBase))
-> SqlExpr (Value (Key LocIdBase)) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==. SqlExpr (Value (Key Mapping)) -> SqlExpr (Value (Key LocIdBase))
forall a b. SqlExpr (Value a) -> SqlExpr (Value b)
coerceId (SqlExpr (Entity Mapping)
mappingsSql SqlExpr (Entity Mapping)
-> EntityField Mapping (Key Mapping)
-> SqlExpr (Value (Key Mapping))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField Mapping (Key Mapping)
forall typ. (typ ~ Key Mapping) => EntityField Mapping typ
MappingId))
      SqlExpr (Value Bool) -> SqlQuery ()
where_ (SqlExpr (Entity Mapping)
mappingsSql SqlExpr (Entity Mapping)
-> EntityField Mapping (Key LocIdBase)
-> SqlExpr (Value (Key LocIdBase))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField Mapping (Key LocIdBase)
column SqlExpr (Value (Key LocIdBase))
-> SqlExpr (Value (Key LocIdBase)) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==. Key LocIdBase -> SqlExpr (Value (Key LocIdBase))
forall typ. PersistField typ => typ -> SqlExpr (Value typ)
val Key LocIdBase
omsKey)
      (SqlExpr (Entity Mapping), SqlExpr (Entity LocIdBase),
 SqlExpr (Entity SignatureMorphism),
 SqlExpr (Maybe (Entity ConservativityStatus)),
 SqlExpr (Entity LocIdBase), SqlExpr (Entity LocIdBase),
 SqlExpr (Maybe (Entity LocIdBase)),
 SqlExpr (Maybe (Entity Language)))
-> SqlQuery
     (SqlExpr (Entity Mapping), SqlExpr (Entity LocIdBase),
      SqlExpr (Entity SignatureMorphism),
      SqlExpr (Maybe (Entity ConservativityStatus)),
      SqlExpr (Entity LocIdBase), SqlExpr (Entity LocIdBase),
      SqlExpr (Maybe (Entity LocIdBase)),
      SqlExpr (Maybe (Entity Language)))
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlExpr (Entity Mapping)
mappingsSql, SqlExpr (Entity LocIdBase)
loc_id_bases, SqlExpr (Entity SignatureMorphism)
signature_morphisms,
              SqlExpr (Maybe (Entity ConservativityStatus))
conservativity_statuses, SqlExpr (Entity LocIdBase)
loc_id_basesSource, SqlExpr (Entity LocIdBase)
loc_id_basesTarget,
              SqlExpr (Maybe (Entity LocIdBase))
loc_id_basesOMS, SqlExpr (Maybe (Entity Language))
languages)
  [Mapping] -> DBMonad m [Mapping]
forall (m :: * -> *) a. Monad m => a -> m a
return ([Mapping] -> DBMonad m [Mapping])
-> [Mapping] -> DBMonad m [Mapping]
forall a b. (a -> b) -> a -> b
$
    ((Entity Mapping, Entity LocIdBase, Entity SignatureMorphism,
  Maybe (Entity ConservativityStatus), Entity LocIdBase,
  Entity LocIdBase, Maybe (Entity LocIdBase),
  Maybe (Entity Language))
 -> Mapping)
-> [(Entity Mapping, Entity LocIdBase, Entity SignatureMorphism,
     Maybe (Entity ConservativityStatus), Entity LocIdBase,
     Entity LocIdBase, Maybe (Entity LocIdBase),
     Maybe (Entity Language))]
-> [Mapping]
forall a b. (a -> b) -> [a] -> [b]
map (\ (mapping :: Entity Mapping
mapping, locIdBase :: Entity LocIdBase
locIdBase, signatureMorphismEntity :: Entity SignatureMorphism
signatureMorphismEntity, conservativityStatusM :: Maybe (Entity ConservativityStatus)
conservativityStatusM,
            locIdBaseSource :: Entity LocIdBase
locIdBaseSource, locIdBaseTarget :: Entity LocIdBase
locIdBaseTarget, freenesParameterOMSLocIdM :: Maybe (Entity LocIdBase)
freenesParameterOMSLocIdM,
            freenessParameterLanguageM :: Maybe (Entity Language)
freenessParameterLanguageM) ->
          Entity Mapping
-> Entity LocIdBase
-> Entity SignatureMorphism
-> Maybe (Entity ConservativityStatus)
-> Entity LocIdBase
-> Entity LocIdBase
-> Maybe (Entity LocIdBase)
-> Maybe (Entity Language)
-> Mapping
mappingToResult Entity Mapping
mapping Entity LocIdBase
locIdBase Entity SignatureMorphism
signatureMorphismEntity
            Maybe (Entity ConservativityStatus)
conservativityStatusM Entity LocIdBase
locIdBaseSource Entity LocIdBase
locIdBaseTarget
            Maybe (Entity LocIdBase)
freenesParameterOMSLocIdM Maybe (Entity Language)
freenessParameterLanguageM
        ) [(Entity Mapping, Entity LocIdBase, Entity SignatureMorphism,
  Maybe (Entity ConservativityStatus), Entity LocIdBase,
  Entity LocIdBase, Maybe (Entity LocIdBase),
  Maybe (Entity Language))]
mappingData

getReasonerOutput :: MonadIO m
                  => ReasoningAttemptId
                  -> DBMonad m (Maybe (Entity DatabaseSchema.ReasonerOutput))
getReasonerOutput :: Key ReasoningAttempt -> DBMonad m (Maybe (Entity ReasonerOutput))
getReasonerOutput reasoningAttemptKey :: Key ReasoningAttempt
reasoningAttemptKey = do
  [Entity ReasonerOutput]
reasonerOutputL <- SqlQuery (SqlExpr (Entity ReasonerOutput))
-> ReaderT SqlBackend m [Entity ReasonerOutput]
forall a r (m :: * -> *).
(SqlSelect a r, MonadIO m) =>
SqlQuery a -> SqlReadT m [r]
select (SqlQuery (SqlExpr (Entity ReasonerOutput))
 -> ReaderT SqlBackend m [Entity ReasonerOutput])
-> SqlQuery (SqlExpr (Entity ReasonerOutput))
-> ReaderT SqlBackend m [Entity ReasonerOutput]
forall a b. (a -> b) -> a -> b
$ (SqlExpr (Entity ReasonerOutput)
 -> SqlQuery (SqlExpr (Entity ReasonerOutput)))
-> SqlQuery (SqlExpr (Entity ReasonerOutput))
forall a b. From a => (a -> SqlQuery b) -> SqlQuery b
from ((SqlExpr (Entity ReasonerOutput)
  -> SqlQuery (SqlExpr (Entity ReasonerOutput)))
 -> SqlQuery (SqlExpr (Entity ReasonerOutput)))
-> (SqlExpr (Entity ReasonerOutput)
    -> SqlQuery (SqlExpr (Entity ReasonerOutput)))
-> SqlQuery (SqlExpr (Entity ReasonerOutput))
forall a b. (a -> b) -> a -> b
$ \ reasoner_outputs :: SqlExpr (Entity ReasonerOutput)
reasoner_outputs -> do
    SqlExpr (Value Bool) -> SqlQuery ()
where_ (SqlExpr (Entity ReasonerOutput)
reasoner_outputs SqlExpr (Entity ReasonerOutput)
-> EntityField ReasonerOutput (Key ReasoningAttempt)
-> SqlExpr (Value (Key ReasoningAttempt))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField ReasonerOutput (Key ReasoningAttempt)
forall typ.
(typ ~ Key ReasoningAttempt) =>
EntityField ReasonerOutput typ
ReasonerOutputReasoningAttemptId SqlExpr (Value (Key ReasoningAttempt))
-> SqlExpr (Value (Key ReasoningAttempt)) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==.
              Key ReasoningAttempt -> SqlExpr (Value (Key ReasoningAttempt))
forall typ. PersistField typ => typ -> SqlExpr (Value typ)
val Key ReasoningAttempt
reasoningAttemptKey)
    SqlExpr (Entity ReasonerOutput)
-> SqlQuery (SqlExpr (Entity ReasonerOutput))
forall (m :: * -> *) a. Monad m => a -> m a
return SqlExpr (Entity ReasonerOutput)
reasoner_outputs
  Maybe (Entity ReasonerOutput)
-> DBMonad m (Maybe (Entity ReasonerOutput))
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (Entity ReasonerOutput)
 -> DBMonad m (Maybe (Entity ReasonerOutput)))
-> Maybe (Entity ReasonerOutput)
-> DBMonad m (Maybe (Entity ReasonerOutput))
forall a b. (a -> b) -> a -> b
$ case [Entity ReasonerOutput]
reasonerOutputL of
    [] -> Maybe (Entity ReasonerOutput)
forall a. Maybe a
Nothing
    reasonerOutputEntity :: Entity ReasonerOutput
reasonerOutputEntity : _ -> Entity ReasonerOutput -> Maybe (Entity ReasonerOutput)
forall a. a -> Maybe a
Just Entity ReasonerOutput
reasonerOutputEntity

resolveReasoningAttempt :: (MonadIO m, MonadFail m)
                        => ( Entity DatabaseSchema.ReasoningAttempt
                           , Maybe (Entity DatabaseSchema.Reasoner)
                           , Entity DatabaseSchema.ReasonerConfiguration
                           )
                        -> DBMonad m GraphQLResultReasoningAttempt.ReasoningAttempt
resolveReasoningAttempt :: (Entity ReasoningAttempt, Maybe (Entity Reasoner),
 Entity ReasonerConfiguration)
-> DBMonad m ReasoningAttempt
resolveReasoningAttempt (reasoningAttemptEntity :: Entity ReasoningAttempt
reasoningAttemptEntity, reasonerEntityM :: Maybe (Entity Reasoner)
reasonerEntityM, reasonerConfigurationEntity :: Entity ReasonerConfiguration
reasonerConfigurationEntity) = do
  Action
actionResult <-
    ActionId -> DBMonad m Action
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
ActionId -> DBMonad m Action
resolveAction (ActionId -> DBMonad m Action) -> ActionId -> DBMonad m Action
forall a b. (a -> b) -> a -> b
$ ReasoningAttempt -> ActionId
reasoningAttemptActionId (ReasoningAttempt -> ActionId) -> ReasoningAttempt -> ActionId
forall a b. (a -> b) -> a -> b
$ Entity ReasoningAttempt -> ReasoningAttempt
forall record. Entity record -> record
entityVal Entity ReasoningAttempt
reasoningAttemptEntity
  Maybe (Entity ReasonerOutput)
reasonerOutputEntityM <- Key ReasoningAttempt -> DBMonad m (Maybe (Entity ReasonerOutput))
forall (m :: * -> *).
MonadIO m =>
Key ReasoningAttempt -> DBMonad m (Maybe (Entity ReasonerOutput))
getReasonerOutput (Key ReasoningAttempt -> DBMonad m (Maybe (Entity ReasonerOutput)))
-> Key ReasoningAttempt
-> DBMonad m (Maybe (Entity ReasonerOutput))
forall a b. (a -> b) -> a -> b
$ Entity ReasoningAttempt -> Key ReasoningAttempt
forall record. Entity record -> Key record
entityKey Entity ReasoningAttempt
reasoningAttemptEntity
  ReasonerConfiguration
reasonerConfigurationResult <-
    Entity ReasonerConfiguration -> DBMonad m ReasonerConfiguration
forall (m :: * -> *).
MonadIO m =>
Entity ReasonerConfiguration -> DBMonad m ReasonerConfiguration
resolveReasonerConfiguration Entity ReasonerConfiguration
reasonerConfigurationEntity
  ReasoningAttempt -> DBMonad m ReasoningAttempt
forall (m :: * -> *) a. Monad m => a -> m a
return (ReasoningAttempt -> DBMonad m ReasoningAttempt)
-> ReasoningAttempt -> DBMonad m ReasoningAttempt
forall a b. (a -> b) -> a -> b
$ Entity ReasoningAttempt
-> Maybe (Entity ReasonerOutput)
-> Maybe (Entity Reasoner)
-> Action
-> ReasonerConfiguration
-> ReasoningAttempt
reasoningAttemptToResult Entity ReasoningAttempt
reasoningAttemptEntity Maybe (Entity ReasonerOutput)
reasonerOutputEntityM
    Maybe (Entity Reasoner)
reasonerEntityM Action
actionResult ReasonerConfiguration
reasonerConfigurationResult

resolveAction :: (MonadIO m, MonadFail m)
              => DatabaseSchema.ActionId
              -> DBMonad m GraphQLResultAction.Action
resolveAction :: ActionId -> DBMonad m Action
resolveAction actionKey :: ActionId
actionKey = do
  Just actionValue :: Action
actionValue <- ActionId -> ReaderT SqlBackend m (Maybe Action)
forall backend (m :: * -> *) record.
(PersistStoreRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
get ActionId
actionKey
  Action -> DBMonad m Action
forall (m :: * -> *) a. Monad m => a -> m a
return (Action -> DBMonad m Action) -> Action -> DBMonad m Action
forall a b. (a -> b) -> a -> b
$ Entity Action -> Action
actionToResult (Entity Action -> Action) -> Entity Action -> Action
forall a b. (a -> b) -> a -> b
$ ActionId -> Action -> Entity Action
forall record. Key record -> record -> Entity record
Entity ActionId
actionKey Action
actionValue

resolveSentences :: (MonadIO m, MonadFail m)
                 => LocIdBaseId -> DBMonad m [GraphQLResultSentence.Sentence]
resolveSentences :: Key LocIdBase -> DBMonad m [Sentence]
resolveSentences omsKey :: Key LocIdBase
omsKey = do
  [(Entity Sentence, Entity LocIdBase, Maybe (Entity FileRange),
  Maybe (Entity Conjecture))]
sentenceL <-
    SqlQuery
  (SqlExpr (Entity Sentence), SqlExpr (Entity LocIdBase),
   SqlExpr (Maybe (Entity FileRange)),
   SqlExpr (Maybe (Entity Conjecture)))
-> ReaderT
     SqlBackend
     m
     [(Entity Sentence, Entity LocIdBase, Maybe (Entity FileRange),
       Maybe (Entity Conjecture))]
forall a r (m :: * -> *).
(SqlSelect a r, MonadIO m) =>
SqlQuery a -> SqlReadT m [r]
select (SqlQuery
   (SqlExpr (Entity Sentence), SqlExpr (Entity LocIdBase),
    SqlExpr (Maybe (Entity FileRange)),
    SqlExpr (Maybe (Entity Conjecture)))
 -> ReaderT
      SqlBackend
      m
      [(Entity Sentence, Entity LocIdBase, Maybe (Entity FileRange),
        Maybe (Entity Conjecture))])
-> SqlQuery
     (SqlExpr (Entity Sentence), SqlExpr (Entity LocIdBase),
      SqlExpr (Maybe (Entity FileRange)),
      SqlExpr (Maybe (Entity Conjecture)))
-> ReaderT
     SqlBackend
     m
     [(Entity Sentence, Entity LocIdBase, Maybe (Entity FileRange),
       Maybe (Entity Conjecture))]
forall a b. (a -> b) -> a -> b
$ (LeftOuterJoin
   (LeftOuterJoin
      (InnerJoin
         (SqlExpr (Entity Sentence)) (SqlExpr (Entity LocIdBase)))
      (SqlExpr (Maybe (Entity FileRange))))
   (SqlExpr (Maybe (Entity Conjecture)))
 -> SqlQuery
      (SqlExpr (Entity Sentence), SqlExpr (Entity LocIdBase),
       SqlExpr (Maybe (Entity FileRange)),
       SqlExpr (Maybe (Entity Conjecture))))
-> SqlQuery
     (SqlExpr (Entity Sentence), SqlExpr (Entity LocIdBase),
      SqlExpr (Maybe (Entity FileRange)),
      SqlExpr (Maybe (Entity Conjecture)))
forall a b. From a => (a -> SqlQuery b) -> SqlQuery b
from ((LeftOuterJoin
    (LeftOuterJoin
       (InnerJoin
          (SqlExpr (Entity Sentence)) (SqlExpr (Entity LocIdBase)))
       (SqlExpr (Maybe (Entity FileRange))))
    (SqlExpr (Maybe (Entity Conjecture)))
  -> SqlQuery
       (SqlExpr (Entity Sentence), SqlExpr (Entity LocIdBase),
        SqlExpr (Maybe (Entity FileRange)),
        SqlExpr (Maybe (Entity Conjecture))))
 -> SqlQuery
      (SqlExpr (Entity Sentence), SqlExpr (Entity LocIdBase),
       SqlExpr (Maybe (Entity FileRange)),
       SqlExpr (Maybe (Entity Conjecture))))
-> (LeftOuterJoin
      (LeftOuterJoin
         (InnerJoin
            (SqlExpr (Entity Sentence)) (SqlExpr (Entity LocIdBase)))
         (SqlExpr (Maybe (Entity FileRange))))
      (SqlExpr (Maybe (Entity Conjecture)))
    -> SqlQuery
         (SqlExpr (Entity Sentence), SqlExpr (Entity LocIdBase),
          SqlExpr (Maybe (Entity FileRange)),
          SqlExpr (Maybe (Entity Conjecture))))
-> SqlQuery
     (SqlExpr (Entity Sentence), SqlExpr (Entity LocIdBase),
      SqlExpr (Maybe (Entity FileRange)),
      SqlExpr (Maybe (Entity Conjecture)))
forall a b. (a -> b) -> a -> b
$ \(sentencesSql :: SqlExpr (Entity Sentence)
sentencesSql `InnerJoin` loc_id_bases :: SqlExpr (Entity LocIdBase)
loc_id_bases
                                   `LeftOuterJoin` file_ranges :: SqlExpr (Maybe (Entity FileRange))
file_ranges
                                   `LeftOuterJoin` conjectures :: SqlExpr (Maybe (Entity Conjecture))
conjectures) -> do
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Value (Maybe (Key Conjecture)))
-> SqlExpr (Value (Key LocIdBase))
forall a b. SqlExpr (Value a) -> SqlExpr (Value b)
coerceId (SqlExpr (Maybe (Entity Conjecture))
conjectures SqlExpr (Maybe (Entity Conjecture))
-> EntityField Conjecture (Key Conjecture)
-> SqlExpr (Value (Maybe (Key Conjecture)))
forall val typ.
(PersistEntity val, PersistField typ) =>
SqlExpr (Maybe (Entity val))
-> EntityField val typ -> SqlExpr (Value (Maybe typ))
?. EntityField Conjecture (Key Conjecture)
forall typ. (typ ~ Key Conjecture) => EntityField Conjecture typ
ConjectureId) SqlExpr (Value (Key LocIdBase))
-> SqlExpr (Value (Key LocIdBase)) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==. SqlExpr (Entity LocIdBase)
loc_id_bases SqlExpr (Entity LocIdBase)
-> EntityField LocIdBase (Key LocIdBase)
-> SqlExpr (Value (Key LocIdBase))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField LocIdBase (Key LocIdBase)
forall typ. (typ ~ Key LocIdBase) => EntityField LocIdBase typ
LocIdBaseId)
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Maybe (Entity FileRange))
file_ranges SqlExpr (Maybe (Entity FileRange))
-> EntityField FileRange (Key FileRange)
-> SqlExpr (Value (Maybe (Key FileRange)))
forall val typ.
(PersistEntity val, PersistField typ) =>
SqlExpr (Maybe (Entity val))
-> EntityField val typ -> SqlExpr (Value (Maybe typ))
?. EntityField FileRange (Key FileRange)
forall typ. (typ ~ Key FileRange) => EntityField FileRange typ
FileRangeId SqlExpr (Value (Maybe (Key FileRange)))
-> SqlExpr (Value (Maybe (Key FileRange))) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==. SqlExpr (Entity Sentence)
sentencesSql SqlExpr (Entity Sentence)
-> EntityField Sentence (Maybe (Key FileRange))
-> SqlExpr (Value (Maybe (Key FileRange)))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField Sentence (Maybe (Key FileRange))
forall typ.
(typ ~ Maybe (Key FileRange)) =>
EntityField Sentence typ
SentenceFileRangeId)
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Entity LocIdBase)
loc_id_bases SqlExpr (Entity LocIdBase)
-> EntityField LocIdBase (Key LocIdBase)
-> SqlExpr (Value (Key LocIdBase))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField LocIdBase (Key LocIdBase)
forall typ. (typ ~ Key LocIdBase) => EntityField LocIdBase typ
LocIdBaseId SqlExpr (Value (Key LocIdBase))
-> SqlExpr (Value (Key LocIdBase)) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==. SqlExpr (Value (Key Sentence)) -> SqlExpr (Value (Key LocIdBase))
forall a b. SqlExpr (Value a) -> SqlExpr (Value b)
coerceId (SqlExpr (Entity Sentence)
sentencesSql SqlExpr (Entity Sentence)
-> EntityField Sentence (Key Sentence)
-> SqlExpr (Value (Key Sentence))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField Sentence (Key Sentence)
forall typ. (typ ~ Key Sentence) => EntityField Sentence typ
SentenceId))
      SqlExpr (Value Bool) -> SqlQuery ()
where_ (SqlExpr (Entity Sentence)
sentencesSql SqlExpr (Entity Sentence)
-> EntityField Sentence (Key LocIdBase)
-> SqlExpr (Value (Key LocIdBase))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField Sentence (Key LocIdBase)
forall typ. (typ ~ Key LocIdBase) => EntityField Sentence typ
SentenceOmsId SqlExpr (Value (Key LocIdBase))
-> SqlExpr (Value (Key LocIdBase)) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==. Key LocIdBase -> SqlExpr (Value (Key LocIdBase))
forall typ. PersistField typ => typ -> SqlExpr (Value typ)
val Key LocIdBase
omsKey)
      (SqlExpr (Entity Sentence), SqlExpr (Entity LocIdBase),
 SqlExpr (Maybe (Entity FileRange)),
 SqlExpr (Maybe (Entity Conjecture)))
-> SqlQuery
     (SqlExpr (Entity Sentence), SqlExpr (Entity LocIdBase),
      SqlExpr (Maybe (Entity FileRange)),
      SqlExpr (Maybe (Entity Conjecture)))
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlExpr (Entity Sentence)
sentencesSql, SqlExpr (Entity LocIdBase)
loc_id_bases, SqlExpr (Maybe (Entity FileRange))
file_ranges, SqlExpr (Maybe (Entity Conjecture))
conjectures)
  ((Entity Sentence, Entity LocIdBase, Maybe (Entity FileRange),
  Maybe (Entity Conjecture))
 -> ReaderT SqlBackend m Sentence)
-> [(Entity Sentence, Entity LocIdBase, Maybe (Entity FileRange),
     Maybe (Entity Conjecture))]
-> DBMonad m [Sentence]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (\ (sentenceEntity :: Entity Sentence
sentenceEntity, locIdBaseEntity :: Entity LocIdBase
locIdBaseEntity, fileRangeM :: Maybe (Entity FileRange)
fileRangeM, conjectureM :: Maybe (Entity Conjecture)
conjectureM) -> do
          [Symbol]
symbolResults <- Key Sentence -> DBMonad m [Symbol]
forall (m :: * -> *).
MonadIO m =>
Key Sentence -> DBMonad m [Symbol]
resolveSymbols (Key Sentence -> DBMonad m [Symbol])
-> Key Sentence -> DBMonad m [Symbol]
forall a b. (a -> b) -> a -> b
$ Entity Sentence -> Key Sentence
forall record. Entity record -> Key record
entityKey Entity Sentence
sentenceEntity
          case Maybe (Entity Conjecture)
conjectureM of
            Nothing -> Sentence -> ReaderT SqlBackend m Sentence
forall (m :: * -> *) a. Monad m => a -> m a
return (Sentence -> ReaderT SqlBackend m Sentence)
-> Sentence -> ReaderT SqlBackend m Sentence
forall a b. (a -> b) -> a -> b
$
              Entity Sentence
-> Entity LocIdBase
-> Maybe (Entity FileRange)
-> [Symbol]
-> Sentence
axiomToResult Entity Sentence
sentenceEntity Entity LocIdBase
locIdBaseEntity Maybe (Entity FileRange)
fileRangeM [Symbol]
symbolResults
            Just conjectureEntity :: Entity Conjecture
conjectureEntity -> Entity Sentence
-> Entity LocIdBase
-> Maybe (Entity FileRange)
-> Entity Conjecture
-> [Symbol]
-> ReaderT SqlBackend m Sentence
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
Entity Sentence
-> Entity LocIdBase
-> Maybe (Entity FileRange)
-> Entity Conjecture
-> [Symbol]
-> DBMonad m Sentence
resolveConjecture Entity Sentence
sentenceEntity
              Entity LocIdBase
locIdBaseEntity Maybe (Entity FileRange)
fileRangeM Entity Conjecture
conjectureEntity [Symbol]
symbolResults
       ) [(Entity Sentence, Entity LocIdBase, Maybe (Entity FileRange),
  Maybe (Entity Conjecture))]
sentenceL

resolveConjecture :: (MonadIO m, MonadFail m)
                  => Entity DatabaseSchema.Sentence
                  -> Entity DatabaseSchema.LocIdBase
                  -> Maybe (Entity DatabaseSchema.FileRange)
                  -> Entity DatabaseSchema.Conjecture
                  -> [GraphQLResultSymbol.Symbol]
                  -> DBMonad m GraphQLResultSentence.Sentence
resolveConjecture :: Entity Sentence
-> Entity LocIdBase
-> Maybe (Entity FileRange)
-> Entity Conjecture
-> [Symbol]
-> DBMonad m Sentence
resolveConjecture sentenceEntity :: Entity Sentence
sentenceEntity locIdBaseEntity :: Entity LocIdBase
locIdBaseEntity fileRangeM :: Maybe (Entity FileRange)
fileRangeM conjectureEntity :: Entity Conjecture
conjectureEntity symbolResults :: [Symbol]
symbolResults = do
  Action
actionResult <- ActionId -> DBMonad m Action
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
ActionId -> DBMonad m Action
resolveAction (ActionId -> DBMonad m Action) -> ActionId -> DBMonad m Action
forall a b. (a -> b) -> a -> b
$ Conjecture -> ActionId
conjectureActionId (Conjecture -> ActionId) -> Conjecture -> ActionId
forall a b. (a -> b) -> a -> b
$ Entity Conjecture -> Conjecture
forall record. Entity record -> record
entityVal Entity Conjecture
conjectureEntity
  [ReasoningAttempt]
proofAttemptResults <- Key LocIdBase -> DBMonad m [ReasoningAttempt]
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
Key LocIdBase -> DBMonad m [ReasoningAttempt]
resolveProofAttempts (Key LocIdBase -> DBMonad m [ReasoningAttempt])
-> Key LocIdBase -> DBMonad m [ReasoningAttempt]
forall a b. (a -> b) -> a -> b
$ Entity LocIdBase -> Key LocIdBase
forall record. Entity record -> Key record
entityKey Entity LocIdBase
locIdBaseEntity
  Sentence -> DBMonad m Sentence
forall (m :: * -> *) a. Monad m => a -> m a
return (Sentence -> DBMonad m Sentence) -> Sentence -> DBMonad m Sentence
forall a b. (a -> b) -> a -> b
$ Entity Sentence
-> Entity LocIdBase
-> Maybe (Entity FileRange)
-> Entity Conjecture
-> Action
-> [Symbol]
-> [ReasoningAttempt]
-> Sentence
conjectureToResult Entity Sentence
sentenceEntity Entity LocIdBase
locIdBaseEntity Maybe (Entity FileRange)
fileRangeM
    Entity Conjecture
conjectureEntity Action
actionResult [Symbol]
symbolResults [ReasoningAttempt]
proofAttemptResults

resolveProofAttempts :: (MonadIO m, MonadFail m)
                     => LocIdBaseId
                     -> DBMonad m [GraphQLResultReasoningAttempt.ReasoningAttempt]
resolveProofAttempts :: Key LocIdBase -> DBMonad m [ReasoningAttempt]
resolveProofAttempts conjectureKey :: Key LocIdBase
conjectureKey = do
  [(Entity ReasoningAttempt, Maybe (Entity Reasoner),
  Entity ReasonerConfiguration)]
proofAttemptL <-
    SqlQuery
  (SqlExpr (Entity ReasoningAttempt),
   SqlExpr (Maybe (Entity Reasoner)),
   SqlExpr (Entity ReasonerConfiguration))
-> ReaderT
     SqlBackend
     m
     [(Entity ReasoningAttempt, Maybe (Entity Reasoner),
       Entity ReasonerConfiguration)]
forall a r (m :: * -> *).
(SqlSelect a r, MonadIO m) =>
SqlQuery a -> SqlReadT m [r]
select (SqlQuery
   (SqlExpr (Entity ReasoningAttempt),
    SqlExpr (Maybe (Entity Reasoner)),
    SqlExpr (Entity ReasonerConfiguration))
 -> ReaderT
      SqlBackend
      m
      [(Entity ReasoningAttempt, Maybe (Entity Reasoner),
        Entity ReasonerConfiguration)])
-> SqlQuery
     (SqlExpr (Entity ReasoningAttempt),
      SqlExpr (Maybe (Entity Reasoner)),
      SqlExpr (Entity ReasonerConfiguration))
-> ReaderT
     SqlBackend
     m
     [(Entity ReasoningAttempt, Maybe (Entity Reasoner),
       Entity ReasonerConfiguration)]
forall a b. (a -> b) -> a -> b
$ (LeftOuterJoin
   (InnerJoin
      (InnerJoin
         (SqlExpr (Entity ReasoningAttempt))
         (SqlExpr (Entity ProofAttempt)))
      (SqlExpr (Entity ReasonerConfiguration)))
   (SqlExpr (Maybe (Entity Reasoner)))
 -> SqlQuery
      (SqlExpr (Entity ReasoningAttempt),
       SqlExpr (Maybe (Entity Reasoner)),
       SqlExpr (Entity ReasonerConfiguration)))
-> SqlQuery
     (SqlExpr (Entity ReasoningAttempt),
      SqlExpr (Maybe (Entity Reasoner)),
      SqlExpr (Entity ReasonerConfiguration))
forall a b. From a => (a -> SqlQuery b) -> SqlQuery b
from ((LeftOuterJoin
    (InnerJoin
       (InnerJoin
          (SqlExpr (Entity ReasoningAttempt))
          (SqlExpr (Entity ProofAttempt)))
       (SqlExpr (Entity ReasonerConfiguration)))
    (SqlExpr (Maybe (Entity Reasoner)))
  -> SqlQuery
       (SqlExpr (Entity ReasoningAttempt),
        SqlExpr (Maybe (Entity Reasoner)),
        SqlExpr (Entity ReasonerConfiguration)))
 -> SqlQuery
      (SqlExpr (Entity ReasoningAttempt),
       SqlExpr (Maybe (Entity Reasoner)),
       SqlExpr (Entity ReasonerConfiguration)))
-> (LeftOuterJoin
      (InnerJoin
         (InnerJoin
            (SqlExpr (Entity ReasoningAttempt))
            (SqlExpr (Entity ProofAttempt)))
         (SqlExpr (Entity ReasonerConfiguration)))
      (SqlExpr (Maybe (Entity Reasoner)))
    -> SqlQuery
         (SqlExpr (Entity ReasoningAttempt),
          SqlExpr (Maybe (Entity Reasoner)),
          SqlExpr (Entity ReasonerConfiguration)))
-> SqlQuery
     (SqlExpr (Entity ReasoningAttempt),
      SqlExpr (Maybe (Entity Reasoner)),
      SqlExpr (Entity ReasonerConfiguration))
forall a b. (a -> b) -> a -> b
$ \(reasoning_attempts :: SqlExpr (Entity ReasoningAttempt)
reasoning_attempts `InnerJoin` proof_attempts :: SqlExpr (Entity ProofAttempt)
proof_attempts
                                         `InnerJoin` reasoner_configurations :: SqlExpr (Entity ReasonerConfiguration)
reasoner_configurations
                                         `LeftOuterJoin` reasoners :: SqlExpr (Maybe (Entity Reasoner))
reasoners) -> do
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Maybe (Entity Reasoner))
reasoners SqlExpr (Maybe (Entity Reasoner))
-> EntityField Reasoner (Key Reasoner)
-> SqlExpr (Value (Maybe (Key Reasoner)))
forall val typ.
(PersistEntity val, PersistField typ) =>
SqlExpr (Maybe (Entity val))
-> EntityField val typ -> SqlExpr (Value (Maybe typ))
?. EntityField Reasoner (Key Reasoner)
forall typ. (typ ~ Key Reasoner) => EntityField Reasoner typ
ReasonerId SqlExpr (Value (Maybe (Key Reasoner)))
-> SqlExpr (Value (Maybe (Key Reasoner))) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==.
            SqlExpr (Entity ReasoningAttempt)
reasoning_attempts SqlExpr (Entity ReasoningAttempt)
-> EntityField ReasoningAttempt (Maybe (Key Reasoner))
-> SqlExpr (Value (Maybe (Key Reasoner)))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField ReasoningAttempt (Maybe (Key Reasoner))
forall typ.
(typ ~ Maybe (Key Reasoner)) =>
EntityField ReasoningAttempt typ
ReasoningAttemptUsedReasonerId)
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Entity ReasonerConfiguration)
reasoner_configurations SqlExpr (Entity ReasonerConfiguration)
-> EntityField ReasonerConfiguration (Key ReasonerConfiguration)
-> SqlExpr (Value (Key ReasonerConfiguration))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField ReasonerConfiguration (Key ReasonerConfiguration)
forall typ.
(typ ~ Key ReasonerConfiguration) =>
EntityField ReasonerConfiguration typ
ReasonerConfigurationId SqlExpr (Value (Key ReasonerConfiguration))
-> SqlExpr (Value (Key ReasonerConfiguration))
-> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==.
            SqlExpr (Entity ReasoningAttempt)
reasoning_attempts SqlExpr (Entity ReasoningAttempt)
-> EntityField ReasoningAttempt (Key ReasonerConfiguration)
-> SqlExpr (Value (Key ReasonerConfiguration))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField ReasoningAttempt (Key ReasonerConfiguration)
forall typ.
(typ ~ Key ReasonerConfiguration) =>
EntityField ReasoningAttempt typ
ReasoningAttemptReasonerConfigurationId)
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Value (Key ProofAttempt))
-> SqlExpr (Value (Key ReasoningAttempt))
forall a b. SqlExpr (Value a) -> SqlExpr (Value b)
coerceId (SqlExpr (Entity ProofAttempt)
proof_attempts SqlExpr (Entity ProofAttempt)
-> EntityField ProofAttempt (Key ProofAttempt)
-> SqlExpr (Value (Key ProofAttempt))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField ProofAttempt (Key ProofAttempt)
forall typ.
(typ ~ Key ProofAttempt) =>
EntityField ProofAttempt typ
ProofAttemptId) SqlExpr (Value (Key ReasoningAttempt))
-> SqlExpr (Value (Key ReasoningAttempt)) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==.
            SqlExpr (Entity ReasoningAttempt)
reasoning_attempts SqlExpr (Entity ReasoningAttempt)
-> EntityField ReasoningAttempt (Key ReasoningAttempt)
-> SqlExpr (Value (Key ReasoningAttempt))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField ReasoningAttempt (Key ReasoningAttempt)
forall typ.
(typ ~ Key ReasoningAttempt) =>
EntityField ReasoningAttempt typ
ReasoningAttemptId)
      SqlExpr (Value Bool) -> SqlQuery ()
where_ (SqlExpr (Entity ProofAttempt)
proof_attempts SqlExpr (Entity ProofAttempt)
-> EntityField ProofAttempt (Maybe (Key LocIdBase))
-> SqlExpr (Value (Maybe (Key LocIdBase)))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField ProofAttempt (Maybe (Key LocIdBase))
forall typ.
(typ ~ Maybe (Key LocIdBase)) =>
EntityField ProofAttempt typ
ProofAttemptConjectureId SqlExpr (Value (Maybe (Key LocIdBase)))
-> SqlExpr (Value (Maybe (Key LocIdBase))) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==.
                SqlExpr (Value (Key LocIdBase))
-> SqlExpr (Value (Maybe (Key LocIdBase)))
forall typ. SqlExpr (Value typ) -> SqlExpr (Value (Maybe typ))
just (Key LocIdBase -> SqlExpr (Value (Key LocIdBase))
forall typ. PersistField typ => typ -> SqlExpr (Value typ)
val Key LocIdBase
conjectureKey))
      (SqlExpr (Entity ReasoningAttempt),
 SqlExpr (Maybe (Entity Reasoner)),
 SqlExpr (Entity ReasonerConfiguration))
-> SqlQuery
     (SqlExpr (Entity ReasoningAttempt),
      SqlExpr (Maybe (Entity Reasoner)),
      SqlExpr (Entity ReasonerConfiguration))
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlExpr (Entity ReasoningAttempt)
reasoning_attempts, SqlExpr (Maybe (Entity Reasoner))
reasoners, SqlExpr (Entity ReasonerConfiguration)
reasoner_configurations)
  ((Entity ReasoningAttempt, Maybe (Entity Reasoner),
  Entity ReasonerConfiguration)
 -> ReaderT SqlBackend m ReasoningAttempt)
-> [(Entity ReasoningAttempt, Maybe (Entity Reasoner),
     Entity ReasonerConfiguration)]
-> DBMonad m [ReasoningAttempt]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (Entity ReasoningAttempt, Maybe (Entity Reasoner),
 Entity ReasonerConfiguration)
-> ReaderT SqlBackend m ReasoningAttempt
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
(Entity ReasoningAttempt, Maybe (Entity Reasoner),
 Entity ReasonerConfiguration)
-> DBMonad m ReasoningAttempt
resolveReasoningAttempt [(Entity ReasoningAttempt, Maybe (Entity Reasoner),
  Entity ReasonerConfiguration)]
proofAttemptL

resolveReasonerConfiguration :: MonadIO m
                             => Entity DatabaseSchema.ReasonerConfiguration
                             -> DBMonad m GraphQLResultReasonerConfiguration.ReasonerConfiguration
resolveReasonerConfiguration :: Entity ReasonerConfiguration -> DBMonad m ReasonerConfiguration
resolveReasonerConfiguration reasonerConfigurationEntity :: Entity ReasonerConfiguration
reasonerConfigurationEntity@(Entity reasonerConfigurationKey :: Key ReasonerConfiguration
reasonerConfigurationKey reasonerConfigurationValue :: ReasonerConfiguration
reasonerConfigurationValue) = do
  [Maybe (Entity Reasoner)]
reasonerL <-
    SqlQuery (SqlExpr (Maybe (Entity Reasoner)))
-> ReaderT SqlBackend m [Maybe (Entity Reasoner)]
forall a r (m :: * -> *).
(SqlSelect a r, MonadIO m) =>
SqlQuery a -> SqlReadT m [r]
select (SqlQuery (SqlExpr (Maybe (Entity Reasoner)))
 -> ReaderT SqlBackend m [Maybe (Entity Reasoner)])
-> SqlQuery (SqlExpr (Maybe (Entity Reasoner)))
-> ReaderT SqlBackend m [Maybe (Entity Reasoner)]
forall a b. (a -> b) -> a -> b
$ (SqlExpr (Maybe (Entity Reasoner))
 -> SqlQuery (SqlExpr (Maybe (Entity Reasoner))))
-> SqlQuery (SqlExpr (Maybe (Entity Reasoner)))
forall a b. From a => (a -> SqlQuery b) -> SqlQuery b
from ((SqlExpr (Maybe (Entity Reasoner))
  -> SqlQuery (SqlExpr (Maybe (Entity Reasoner))))
 -> SqlQuery (SqlExpr (Maybe (Entity Reasoner))))
-> (SqlExpr (Maybe (Entity Reasoner))
    -> SqlQuery (SqlExpr (Maybe (Entity Reasoner))))
-> SqlQuery (SqlExpr (Maybe (Entity Reasoner)))
forall a b. (a -> b) -> a -> b
$ \ reasoners :: SqlExpr (Maybe (Entity Reasoner))
reasoners -> do
      SqlExpr (Value Bool) -> SqlQuery ()
where_ (SqlExpr (Maybe (Entity Reasoner))
reasoners SqlExpr (Maybe (Entity Reasoner))
-> EntityField Reasoner (Key Reasoner)
-> SqlExpr (Value (Maybe (Key Reasoner)))
forall val typ.
(PersistEntity val, PersistField typ) =>
SqlExpr (Maybe (Entity val))
-> EntityField val typ -> SqlExpr (Value (Maybe typ))
?. EntityField Reasoner (Key Reasoner)
forall typ. (typ ~ Key Reasoner) => EntityField Reasoner typ
ReasonerId SqlExpr (Value (Maybe (Key Reasoner)))
-> SqlExpr (Value (Maybe (Key Reasoner))) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==.
                Maybe (Key Reasoner) -> SqlExpr (Value (Maybe (Key Reasoner)))
forall typ. PersistField typ => typ -> SqlExpr (Value typ)
val (ReasonerConfiguration -> Maybe (Key Reasoner)
reasonerConfigurationConfiguredReasonerId ReasonerConfiguration
reasonerConfigurationValue))
      SqlExpr (Maybe (Entity Reasoner))
-> SqlQuery (SqlExpr (Maybe (Entity Reasoner)))
forall (m :: * -> *) a. Monad m => a -> m a
return SqlExpr (Maybe (Entity Reasoner))
reasoners
  let reasonerResultM :: Maybe (Entity Reasoner)
reasonerResultM = case [Maybe (Entity Reasoner)]
reasonerL of
        [] -> Maybe (Entity Reasoner)
forall a. Maybe a
Nothing
        reasonerEntity :: Maybe (Entity Reasoner)
reasonerEntity : _ -> Maybe (Entity Reasoner)
reasonerEntity

  [Entity PremiseSelection]
premiseSelectionsL <-
    SqlQuery (SqlExpr (Entity PremiseSelection))
-> ReaderT SqlBackend m [Entity PremiseSelection]
forall a r (m :: * -> *).
(SqlSelect a r, MonadIO m) =>
SqlQuery a -> SqlReadT m [r]
select (SqlQuery (SqlExpr (Entity PremiseSelection))
 -> ReaderT SqlBackend m [Entity PremiseSelection])
-> SqlQuery (SqlExpr (Entity PremiseSelection))
-> ReaderT SqlBackend m [Entity PremiseSelection]
forall a b. (a -> b) -> a -> b
$ (SqlExpr (Entity PremiseSelection)
 -> SqlQuery (SqlExpr (Entity PremiseSelection)))
-> SqlQuery (SqlExpr (Entity PremiseSelection))
forall a b. From a => (a -> SqlQuery b) -> SqlQuery b
from ((SqlExpr (Entity PremiseSelection)
  -> SqlQuery (SqlExpr (Entity PremiseSelection)))
 -> SqlQuery (SqlExpr (Entity PremiseSelection)))
-> (SqlExpr (Entity PremiseSelection)
    -> SqlQuery (SqlExpr (Entity PremiseSelection)))
-> SqlQuery (SqlExpr (Entity PremiseSelection))
forall a b. (a -> b) -> a -> b
$ \ premise_selections :: SqlExpr (Entity PremiseSelection)
premise_selections -> do
      SqlExpr (Value Bool) -> SqlQuery ()
where_ (SqlExpr (Entity PremiseSelection)
premise_selections SqlExpr (Entity PremiseSelection)
-> EntityField PremiseSelection (Key ReasonerConfiguration)
-> SqlExpr (Value (Key ReasonerConfiguration))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField PremiseSelection (Key ReasonerConfiguration)
forall typ.
(typ ~ Key ReasonerConfiguration) =>
EntityField PremiseSelection typ
PremiseSelectionReasonerConfigurationId SqlExpr (Value (Key ReasonerConfiguration))
-> SqlExpr (Value (Key ReasonerConfiguration))
-> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==.
                Key ReasonerConfiguration
-> SqlExpr (Value (Key ReasonerConfiguration))
forall typ. PersistField typ => typ -> SqlExpr (Value typ)
val Key ReasonerConfiguration
reasonerConfigurationKey)
      SqlExpr (Entity PremiseSelection)
-> SqlQuery (SqlExpr (Entity PremiseSelection))
forall (m :: * -> *) a. Monad m => a -> m a
return SqlExpr (Entity PremiseSelection)
premise_selections

  [PremiseSelection]
premiseSelectionResults <- (Entity PremiseSelection -> ReaderT SqlBackend m PremiseSelection)
-> [Entity PremiseSelection]
-> ReaderT SqlBackend m [PremiseSelection]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Entity PremiseSelection -> ReaderT SqlBackend m PremiseSelection
forall (m :: * -> *).
MonadIO m =>
Entity PremiseSelection -> DBMonad m PremiseSelection
resolvePremiseSelection [Entity PremiseSelection]
premiseSelectionsL
  ReasonerConfiguration -> DBMonad m ReasonerConfiguration
forall (m :: * -> *) a. Monad m => a -> m a
return (ReasonerConfiguration -> DBMonad m ReasonerConfiguration)
-> ReasonerConfiguration -> DBMonad m ReasonerConfiguration
forall a b. (a -> b) -> a -> b
$ Entity ReasonerConfiguration
-> Maybe (Entity Reasoner)
-> [PremiseSelection]
-> ReasonerConfiguration
reasonerConfigurationToResult Entity ReasonerConfiguration
reasonerConfigurationEntity
    Maybe (Entity Reasoner)
reasonerResultM [PremiseSelection]
premiseSelectionResults

resolvePremiseSelection :: MonadIO m
                        => Entity DatabaseSchema.PremiseSelection
                        -> DBMonad m GraphQLResultPremiseSelection.PremiseSelection
resolvePremiseSelection :: Entity PremiseSelection -> DBMonad m PremiseSelection
resolvePremiseSelection (Entity premiseSelectionKey :: Key PremiseSelection
premiseSelectionKey _) = do
  [Entity LocIdBase]
premises <-
    SqlQuery (SqlExpr (Entity LocIdBase))
-> ReaderT SqlBackend m [Entity LocIdBase]
forall a r (m :: * -> *).
(SqlSelect a r, MonadIO m) =>
SqlQuery a -> SqlReadT m [r]
select (SqlQuery (SqlExpr (Entity LocIdBase))
 -> ReaderT SqlBackend m [Entity LocIdBase])
-> SqlQuery (SqlExpr (Entity LocIdBase))
-> ReaderT SqlBackend m [Entity LocIdBase]
forall a b. (a -> b) -> a -> b
$ (InnerJoin
   (InnerJoin
      (SqlExpr (Entity LocIdBase))
      (SqlExpr (Entity PremiseSelectedSentence)))
   (SqlExpr (Entity PremiseSelection))
 -> SqlQuery (SqlExpr (Entity LocIdBase)))
-> SqlQuery (SqlExpr (Entity LocIdBase))
forall a b. From a => (a -> SqlQuery b) -> SqlQuery b
from ((InnerJoin
    (InnerJoin
       (SqlExpr (Entity LocIdBase))
       (SqlExpr (Entity PremiseSelectedSentence)))
    (SqlExpr (Entity PremiseSelection))
  -> SqlQuery (SqlExpr (Entity LocIdBase)))
 -> SqlQuery (SqlExpr (Entity LocIdBase)))
-> (InnerJoin
      (InnerJoin
         (SqlExpr (Entity LocIdBase))
         (SqlExpr (Entity PremiseSelectedSentence)))
      (SqlExpr (Entity PremiseSelection))
    -> SqlQuery (SqlExpr (Entity LocIdBase)))
-> SqlQuery (SqlExpr (Entity LocIdBase))
forall a b. (a -> b) -> a -> b
$ \ (loc_id_bases :: SqlExpr (Entity LocIdBase)
loc_id_bases `InnerJoin` premise_selected_sentences :: SqlExpr (Entity PremiseSelectedSentence)
premise_selected_sentences
                                    `InnerJoin` premise_selections :: SqlExpr (Entity PremiseSelection)
premise_selections) -> do
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Entity LocIdBase)
loc_id_bases SqlExpr (Entity LocIdBase)
-> EntityField LocIdBase (Key LocIdBase)
-> SqlExpr (Value (Key LocIdBase))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField LocIdBase (Key LocIdBase)
forall typ. (typ ~ Key LocIdBase) => EntityField LocIdBase typ
LocIdBaseId SqlExpr (Value (Key LocIdBase))
-> SqlExpr (Value (Key LocIdBase)) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==.
            SqlExpr (Entity PremiseSelectedSentence)
premise_selected_sentences SqlExpr (Entity PremiseSelectedSentence)
-> EntityField PremiseSelectedSentence (Key LocIdBase)
-> SqlExpr (Value (Key LocIdBase))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField PremiseSelectedSentence (Key LocIdBase)
forall typ.
(typ ~ Key LocIdBase) =>
EntityField PremiseSelectedSentence typ
PremiseSelectedSentencePremiseId)
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Entity PremiseSelectedSentence)
premise_selected_sentences SqlExpr (Entity PremiseSelectedSentence)
-> EntityField PremiseSelectedSentence (Key PremiseSelection)
-> SqlExpr (Value (Key PremiseSelection))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField PremiseSelectedSentence (Key PremiseSelection)
forall typ.
(typ ~ Key PremiseSelection) =>
EntityField PremiseSelectedSentence typ
PremiseSelectedSentencePremiseSelectionId SqlExpr (Value (Key PremiseSelection))
-> SqlExpr (Value (Key PremiseSelection)) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==.
            SqlExpr (Entity PremiseSelection)
premise_selections SqlExpr (Entity PremiseSelection)
-> EntityField PremiseSelection (Key PremiseSelection)
-> SqlExpr (Value (Key PremiseSelection))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField PremiseSelection (Key PremiseSelection)
forall typ.
(typ ~ Key PremiseSelection) =>
EntityField PremiseSelection typ
PremiseSelectionId)
      SqlExpr (Value Bool) -> SqlQuery ()
where_ (SqlExpr (Entity PremiseSelection)
premise_selections SqlExpr (Entity PremiseSelection)
-> EntityField PremiseSelection (Key PremiseSelection)
-> SqlExpr (Value (Key PremiseSelection))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField PremiseSelection (Key PremiseSelection)
forall typ.
(typ ~ Key PremiseSelection) =>
EntityField PremiseSelection typ
PremiseSelectionId SqlExpr (Value (Key PremiseSelection))
-> SqlExpr (Value (Key PremiseSelection)) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==. Key PremiseSelection -> SqlExpr (Value (Key PremiseSelection))
forall typ. PersistField typ => typ -> SqlExpr (Value typ)
val Key PremiseSelection
premiseSelectionKey)
      SqlExpr (Entity LocIdBase) -> SqlQuery (SqlExpr (Entity LocIdBase))
forall (m :: * -> *) a. Monad m => a -> m a
return SqlExpr (Entity LocIdBase)
loc_id_bases
  PremiseSelection -> DBMonad m PremiseSelection
forall (m :: * -> *) a. Monad m => a -> m a
return (PremiseSelection -> DBMonad m PremiseSelection)
-> PremiseSelection -> DBMonad m PremiseSelection
forall a b. (a -> b) -> a -> b
$ [Entity LocIdBase] -> PremiseSelection
premiseSelectionToResult [Entity LocIdBase]
premises

resolveSerialization :: MonadIO m
                     => SerializationId
                     -> DBMonad m (Maybe StringReference)
resolveSerialization :: Key Serialization -> DBMonad m (Maybe StringReference)
resolveSerialization serializationKey :: Key Serialization
serializationKey = do
  [Entity Serialization]
serializationL <-
    SqlQuery (SqlExpr (Entity Serialization))
-> ReaderT SqlBackend m [Entity Serialization]
forall a r (m :: * -> *).
(SqlSelect a r, MonadIO m) =>
SqlQuery a -> SqlReadT m [r]
select (SqlQuery (SqlExpr (Entity Serialization))
 -> ReaderT SqlBackend m [Entity Serialization])
-> SqlQuery (SqlExpr (Entity Serialization))
-> ReaderT SqlBackend m [Entity Serialization]
forall a b. (a -> b) -> a -> b
$ (SqlExpr (Entity Serialization)
 -> SqlQuery (SqlExpr (Entity Serialization)))
-> SqlQuery (SqlExpr (Entity Serialization))
forall a b. From a => (a -> SqlQuery b) -> SqlQuery b
from ((SqlExpr (Entity Serialization)
  -> SqlQuery (SqlExpr (Entity Serialization)))
 -> SqlQuery (SqlExpr (Entity Serialization)))
-> (SqlExpr (Entity Serialization)
    -> SqlQuery (SqlExpr (Entity Serialization)))
-> SqlQuery (SqlExpr (Entity Serialization))
forall a b. (a -> b) -> a -> b
$ \(SqlExpr (Entity Serialization)
serializations) -> do
      SqlExpr (Value Bool) -> SqlQuery ()
where_ (SqlExpr (Entity Serialization)
serializations SqlExpr (Entity Serialization)
-> EntityField Serialization (Key Serialization)
-> SqlExpr (Value (Key Serialization))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField Serialization (Key Serialization)
forall typ.
(typ ~ Key Serialization) =>
EntityField Serialization typ
SerializationId SqlExpr (Value (Key Serialization))
-> SqlExpr (Value (Key Serialization)) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==. Key Serialization -> SqlExpr (Value (Key Serialization))
forall typ. PersistField typ => typ -> SqlExpr (Value typ)
val Key Serialization
serializationKey)
      SqlExpr (Entity Serialization)
-> SqlQuery (SqlExpr (Entity Serialization))
forall (m :: * -> *) a. Monad m => a -> m a
return SqlExpr (Entity Serialization)
serializations
  case [Entity Serialization]
serializationL of
    [] -> Maybe StringReference -> DBMonad m (Maybe StringReference)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe StringReference
forall a. Maybe a
Nothing
    Entity _ serializationValue :: Serialization
serializationValue : _ ->
      Maybe StringReference -> DBMonad m (Maybe StringReference)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe StringReference -> DBMonad m (Maybe StringReference))
-> Maybe StringReference -> DBMonad m (Maybe StringReference)
forall a b. (a -> b) -> a -> b
$ StringReference -> Maybe StringReference
forall a. a -> Maybe a
Just (StringReference -> Maybe StringReference)
-> StringReference -> Maybe StringReference
forall a b. (a -> b) -> a -> b
$ String -> StringReference
StringReference (String -> StringReference) -> String -> StringReference
forall a b. (a -> b) -> a -> b
$ Serialization -> String
serializationSlug Serialization
serializationValue

resolveSymbols :: MonadIO m
               => SentenceId -> DBMonad m [GraphQLResultSymbol.Symbol]
resolveSymbols :: Key Sentence -> DBMonad m [Symbol]
resolveSymbols sentenceKey :: Key Sentence
sentenceKey = do
  [(Entity LocIdBase, Entity Symbol, Maybe (Entity FileRange))]
symbolL <-
    SqlQuery
  (SqlExpr (Entity LocIdBase), SqlExpr (Entity Symbol),
   SqlExpr (Maybe (Entity FileRange)))
-> ReaderT
     SqlBackend
     m
     [(Entity LocIdBase, Entity Symbol, Maybe (Entity FileRange))]
forall a r (m :: * -> *).
(SqlSelect a r, MonadIO m) =>
SqlQuery a -> SqlReadT m [r]
select (SqlQuery
   (SqlExpr (Entity LocIdBase), SqlExpr (Entity Symbol),
    SqlExpr (Maybe (Entity FileRange)))
 -> ReaderT
      SqlBackend
      m
      [(Entity LocIdBase, Entity Symbol, Maybe (Entity FileRange))])
-> SqlQuery
     (SqlExpr (Entity LocIdBase), SqlExpr (Entity Symbol),
      SqlExpr (Maybe (Entity FileRange)))
-> ReaderT
     SqlBackend
     m
     [(Entity LocIdBase, Entity Symbol, Maybe (Entity FileRange))]
forall a b. (a -> b) -> a -> b
$ (LeftOuterJoin
   (InnerJoin
      (InnerJoin
         (InnerJoin
            (SqlExpr (Entity Symbol)) (SqlExpr (Entity SentenceSymbol)))
         (SqlExpr (Entity Sentence)))
      (SqlExpr (Entity LocIdBase)))
   (SqlExpr (Maybe (Entity FileRange)))
 -> SqlQuery
      (SqlExpr (Entity LocIdBase), SqlExpr (Entity Symbol),
       SqlExpr (Maybe (Entity FileRange))))
-> SqlQuery
     (SqlExpr (Entity LocIdBase), SqlExpr (Entity Symbol),
      SqlExpr (Maybe (Entity FileRange)))
forall a b. From a => (a -> SqlQuery b) -> SqlQuery b
from ((LeftOuterJoin
    (InnerJoin
       (InnerJoin
          (InnerJoin
             (SqlExpr (Entity Symbol)) (SqlExpr (Entity SentenceSymbol)))
          (SqlExpr (Entity Sentence)))
       (SqlExpr (Entity LocIdBase)))
    (SqlExpr (Maybe (Entity FileRange)))
  -> SqlQuery
       (SqlExpr (Entity LocIdBase), SqlExpr (Entity Symbol),
        SqlExpr (Maybe (Entity FileRange))))
 -> SqlQuery
      (SqlExpr (Entity LocIdBase), SqlExpr (Entity Symbol),
       SqlExpr (Maybe (Entity FileRange))))
-> (LeftOuterJoin
      (InnerJoin
         (InnerJoin
            (InnerJoin
               (SqlExpr (Entity Symbol)) (SqlExpr (Entity SentenceSymbol)))
            (SqlExpr (Entity Sentence)))
         (SqlExpr (Entity LocIdBase)))
      (SqlExpr (Maybe (Entity FileRange)))
    -> SqlQuery
         (SqlExpr (Entity LocIdBase), SqlExpr (Entity Symbol),
          SqlExpr (Maybe (Entity FileRange))))
-> SqlQuery
     (SqlExpr (Entity LocIdBase), SqlExpr (Entity Symbol),
      SqlExpr (Maybe (Entity FileRange)))
forall a b. (a -> b) -> a -> b
$ \(symbols :: SqlExpr (Entity Symbol)
symbols `InnerJoin` sentences_symbols :: SqlExpr (Entity SentenceSymbol)
sentences_symbols
                              `InnerJoin` sentencesSql :: SqlExpr (Entity Sentence)
sentencesSql
                              `InnerJoin` loc_id_bases :: SqlExpr (Entity LocIdBase)
loc_id_bases
                              `LeftOuterJoin` file_ranges :: SqlExpr (Maybe (Entity FileRange))
file_ranges) -> do
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Maybe (Entity FileRange))
file_ranges SqlExpr (Maybe (Entity FileRange))
-> EntityField FileRange (Key FileRange)
-> SqlExpr (Value (Maybe (Key FileRange)))
forall val typ.
(PersistEntity val, PersistField typ) =>
SqlExpr (Maybe (Entity val))
-> EntityField val typ -> SqlExpr (Value (Maybe typ))
?. EntityField FileRange (Key FileRange)
forall typ. (typ ~ Key FileRange) => EntityField FileRange typ
FileRangeId SqlExpr (Value (Maybe (Key FileRange)))
-> SqlExpr (Value (Maybe (Key FileRange))) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==. SqlExpr (Entity Symbol)
symbols SqlExpr (Entity Symbol)
-> EntityField Symbol (Maybe (Key FileRange))
-> SqlExpr (Value (Maybe (Key FileRange)))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField Symbol (Maybe (Key FileRange))
forall typ. (typ ~ Maybe (Key FileRange)) => EntityField Symbol typ
SymbolFileRangeId)
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Entity LocIdBase)
loc_id_bases SqlExpr (Entity LocIdBase)
-> EntityField LocIdBase (Key LocIdBase)
-> SqlExpr (Value (Key LocIdBase))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField LocIdBase (Key LocIdBase)
forall typ. (typ ~ Key LocIdBase) => EntityField LocIdBase typ
LocIdBaseId SqlExpr (Value (Key LocIdBase))
-> SqlExpr (Value (Key LocIdBase)) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==. SqlExpr (Value (Key Symbol)) -> SqlExpr (Value (Key LocIdBase))
forall a b. SqlExpr (Value a) -> SqlExpr (Value b)
coerceId (SqlExpr (Entity Symbol)
symbols SqlExpr (Entity Symbol)
-> EntityField Symbol (Key Symbol) -> SqlExpr (Value (Key Symbol))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField Symbol (Key Symbol)
forall typ. (typ ~ Key Symbol) => EntityField Symbol typ
SymbolId))
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Value (Key Sentence)) -> SqlExpr (Value (Key LocIdBase))
forall a b. SqlExpr (Value a) -> SqlExpr (Value b)
coerceId (SqlExpr (Entity Sentence)
sentencesSql SqlExpr (Entity Sentence)
-> EntityField Sentence (Key Sentence)
-> SqlExpr (Value (Key Sentence))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField Sentence (Key Sentence)
forall typ. (typ ~ Key Sentence) => EntityField Sentence typ
SentenceId) SqlExpr (Value (Key LocIdBase))
-> SqlExpr (Value (Key LocIdBase)) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==.
            SqlExpr (Entity SentenceSymbol)
sentences_symbols SqlExpr (Entity SentenceSymbol)
-> EntityField SentenceSymbol (Key LocIdBase)
-> SqlExpr (Value (Key LocIdBase))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField SentenceSymbol (Key LocIdBase)
forall typ. (typ ~ Key LocIdBase) => EntityField SentenceSymbol typ
SentenceSymbolSentenceId)
      SqlExpr (Value Bool) -> SqlQuery ()
on (SqlExpr (Entity SentenceSymbol)
sentences_symbols SqlExpr (Entity SentenceSymbol)
-> EntityField SentenceSymbol (Key LocIdBase)
-> SqlExpr (Value (Key LocIdBase))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField SentenceSymbol (Key LocIdBase)
forall typ. (typ ~ Key LocIdBase) => EntityField SentenceSymbol typ
SentenceSymbolSymbolId SqlExpr (Value (Key LocIdBase))
-> SqlExpr (Value (Key LocIdBase)) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==.
            SqlExpr (Value (Key Symbol)) -> SqlExpr (Value (Key LocIdBase))
forall a b. SqlExpr (Value a) -> SqlExpr (Value b)
coerceId (SqlExpr (Entity Symbol)
symbols SqlExpr (Entity Symbol)
-> EntityField Symbol (Key Symbol) -> SqlExpr (Value (Key Symbol))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField Symbol (Key Symbol)
forall typ. (typ ~ Key Symbol) => EntityField Symbol typ
SymbolId))
      SqlExpr (Value Bool) -> SqlQuery ()
where_ (SqlExpr (Entity SentenceSymbol)
sentences_symbols SqlExpr (Entity SentenceSymbol)
-> EntityField SentenceSymbol (Key LocIdBase)
-> SqlExpr (Value (Key LocIdBase))
forall typ val.
(PersistEntity val, PersistField typ) =>
SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
^. EntityField SentenceSymbol (Key LocIdBase)
forall typ. (typ ~ Key LocIdBase) => EntityField SentenceSymbol typ
SentenceSymbolSentenceId SqlExpr (Value (Key LocIdBase))
-> SqlExpr (Value (Key LocIdBase)) -> SqlExpr (Value Bool)
forall typ.
PersistField typ =>
SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
==.
                Key LocIdBase -> SqlExpr (Value (Key LocIdBase))
forall typ. PersistField typ => typ -> SqlExpr (Value typ)
val (Int64 -> Key LocIdBase
forall record.
ToBackendKey SqlBackend record =>
Int64 -> Key record
toSqlKey (Int64 -> Key LocIdBase) -> Int64 -> Key LocIdBase
forall a b. (a -> b) -> a -> b
$ Key Sentence -> Int64
forall record.
ToBackendKey SqlBackend record =>
Key record -> Int64
fromSqlKey Key Sentence
sentenceKey))
      (SqlExpr (Entity LocIdBase), SqlExpr (Entity Symbol),
 SqlExpr (Maybe (Entity FileRange)))
-> SqlQuery
     (SqlExpr (Entity LocIdBase), SqlExpr (Entity Symbol),
      SqlExpr (Maybe (Entity FileRange)))
forall (m :: * -> *) a. Monad m => a -> m a
return (SqlExpr (Entity LocIdBase)
loc_id_bases, SqlExpr (Entity Symbol)
symbols, SqlExpr (Maybe (Entity FileRange))
file_ranges)
  [Symbol] -> DBMonad m [Symbol]
forall (m :: * -> *) a. Monad m => a -> m a
return ([Symbol] -> DBMonad m [Symbol]) -> [Symbol] -> DBMonad m [Symbol]
forall a b. (a -> b) -> a -> b
$ ((Entity LocIdBase, Entity Symbol, Maybe (Entity FileRange))
 -> Symbol)
-> [(Entity LocIdBase, Entity Symbol, Maybe (Entity FileRange))]
-> [Symbol]
forall a b. (a -> b) -> [a] -> [b]
map (Entity LocIdBase, Entity Symbol, Maybe (Entity FileRange))
-> Symbol
symbolToResultUncurried [(Entity LocIdBase, Entity Symbol, Maybe (Entity FileRange))]
symbolL