{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeOperators #-}

module Server.Handlers.DocsHandlers
    ( DocsAPI
    , docsServer
    , getUser
    , withDB
    ) where

import Data.Time (UTCTime)

import Control.Monad.IO.Class (MonadIO (liftIO))
import qualified Data.ByteString.Lazy.Char8 as LBS
import Data.Maybe (fromMaybe)
import qualified Data.Text as T

import Hasql.Connection (Connection)
import qualified Hasql.Session as Session

import Servant
    ( Capture
    , Delete
    , Description
    , Get
    , Handler
    , JSON
    , Post
    , QueryParam
    , ReqBody
    , Server
    , Summary
    , err400
    , err403
    , err500
    , errBody
    , throwError
    , type (:<|>) (..)
    , type (:>)
    )
import Servant.Auth.Server (Auth, AuthResult (Authenticated))

import Server.Auth (AuthMethod)
import qualified Server.Auth as Auth
import Server.HandlerUtil (errNotLoggedIn, tryGetDBConnection)

import UserManagement.User (UserID)

import qualified Docs
import Docs.Document (Document, DocumentID (..))
import Docs.DocumentHistory (DocumentHistory)
import Docs.Hasql.Database (run, runTransaction)
import Docs.TextElement
    ( TextElement
    , TextElementID
    , TextElementRef (..)
    , prettyPrintTextElementRef
    )
import Docs.TextRevision
    ( ConflictStatus
    , DraftRevision
    , NewTextRevision (..)
    , Rendered
    , TextElementRevision
    , TextRevisionHistory
    , TextRevisionRef (..)
    , TextRevisionSelector
    , prettyPrintTextRevisionRef
    )
import Docs.Tree (Node)
import Docs.TreeRevision
    ( TreeRevision
    , TreeRevisionHistory
    , TreeRevisionRef (..)
    , TreeRevisionSelector
    , prettyPrintTreeRevisionRef
    )

import Docs.Comment
    ( Comment
    , CommentID
    , CommentRef (CommentRef)
    , Message
    , prettyPrintCommentRef
    )
import Docs.FullDocument (FullDocument)
import Docs.MetaTree (TreeRevisionWithMetaData)
import Docs.Rendered (PDF, PDFBytes, Zip, ZipBytes)
import Docs.Revision
    ( RevisionRef (RevisionRef)
    , RevisionSelector
    , prettyPrintRevisionRef
    )
import Language.Ltml.Tree.Example.Fpo (fpoTree)
import Server.DTOs.Comments (Comments (Comments))
import Server.DTOs.CreateComment (CreateComment)
import qualified Server.DTOs.CreateComment as CreateComment
import Server.DTOs.CreateDocument (CreateDocument)
import qualified Server.DTOs.CreateDocument as CreateDocument
import Server.DTOs.CreateReply (CreateReply)
import qualified Server.DTOs.CreateReply as CreateReply
import Server.DTOs.CreateTextElement (CreateTextElement)
import qualified Server.DTOs.CreateTextElement as CreateTextElement
import Server.DTOs.CreateTextRevision (CreateTextRevision)
import qualified Server.DTOs.CreateTextRevision as CreateTextRevision
import Server.DTOs.Documents
    ( Documents (Documents)
    , DocumentsQuery (DocumentsQuery)
    )
import qualified Server.DTOs.Documents as Documents
import Server.Handlers.RenderHandlers
    ( RenderAPI
    , renderServer
    )
import UserManagement.Group (GroupID)

type DocsAPI =
    "docs"
        :> ( {-   -} PostDocument
                :<|> GetDocument
                :<|> GetDocuments
                :<|> PostTextElement
                :<|> PostTextRevision
                :<|> GetTextElementRevision
                :<|> GetTextElementRevisionPDF
                :<|> PostTreeRevision
                :<|> GetTreeRevision
                :<|> GetTreeRevisionFull
                :<|> GetTreeRevisionPDF
                :<|> GetTreeRevisionHTML
                :<|> GetTextHistory
                :<|> GetTreeHistory
                :<|> GetDocumentHistory
                :<|> PostComment
                :<|> GetComments
                :<|> ResolveComment
                :<|> PostReply
                :<|> GetDocumentRevision
                :<|> GetDocumentRevisionPDF
                :<|> GetDocumentRevisionHTML
                :<|> GetDocumentRevisionTree
                :<|> GetDocumentRevisionText
                :<|> GetDraftTextRevision
                :<|> PublishDraftTextRevision
                :<|> DiscardDraftTextRevision
                :<|> RenderAPI
           )

type PostDocument =
    Summary "Create a new document"
        :> Description "Create a new document with default content"
        :> Auth AuthMethod Auth.Token
        :> ReqBody '[JSON] CreateDocument
        :> Post '[JSON] (FullDocument (Rendered TextElementRevision))

type GetDocument =
    Summary "Get metadata for a document"
        :> Description "Obtain a documents metadat"
        :> Auth AuthMethod Auth.Token
        :> Capture "documentID" DocumentID
        :> Get '[JSON] Document

type GetDocuments =
    Summary "Get all documents"
        :> Description
            "Get all documents visible for the user. For super admins, this does not contain all visible documents, as a super admin can see all documents."
        :> Auth AuthMethod Auth.Token
        :> QueryParam "user" UserID
        :> QueryParam "group" GroupID
        :> Get '[JSON] Documents

type PostTextElement =
    Auth AuthMethod Auth.Token
        :> Capture "documentID" DocumentID
        :> "text"
        :> ReqBody '[JSON] CreateTextElement
        :> Post '[JSON] TextElement

type PostTextRevision =
    Auth AuthMethod Auth.Token
        :> Capture "documentID" DocumentID
        :> "text"
        :> Capture "textElementID" TextElementID
        :> "rev"
        :> QueryParam "isAutoSave" Bool
        :> ReqBody '[JSON] CreateTextRevision
        :> Post '[JSON] (Rendered ConflictStatus)

type GetTextElementRevision =
    Auth AuthMethod Auth.Token
        :> Capture "documentID" DocumentID
        :> "text"
        :> Capture "textElementID" TextElementID
        :> "rev"
        :> Capture "textRevision" TextRevisionSelector
        :> Get '[JSON] (Maybe (Rendered TextElementRevision))

type GetTextElementRevisionPDF =
    Auth AuthMethod Auth.Token
        :> Capture "documentID" DocumentID
        :> "text"
        :> Capture "textElementID" TextElementID
        :> "rev"
        :> Capture "textRevision" TextRevisionSelector
        :> "pdf"
        :> Get '[PDF] PDFBytes

type PostTreeRevision =
    Auth AuthMethod Auth.Token
        :> Capture "documentID" DocumentID
        :> "tree"
        :> ReqBody '[JSON] (Node TextElementID)
        :> Post '[JSON] (TreeRevisionWithMetaData TextElementID)

type GetTreeRevision =
    Auth AuthMethod Auth.Token
        :> Capture "documentID" DocumentID
        :> "tree"
        :> Capture "treeRevision" TreeRevisionSelector
        :> Get '[JSON] (Maybe (TreeRevisionWithMetaData TextElement))

type GetTreeRevisionFull =
    Auth AuthMethod Auth.Token
        :> Capture "documentID" DocumentID
        :> "tree"
        :> Capture "treeRevision" TreeRevisionSelector
        :> "full"
        :> Get '[JSON] (Maybe (TreeRevisionWithMetaData TextElementRevision))

type GetTreeRevisionPDF =
    Auth AuthMethod Auth.Token
        :> Capture "documentID" DocumentID
        :> "tree"
        :> Capture "treeRevision" TreeRevisionSelector
        :> "pdf"
        :> Get '[PDF] PDFBytes

type GetTreeRevisionHTML =
    Auth AuthMethod Auth.Token
        :> Capture "documentID" DocumentID
        :> "tree"
        :> Capture "treeRevision" TreeRevisionSelector
        :> "html"
        :> Get '[Zip] ZipBytes

type GetTextHistory =
    Auth AuthMethod Auth.Token
        :> Capture "documentID" DocumentID
        :> "text"
        :> Capture "textElementID" TextElementID
        :> "history"
        :> QueryParam "after" UTCTime
        :> QueryParam "before" UTCTime
        :> QueryParam "limit" Docs.Limit
        :> Get '[JSON] TextRevisionHistory

type GetTreeHistory =
    Auth AuthMethod Auth.Token
        :> Capture "documentID" DocumentID
        :> "tree"
        :> "history"
        :> QueryParam "before" UTCTime
        :> QueryParam "limit" Docs.Limit
        :> Get '[JSON] TreeRevisionHistory

type GetDocumentHistory =
    Auth AuthMethod Auth.Token
        :> Capture "documentID" DocumentID
        :> "history"
        :> QueryParam "before" UTCTime
        :> QueryParam "limit" Docs.Limit
        :> Get '[JSON] DocumentHistory

type PostComment =
    Auth AuthMethod Auth.Token
        :> Capture "documentID" DocumentID
        :> "text"
        :> Capture "textElementID" TextElementID
        :> "comments"
        :> ReqBody '[JSON] CreateComment
        :> Post '[JSON] Comment

type GetComments =
    Auth AuthMethod Auth.Token
        :> Capture "documentID" DocumentID
        :> "text"
        :> Capture "textElementID" TextElementID
        :> "comments"
        :> Get '[JSON] Comments

-- | jaja, das ist kein cleanes rest design,
--   aber das ist mir langsam auch wirklich scheiß egal.
type ResolveComment =
    Auth AuthMethod Auth.Token
        :> Capture "documentID" DocumentID
        :> "text"
        :> Capture "textElementID" TextElementID
        :> "comments"
        :> Capture "commentID" CommentID
        :> "resolve"
        :> Post '[JSON] ()

type PostReply =
    Auth AuthMethod Auth.Token
        :> Capture "documentID" DocumentID
        :> "text"
        :> Capture "textElementID" TextElementID
        :> "comments"
        :> Capture "commentID" CommentID
        :> "replies"
        :> ReqBody '[JSON] CreateReply
        :> Post '[JSON] Message

type GetDocumentRevision =
    Auth AuthMethod Auth.Token
        :> Capture "documentID" DocumentID
        :> "rev"
        :> Capture "revision" RevisionSelector
        :> Get '[JSON] (FullDocument TextElementRevision)

type GetDocumentRevisionPDF =
    Auth AuthMethod Auth.Token
        :> Capture "documentID" DocumentID
        :> "rev"
        :> Capture "revision" RevisionSelector
        :> "pdf"
        :> Get '[PDF] PDFBytes

type GetDocumentRevisionHTML =
    Auth AuthMethod Auth.Token
        :> Capture "documentID" DocumentID
        :> "rev"
        :> Capture "revision" RevisionSelector
        :> "html"
        :> Get '[Zip] ZipBytes

type GetDocumentRevisionTree =
    Auth AuthMethod Auth.Token
        :> Capture "documentID" DocumentID
        :> "rev"
        :> Capture "revision" RevisionSelector
        :> "tree"
        :> Get '[JSON] (Maybe (TreeRevision TextElement))

type GetDocumentRevisionText =
    Auth AuthMethod Auth.Token
        :> Capture "documentID" DocumentID
        :> "rev"
        :> Capture "revision" RevisionSelector
        :> "text"
        :> Capture "textElementID" TextElementID
        :> Get '[JSON] (Maybe TextElementRevision)

type GetDraftTextRevision =
    Summary "Get draft text revision"
        :> Description
            "Retrieve the user's draft text revision for a specific text element, if it exists"
        :> Auth AuthMethod Auth.Token
        :> Capture "documentID" DocumentID
        :> "text"
        :> Capture "textElementID" TextElementID
        :> "draft"
        :> Get '[JSON] (Maybe (Rendered DraftRevision))

type PublishDraftTextRevision =
    Summary "Publish draft text revision"
        :> Description
            "Publish the user's draft text revision to the main revision tree, potentially creating conflicts"
        :> Auth AuthMethod Auth.Token
        :> Capture "documentID" DocumentID
        :> "text"
        :> Capture "textElementID" TextElementID
        :> "draft"
        :> "publish"
        :> Post '[JSON] (Rendered ConflictStatus)

type DiscardDraftTextRevision =
    Summary "Discard draft text revision"
        :> Description
            "Delete the user's draft text revision, discarding all unsaved changes"
        :> Auth AuthMethod Auth.Token
        :> Capture "documentID" DocumentID
        :> "text"
        :> Capture "textElementID" TextElementID
        :> "draft"
        :> Delete '[JSON] ()

docsServer :: Server DocsAPI
docsServer :: Server DocsAPI
docsServer =
    {-    -} AuthResult Token
-> CreateDocument
-> Handler (FullDocument (Rendered TextElementRevision))
postDocumentHandler
        (AuthResult Token
 -> CreateDocument
 -> Handler (FullDocument (Rendered TextElementRevision)))
-> ((AuthResult Token -> DocumentID -> Handler Document)
    :<|> ((AuthResult Token
           -> Maybe UserID -> Maybe GroupID -> Handler Documents)
          :<|> ((AuthResult Token
                 -> DocumentID -> CreateTextElement -> Handler TextElement)
                :<|> ((AuthResult Token
                       -> DocumentID
                       -> TextElementID
                       -> Maybe Bool
                       -> CreateTextRevision
                       -> Handler (Rendered ConflictStatus))
                      :<|> ((AuthResult Token
                             -> DocumentID
                             -> TextElementID
                             -> TextRevisionSelector
                             -> Handler (Maybe (Rendered TextElementRevision)))
                            :<|> ((AuthResult Token
                                   -> DocumentID
                                   -> TextElementID
                                   -> TextRevisionSelector
                                   -> Handler PDFBytes)
                                  :<|> ((AuthResult Token
                                         -> DocumentID
                                         -> Node TextElementID
                                         -> Handler (TreeRevisionWithMetaData TextElementID))
                                        :<|> ((AuthResult Token
                                               -> DocumentID
                                               -> TreeRevisionSelector
                                               -> Handler
                                                    (Maybe (TreeRevisionWithMetaData TextElement)))
                                              :<|> ((AuthResult Token
                                                     -> DocumentID
                                                     -> TreeRevisionSelector
                                                     -> Handler
                                                          (Maybe
                                                             (TreeRevisionWithMetaData
                                                                TextElementRevision)))
                                                    :<|> ((AuthResult Token
                                                           -> DocumentID
                                                           -> TreeRevisionSelector
                                                           -> Handler PDFBytes)
                                                          :<|> ((AuthResult Token
                                                                 -> DocumentID
                                                                 -> TreeRevisionSelector
                                                                 -> Handler ZipBytes)
                                                                :<|> ((AuthResult Token
                                                                       -> DocumentID
                                                                       -> TextElementID
                                                                       -> Maybe UTCTime
                                                                       -> Maybe UTCTime
                                                                       -> Maybe GroupID
                                                                       -> Handler
                                                                            TextRevisionHistory)
                                                                      :<|> ((AuthResult Token
                                                                             -> DocumentID
                                                                             -> Maybe UTCTime
                                                                             -> Maybe GroupID
                                                                             -> Handler
                                                                                  TreeRevisionHistory)
                                                                            :<|> ((AuthResult Token
                                                                                   -> DocumentID
                                                                                   -> Maybe UTCTime
                                                                                   -> Maybe GroupID
                                                                                   -> Handler
                                                                                        DocumentHistory)
                                                                                  :<|> ((AuthResult
                                                                                           Token
                                                                                         -> DocumentID
                                                                                         -> TextElementID
                                                                                         -> CreateComment
                                                                                         -> Handler
                                                                                              Comment)
                                                                                        :<|> ((AuthResult
                                                                                                 Token
                                                                                               -> DocumentID
                                                                                               -> TextElementID
                                                                                               -> Handler
                                                                                                    Comments)
                                                                                              :<|> ((AuthResult
                                                                                                       Token
                                                                                                     -> DocumentID
                                                                                                     -> TextElementID
                                                                                                     -> CommentID
                                                                                                     -> Handler
                                                                                                          ())
                                                                                                    :<|> ((AuthResult
                                                                                                             Token
                                                                                                           -> DocumentID
                                                                                                           -> TextElementID
                                                                                                           -> CommentID
                                                                                                           -> CreateReply
                                                                                                           -> Handler
                                                                                                                Message)
                                                                                                          :<|> ((AuthResult
                                                                                                                   Token
                                                                                                                 -> DocumentID
                                                                                                                 -> RevisionSelector
                                                                                                                 -> Handler
                                                                                                                      (FullDocument
                                                                                                                         TextElementRevision))
                                                                                                                :<|> ((AuthResult
                                                                                                                         Token
                                                                                                                       -> DocumentID
                                                                                                                       -> RevisionSelector
                                                                                                                       -> Handler
                                                                                                                            PDFBytes)
                                                                                                                      :<|> ((AuthResult
                                                                                                                               Token
                                                                                                                             -> DocumentID
                                                                                                                             -> RevisionSelector
                                                                                                                             -> Handler
                                                                                                                                  ZipBytes)
                                                                                                                            :<|> ((AuthResult
                                                                                                                                     Token
                                                                                                                                   -> DocumentID
                                                                                                                                   -> RevisionSelector
                                                                                                                                   -> Handler
                                                                                                                                        (Maybe
                                                                                                                                           (TreeRevision
                                                                                                                                              TextElement)))
                                                                                                                                  :<|> ((AuthResult
                                                                                                                                           Token
                                                                                                                                         -> DocumentID
                                                                                                                                         -> RevisionSelector
                                                                                                                                         -> TextElementID
                                                                                                                                         -> Handler
                                                                                                                                              (Maybe
                                                                                                                                                 TextElementRevision))
                                                                                                                                        :<|> ((AuthResult
                                                                                                                                                 Token
                                                                                                                                               -> DocumentID
                                                                                                                                               -> TextElementID
                                                                                                                                               -> Handler
                                                                                                                                                    (Maybe
                                                                                                                                                       (Rendered
                                                                                                                                                          DraftRevision)))
                                                                                                                                              :<|> ((AuthResult
                                                                                                                                                       Token
                                                                                                                                                     -> DocumentID
                                                                                                                                                     -> TextElementID
                                                                                                                                                     -> Handler
                                                                                                                                                          (Rendered
                                                                                                                                                             ConflictStatus))
                                                                                                                                                    :<|> ((AuthResult
                                                                                                                                                             Token
                                                                                                                                                           -> DocumentID
                                                                                                                                                           -> TextElementID
                                                                                                                                                           -> Handler
                                                                                                                                                                ())
                                                                                                                                                          :<|> ((AuthResult
                                                                                                                                                                   Token
                                                                                                                                                                 -> Text
                                                                                                                                                                 -> Handler
                                                                                                                                                                      DocByteString)
                                                                                                                                                                :<|> (AuthResult
                                                                                                                                                                        Token
                                                                                                                                                                      -> Text
                                                                                                                                                                      -> Handler
                                                                                                                                                                           PDFByteString))))))))))))))))))))))))))))
-> (AuthResult Token
    -> CreateDocument
    -> Handler (FullDocument (Rendered TextElementRevision)))
   :<|> ((AuthResult Token -> DocumentID -> Handler Document)
         :<|> ((AuthResult Token
                -> Maybe UserID -> Maybe GroupID -> Handler Documents)
               :<|> ((AuthResult Token
                      -> DocumentID -> CreateTextElement -> Handler TextElement)
                     :<|> ((AuthResult Token
                            -> DocumentID
                            -> TextElementID
                            -> Maybe Bool
                            -> CreateTextRevision
                            -> Handler (Rendered ConflictStatus))
                           :<|> ((AuthResult Token
                                  -> DocumentID
                                  -> TextElementID
                                  -> TextRevisionSelector
                                  -> Handler (Maybe (Rendered TextElementRevision)))
                                 :<|> ((AuthResult Token
                                        -> DocumentID
                                        -> TextElementID
                                        -> TextRevisionSelector
                                        -> Handler PDFBytes)
                                       :<|> ((AuthResult Token
                                              -> DocumentID
                                              -> Node TextElementID
                                              -> Handler (TreeRevisionWithMetaData TextElementID))
                                             :<|> ((AuthResult Token
                                                    -> DocumentID
                                                    -> TreeRevisionSelector
                                                    -> Handler
                                                         (Maybe
                                                            (TreeRevisionWithMetaData TextElement)))
                                                   :<|> ((AuthResult Token
                                                          -> DocumentID
                                                          -> TreeRevisionSelector
                                                          -> Handler
                                                               (Maybe
                                                                  (TreeRevisionWithMetaData
                                                                     TextElementRevision)))
                                                         :<|> ((AuthResult Token
                                                                -> DocumentID
                                                                -> TreeRevisionSelector
                                                                -> Handler PDFBytes)
                                                               :<|> ((AuthResult Token
                                                                      -> DocumentID
                                                                      -> TreeRevisionSelector
                                                                      -> Handler ZipBytes)
                                                                     :<|> ((AuthResult Token
                                                                            -> DocumentID
                                                                            -> TextElementID
                                                                            -> Maybe UTCTime
                                                                            -> Maybe UTCTime
                                                                            -> Maybe GroupID
                                                                            -> Handler
                                                                                 TextRevisionHistory)
                                                                           :<|> ((AuthResult Token
                                                                                  -> DocumentID
                                                                                  -> Maybe UTCTime
                                                                                  -> Maybe GroupID
                                                                                  -> Handler
                                                                                       TreeRevisionHistory)
                                                                                 :<|> ((AuthResult
                                                                                          Token
                                                                                        -> DocumentID
                                                                                        -> Maybe
                                                                                             UTCTime
                                                                                        -> Maybe
                                                                                             GroupID
                                                                                        -> Handler
                                                                                             DocumentHistory)
                                                                                       :<|> ((AuthResult
                                                                                                Token
                                                                                              -> DocumentID
                                                                                              -> TextElementID
                                                                                              -> CreateComment
                                                                                              -> Handler
                                                                                                   Comment)
                                                                                             :<|> ((AuthResult
                                                                                                      Token
                                                                                                    -> DocumentID
                                                                                                    -> TextElementID
                                                                                                    -> Handler
                                                                                                         Comments)
                                                                                                   :<|> ((AuthResult
                                                                                                            Token
                                                                                                          -> DocumentID
                                                                                                          -> TextElementID
                                                                                                          -> CommentID
                                                                                                          -> Handler
                                                                                                               ())
                                                                                                         :<|> ((AuthResult
                                                                                                                  Token
                                                                                                                -> DocumentID
                                                                                                                -> TextElementID
                                                                                                                -> CommentID
                                                                                                                -> CreateReply
                                                                                                                -> Handler
                                                                                                                     Message)
                                                                                                               :<|> ((AuthResult
                                                                                                                        Token
                                                                                                                      -> DocumentID
                                                                                                                      -> RevisionSelector
                                                                                                                      -> Handler
                                                                                                                           (FullDocument
                                                                                                                              TextElementRevision))
                                                                                                                     :<|> ((AuthResult
                                                                                                                              Token
                                                                                                                            -> DocumentID
                                                                                                                            -> RevisionSelector
                                                                                                                            -> Handler
                                                                                                                                 PDFBytes)
                                                                                                                           :<|> ((AuthResult
                                                                                                                                    Token
                                                                                                                                  -> DocumentID
                                                                                                                                  -> RevisionSelector
                                                                                                                                  -> Handler
                                                                                                                                       ZipBytes)
                                                                                                                                 :<|> ((AuthResult
                                                                                                                                          Token
                                                                                                                                        -> DocumentID
                                                                                                                                        -> RevisionSelector
                                                                                                                                        -> Handler
                                                                                                                                             (Maybe
                                                                                                                                                (TreeRevision
                                                                                                                                                   TextElement)))
                                                                                                                                       :<|> ((AuthResult
                                                                                                                                                Token
                                                                                                                                              -> DocumentID
                                                                                                                                              -> RevisionSelector
                                                                                                                                              -> TextElementID
                                                                                                                                              -> Handler
                                                                                                                                                   (Maybe
                                                                                                                                                      TextElementRevision))
                                                                                                                                             :<|> ((AuthResult
                                                                                                                                                      Token
                                                                                                                                                    -> DocumentID
                                                                                                                                                    -> TextElementID
                                                                                                                                                    -> Handler
                                                                                                                                                         (Maybe
                                                                                                                                                            (Rendered
                                                                                                                                                               DraftRevision)))
                                                                                                                                                   :<|> ((AuthResult
                                                                                                                                                            Token
                                                                                                                                                          -> DocumentID
                                                                                                                                                          -> TextElementID
                                                                                                                                                          -> Handler
                                                                                                                                                               (Rendered
                                                                                                                                                                  ConflictStatus))
                                                                                                                                                         :<|> ((AuthResult
                                                                                                                                                                  Token
                                                                                                                                                                -> DocumentID
                                                                                                                                                                -> TextElementID
                                                                                                                                                                -> Handler
                                                                                                                                                                     ())
                                                                                                                                                               :<|> ((AuthResult
                                                                                                                                                                        Token
                                                                                                                                                                      -> Text
                                                                                                                                                                      -> Handler
                                                                                                                                                                           DocByteString)
                                                                                                                                                                     :<|> (AuthResult
                                                                                                                                                                             Token
                                                                                                                                                                           -> Text
                                                                                                                                                                           -> Handler
                                                                                                                                                                                PDFByteString))))))))))))))))))))))))))))
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token -> DocumentID -> Handler Document
getDocumentHandler
        (AuthResult Token -> DocumentID -> Handler Document)
-> ((AuthResult Token
     -> Maybe UserID -> Maybe GroupID -> Handler Documents)
    :<|> ((AuthResult Token
           -> DocumentID -> CreateTextElement -> Handler TextElement)
          :<|> ((AuthResult Token
                 -> DocumentID
                 -> TextElementID
                 -> Maybe Bool
                 -> CreateTextRevision
                 -> Handler (Rendered ConflictStatus))
                :<|> ((AuthResult Token
                       -> DocumentID
                       -> TextElementID
                       -> TextRevisionSelector
                       -> Handler (Maybe (Rendered TextElementRevision)))
                      :<|> ((AuthResult Token
                             -> DocumentID
                             -> TextElementID
                             -> TextRevisionSelector
                             -> Handler PDFBytes)
                            :<|> ((AuthResult Token
                                   -> DocumentID
                                   -> Node TextElementID
                                   -> Handler (TreeRevisionWithMetaData TextElementID))
                                  :<|> ((AuthResult Token
                                         -> DocumentID
                                         -> TreeRevisionSelector
                                         -> Handler (Maybe (TreeRevisionWithMetaData TextElement)))
                                        :<|> ((AuthResult Token
                                               -> DocumentID
                                               -> TreeRevisionSelector
                                               -> Handler
                                                    (Maybe
                                                       (TreeRevisionWithMetaData
                                                          TextElementRevision)))
                                              :<|> ((AuthResult Token
                                                     -> DocumentID
                                                     -> TreeRevisionSelector
                                                     -> Handler PDFBytes)
                                                    :<|> ((AuthResult Token
                                                           -> DocumentID
                                                           -> TreeRevisionSelector
                                                           -> Handler ZipBytes)
                                                          :<|> ((AuthResult Token
                                                                 -> DocumentID
                                                                 -> TextElementID
                                                                 -> Maybe UTCTime
                                                                 -> Maybe UTCTime
                                                                 -> Maybe GroupID
                                                                 -> Handler TextRevisionHistory)
                                                                :<|> ((AuthResult Token
                                                                       -> DocumentID
                                                                       -> Maybe UTCTime
                                                                       -> Maybe GroupID
                                                                       -> Handler
                                                                            TreeRevisionHistory)
                                                                      :<|> ((AuthResult Token
                                                                             -> DocumentID
                                                                             -> Maybe UTCTime
                                                                             -> Maybe GroupID
                                                                             -> Handler
                                                                                  DocumentHistory)
                                                                            :<|> ((AuthResult Token
                                                                                   -> DocumentID
                                                                                   -> TextElementID
                                                                                   -> CreateComment
                                                                                   -> Handler
                                                                                        Comment)
                                                                                  :<|> ((AuthResult
                                                                                           Token
                                                                                         -> DocumentID
                                                                                         -> TextElementID
                                                                                         -> Handler
                                                                                              Comments)
                                                                                        :<|> ((AuthResult
                                                                                                 Token
                                                                                               -> DocumentID
                                                                                               -> TextElementID
                                                                                               -> CommentID
                                                                                               -> Handler
                                                                                                    ())
                                                                                              :<|> ((AuthResult
                                                                                                       Token
                                                                                                     -> DocumentID
                                                                                                     -> TextElementID
                                                                                                     -> CommentID
                                                                                                     -> CreateReply
                                                                                                     -> Handler
                                                                                                          Message)
                                                                                                    :<|> ((AuthResult
                                                                                                             Token
                                                                                                           -> DocumentID
                                                                                                           -> RevisionSelector
                                                                                                           -> Handler
                                                                                                                (FullDocument
                                                                                                                   TextElementRevision))
                                                                                                          :<|> ((AuthResult
                                                                                                                   Token
                                                                                                                 -> DocumentID
                                                                                                                 -> RevisionSelector
                                                                                                                 -> Handler
                                                                                                                      PDFBytes)
                                                                                                                :<|> ((AuthResult
                                                                                                                         Token
                                                                                                                       -> DocumentID
                                                                                                                       -> RevisionSelector
                                                                                                                       -> Handler
                                                                                                                            ZipBytes)
                                                                                                                      :<|> ((AuthResult
                                                                                                                               Token
                                                                                                                             -> DocumentID
                                                                                                                             -> RevisionSelector
                                                                                                                             -> Handler
                                                                                                                                  (Maybe
                                                                                                                                     (TreeRevision
                                                                                                                                        TextElement)))
                                                                                                                            :<|> ((AuthResult
                                                                                                                                     Token
                                                                                                                                   -> DocumentID
                                                                                                                                   -> RevisionSelector
                                                                                                                                   -> TextElementID
                                                                                                                                   -> Handler
                                                                                                                                        (Maybe
                                                                                                                                           TextElementRevision))
                                                                                                                                  :<|> ((AuthResult
                                                                                                                                           Token
                                                                                                                                         -> DocumentID
                                                                                                                                         -> TextElementID
                                                                                                                                         -> Handler
                                                                                                                                              (Maybe
                                                                                                                                                 (Rendered
                                                                                                                                                    DraftRevision)))
                                                                                                                                        :<|> ((AuthResult
                                                                                                                                                 Token
                                                                                                                                               -> DocumentID
                                                                                                                                               -> TextElementID
                                                                                                                                               -> Handler
                                                                                                                                                    (Rendered
                                                                                                                                                       ConflictStatus))
                                                                                                                                              :<|> ((AuthResult
                                                                                                                                                       Token
                                                                                                                                                     -> DocumentID
                                                                                                                                                     -> TextElementID
                                                                                                                                                     -> Handler
                                                                                                                                                          ())
                                                                                                                                                    :<|> ((AuthResult
                                                                                                                                                             Token
                                                                                                                                                           -> Text
                                                                                                                                                           -> Handler
                                                                                                                                                                DocByteString)
                                                                                                                                                          :<|> (AuthResult
                                                                                                                                                                  Token
                                                                                                                                                                -> Text
                                                                                                                                                                -> Handler
                                                                                                                                                                     PDFByteString)))))))))))))))))))))))))))
-> (AuthResult Token -> DocumentID -> Handler Document)
   :<|> ((AuthResult Token
          -> Maybe UserID -> Maybe GroupID -> Handler Documents)
         :<|> ((AuthResult Token
                -> DocumentID -> CreateTextElement -> Handler TextElement)
               :<|> ((AuthResult Token
                      -> DocumentID
                      -> TextElementID
                      -> Maybe Bool
                      -> CreateTextRevision
                      -> Handler (Rendered ConflictStatus))
                     :<|> ((AuthResult Token
                            -> DocumentID
                            -> TextElementID
                            -> TextRevisionSelector
                            -> Handler (Maybe (Rendered TextElementRevision)))
                           :<|> ((AuthResult Token
                                  -> DocumentID
                                  -> TextElementID
                                  -> TextRevisionSelector
                                  -> Handler PDFBytes)
                                 :<|> ((AuthResult Token
                                        -> DocumentID
                                        -> Node TextElementID
                                        -> Handler (TreeRevisionWithMetaData TextElementID))
                                       :<|> ((AuthResult Token
                                              -> DocumentID
                                              -> TreeRevisionSelector
                                              -> Handler
                                                   (Maybe (TreeRevisionWithMetaData TextElement)))
                                             :<|> ((AuthResult Token
                                                    -> DocumentID
                                                    -> TreeRevisionSelector
                                                    -> Handler
                                                         (Maybe
                                                            (TreeRevisionWithMetaData
                                                               TextElementRevision)))
                                                   :<|> ((AuthResult Token
                                                          -> DocumentID
                                                          -> TreeRevisionSelector
                                                          -> Handler PDFBytes)
                                                         :<|> ((AuthResult Token
                                                                -> DocumentID
                                                                -> TreeRevisionSelector
                                                                -> Handler ZipBytes)
                                                               :<|> ((AuthResult Token
                                                                      -> DocumentID
                                                                      -> TextElementID
                                                                      -> Maybe UTCTime
                                                                      -> Maybe UTCTime
                                                                      -> Maybe GroupID
                                                                      -> Handler
                                                                           TextRevisionHistory)
                                                                     :<|> ((AuthResult Token
                                                                            -> DocumentID
                                                                            -> Maybe UTCTime
                                                                            -> Maybe GroupID
                                                                            -> Handler
                                                                                 TreeRevisionHistory)
                                                                           :<|> ((AuthResult Token
                                                                                  -> DocumentID
                                                                                  -> Maybe UTCTime
                                                                                  -> Maybe GroupID
                                                                                  -> Handler
                                                                                       DocumentHistory)
                                                                                 :<|> ((AuthResult
                                                                                          Token
                                                                                        -> DocumentID
                                                                                        -> TextElementID
                                                                                        -> CreateComment
                                                                                        -> Handler
                                                                                             Comment)
                                                                                       :<|> ((AuthResult
                                                                                                Token
                                                                                              -> DocumentID
                                                                                              -> TextElementID
                                                                                              -> Handler
                                                                                                   Comments)
                                                                                             :<|> ((AuthResult
                                                                                                      Token
                                                                                                    -> DocumentID
                                                                                                    -> TextElementID
                                                                                                    -> CommentID
                                                                                                    -> Handler
                                                                                                         ())
                                                                                                   :<|> ((AuthResult
                                                                                                            Token
                                                                                                          -> DocumentID
                                                                                                          -> TextElementID
                                                                                                          -> CommentID
                                                                                                          -> CreateReply
                                                                                                          -> Handler
                                                                                                               Message)
                                                                                                         :<|> ((AuthResult
                                                                                                                  Token
                                                                                                                -> DocumentID
                                                                                                                -> RevisionSelector
                                                                                                                -> Handler
                                                                                                                     (FullDocument
                                                                                                                        TextElementRevision))
                                                                                                               :<|> ((AuthResult
                                                                                                                        Token
                                                                                                                      -> DocumentID
                                                                                                                      -> RevisionSelector
                                                                                                                      -> Handler
                                                                                                                           PDFBytes)
                                                                                                                     :<|> ((AuthResult
                                                                                                                              Token
                                                                                                                            -> DocumentID
                                                                                                                            -> RevisionSelector
                                                                                                                            -> Handler
                                                                                                                                 ZipBytes)
                                                                                                                           :<|> ((AuthResult
                                                                                                                                    Token
                                                                                                                                  -> DocumentID
                                                                                                                                  -> RevisionSelector
                                                                                                                                  -> Handler
                                                                                                                                       (Maybe
                                                                                                                                          (TreeRevision
                                                                                                                                             TextElement)))
                                                                                                                                 :<|> ((AuthResult
                                                                                                                                          Token
                                                                                                                                        -> DocumentID
                                                                                                                                        -> RevisionSelector
                                                                                                                                        -> TextElementID
                                                                                                                                        -> Handler
                                                                                                                                             (Maybe
                                                                                                                                                TextElementRevision))
                                                                                                                                       :<|> ((AuthResult
                                                                                                                                                Token
                                                                                                                                              -> DocumentID
                                                                                                                                              -> TextElementID
                                                                                                                                              -> Handler
                                                                                                                                                   (Maybe
                                                                                                                                                      (Rendered
                                                                                                                                                         DraftRevision)))
                                                                                                                                             :<|> ((AuthResult
                                                                                                                                                      Token
                                                                                                                                                    -> DocumentID
                                                                                                                                                    -> TextElementID
                                                                                                                                                    -> Handler
                                                                                                                                                         (Rendered
                                                                                                                                                            ConflictStatus))
                                                                                                                                                   :<|> ((AuthResult
                                                                                                                                                            Token
                                                                                                                                                          -> DocumentID
                                                                                                                                                          -> TextElementID
                                                                                                                                                          -> Handler
                                                                                                                                                               ())
                                                                                                                                                         :<|> ((AuthResult
                                                                                                                                                                  Token
                                                                                                                                                                -> Text
                                                                                                                                                                -> Handler
                                                                                                                                                                     DocByteString)
                                                                                                                                                               :<|> (AuthResult
                                                                                                                                                                       Token
                                                                                                                                                                     -> Text
                                                                                                                                                                     -> Handler
                                                                                                                                                                          PDFByteString)))))))))))))))))))))))))))
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token
-> Maybe UserID -> Maybe GroupID -> Handler Documents
getDocumentsHandler
        (AuthResult Token
 -> Maybe UserID -> Maybe GroupID -> Handler Documents)
-> ((AuthResult Token
     -> DocumentID -> CreateTextElement -> Handler TextElement)
    :<|> ((AuthResult Token
           -> DocumentID
           -> TextElementID
           -> Maybe Bool
           -> CreateTextRevision
           -> Handler (Rendered ConflictStatus))
          :<|> ((AuthResult Token
                 -> DocumentID
                 -> TextElementID
                 -> TextRevisionSelector
                 -> Handler (Maybe (Rendered TextElementRevision)))
                :<|> ((AuthResult Token
                       -> DocumentID
                       -> TextElementID
                       -> TextRevisionSelector
                       -> Handler PDFBytes)
                      :<|> ((AuthResult Token
                             -> DocumentID
                             -> Node TextElementID
                             -> Handler (TreeRevisionWithMetaData TextElementID))
                            :<|> ((AuthResult Token
                                   -> DocumentID
                                   -> TreeRevisionSelector
                                   -> Handler (Maybe (TreeRevisionWithMetaData TextElement)))
                                  :<|> ((AuthResult Token
                                         -> DocumentID
                                         -> TreeRevisionSelector
                                         -> Handler
                                              (Maybe
                                                 (TreeRevisionWithMetaData TextElementRevision)))
                                        :<|> ((AuthResult Token
                                               -> DocumentID
                                               -> TreeRevisionSelector
                                               -> Handler PDFBytes)
                                              :<|> ((AuthResult Token
                                                     -> DocumentID
                                                     -> TreeRevisionSelector
                                                     -> Handler ZipBytes)
                                                    :<|> ((AuthResult Token
                                                           -> DocumentID
                                                           -> TextElementID
                                                           -> Maybe UTCTime
                                                           -> Maybe UTCTime
                                                           -> Maybe GroupID
                                                           -> Handler TextRevisionHistory)
                                                          :<|> ((AuthResult Token
                                                                 -> DocumentID
                                                                 -> Maybe UTCTime
                                                                 -> Maybe GroupID
                                                                 -> Handler TreeRevisionHistory)
                                                                :<|> ((AuthResult Token
                                                                       -> DocumentID
                                                                       -> Maybe UTCTime
                                                                       -> Maybe GroupID
                                                                       -> Handler DocumentHistory)
                                                                      :<|> ((AuthResult Token
                                                                             -> DocumentID
                                                                             -> TextElementID
                                                                             -> CreateComment
                                                                             -> Handler Comment)
                                                                            :<|> ((AuthResult Token
                                                                                   -> DocumentID
                                                                                   -> TextElementID
                                                                                   -> Handler
                                                                                        Comments)
                                                                                  :<|> ((AuthResult
                                                                                           Token
                                                                                         -> DocumentID
                                                                                         -> TextElementID
                                                                                         -> CommentID
                                                                                         -> Handler
                                                                                              ())
                                                                                        :<|> ((AuthResult
                                                                                                 Token
                                                                                               -> DocumentID
                                                                                               -> TextElementID
                                                                                               -> CommentID
                                                                                               -> CreateReply
                                                                                               -> Handler
                                                                                                    Message)
                                                                                              :<|> ((AuthResult
                                                                                                       Token
                                                                                                     -> DocumentID
                                                                                                     -> RevisionSelector
                                                                                                     -> Handler
                                                                                                          (FullDocument
                                                                                                             TextElementRevision))
                                                                                                    :<|> ((AuthResult
                                                                                                             Token
                                                                                                           -> DocumentID
                                                                                                           -> RevisionSelector
                                                                                                           -> Handler
                                                                                                                PDFBytes)
                                                                                                          :<|> ((AuthResult
                                                                                                                   Token
                                                                                                                 -> DocumentID
                                                                                                                 -> RevisionSelector
                                                                                                                 -> Handler
                                                                                                                      ZipBytes)
                                                                                                                :<|> ((AuthResult
                                                                                                                         Token
                                                                                                                       -> DocumentID
                                                                                                                       -> RevisionSelector
                                                                                                                       -> Handler
                                                                                                                            (Maybe
                                                                                                                               (TreeRevision
                                                                                                                                  TextElement)))
                                                                                                                      :<|> ((AuthResult
                                                                                                                               Token
                                                                                                                             -> DocumentID
                                                                                                                             -> RevisionSelector
                                                                                                                             -> TextElementID
                                                                                                                             -> Handler
                                                                                                                                  (Maybe
                                                                                                                                     TextElementRevision))
                                                                                                                            :<|> ((AuthResult
                                                                                                                                     Token
                                                                                                                                   -> DocumentID
                                                                                                                                   -> TextElementID
                                                                                                                                   -> Handler
                                                                                                                                        (Maybe
                                                                                                                                           (Rendered
                                                                                                                                              DraftRevision)))
                                                                                                                                  :<|> ((AuthResult
                                                                                                                                           Token
                                                                                                                                         -> DocumentID
                                                                                                                                         -> TextElementID
                                                                                                                                         -> Handler
                                                                                                                                              (Rendered
                                                                                                                                                 ConflictStatus))
                                                                                                                                        :<|> ((AuthResult
                                                                                                                                                 Token
                                                                                                                                               -> DocumentID
                                                                                                                                               -> TextElementID
                                                                                                                                               -> Handler
                                                                                                                                                    ())
                                                                                                                                              :<|> ((AuthResult
                                                                                                                                                       Token
                                                                                                                                                     -> Text
                                                                                                                                                     -> Handler
                                                                                                                                                          DocByteString)
                                                                                                                                                    :<|> (AuthResult
                                                                                                                                                            Token
                                                                                                                                                          -> Text
                                                                                                                                                          -> Handler
                                                                                                                                                               PDFByteString))))))))))))))))))))))))))
-> (AuthResult Token
    -> Maybe UserID -> Maybe GroupID -> Handler Documents)
   :<|> ((AuthResult Token
          -> DocumentID -> CreateTextElement -> Handler TextElement)
         :<|> ((AuthResult Token
                -> DocumentID
                -> TextElementID
                -> Maybe Bool
                -> CreateTextRevision
                -> Handler (Rendered ConflictStatus))
               :<|> ((AuthResult Token
                      -> DocumentID
                      -> TextElementID
                      -> TextRevisionSelector
                      -> Handler (Maybe (Rendered TextElementRevision)))
                     :<|> ((AuthResult Token
                            -> DocumentID
                            -> TextElementID
                            -> TextRevisionSelector
                            -> Handler PDFBytes)
                           :<|> ((AuthResult Token
                                  -> DocumentID
                                  -> Node TextElementID
                                  -> Handler (TreeRevisionWithMetaData TextElementID))
                                 :<|> ((AuthResult Token
                                        -> DocumentID
                                        -> TreeRevisionSelector
                                        -> Handler (Maybe (TreeRevisionWithMetaData TextElement)))
                                       :<|> ((AuthResult Token
                                              -> DocumentID
                                              -> TreeRevisionSelector
                                              -> Handler
                                                   (Maybe
                                                      (TreeRevisionWithMetaData
                                                         TextElementRevision)))
                                             :<|> ((AuthResult Token
                                                    -> DocumentID
                                                    -> TreeRevisionSelector
                                                    -> Handler PDFBytes)
                                                   :<|> ((AuthResult Token
                                                          -> DocumentID
                                                          -> TreeRevisionSelector
                                                          -> Handler ZipBytes)
                                                         :<|> ((AuthResult Token
                                                                -> DocumentID
                                                                -> TextElementID
                                                                -> Maybe UTCTime
                                                                -> Maybe UTCTime
                                                                -> Maybe GroupID
                                                                -> Handler TextRevisionHistory)
                                                               :<|> ((AuthResult Token
                                                                      -> DocumentID
                                                                      -> Maybe UTCTime
                                                                      -> Maybe GroupID
                                                                      -> Handler
                                                                           TreeRevisionHistory)
                                                                     :<|> ((AuthResult Token
                                                                            -> DocumentID
                                                                            -> Maybe UTCTime
                                                                            -> Maybe GroupID
                                                                            -> Handler
                                                                                 DocumentHistory)
                                                                           :<|> ((AuthResult Token
                                                                                  -> DocumentID
                                                                                  -> TextElementID
                                                                                  -> CreateComment
                                                                                  -> Handler
                                                                                       Comment)
                                                                                 :<|> ((AuthResult
                                                                                          Token
                                                                                        -> DocumentID
                                                                                        -> TextElementID
                                                                                        -> Handler
                                                                                             Comments)
                                                                                       :<|> ((AuthResult
                                                                                                Token
                                                                                              -> DocumentID
                                                                                              -> TextElementID
                                                                                              -> CommentID
                                                                                              -> Handler
                                                                                                   ())
                                                                                             :<|> ((AuthResult
                                                                                                      Token
                                                                                                    -> DocumentID
                                                                                                    -> TextElementID
                                                                                                    -> CommentID
                                                                                                    -> CreateReply
                                                                                                    -> Handler
                                                                                                         Message)
                                                                                                   :<|> ((AuthResult
                                                                                                            Token
                                                                                                          -> DocumentID
                                                                                                          -> RevisionSelector
                                                                                                          -> Handler
                                                                                                               (FullDocument
                                                                                                                  TextElementRevision))
                                                                                                         :<|> ((AuthResult
                                                                                                                  Token
                                                                                                                -> DocumentID
                                                                                                                -> RevisionSelector
                                                                                                                -> Handler
                                                                                                                     PDFBytes)
                                                                                                               :<|> ((AuthResult
                                                                                                                        Token
                                                                                                                      -> DocumentID
                                                                                                                      -> RevisionSelector
                                                                                                                      -> Handler
                                                                                                                           ZipBytes)
                                                                                                                     :<|> ((AuthResult
                                                                                                                              Token
                                                                                                                            -> DocumentID
                                                                                                                            -> RevisionSelector
                                                                                                                            -> Handler
                                                                                                                                 (Maybe
                                                                                                                                    (TreeRevision
                                                                                                                                       TextElement)))
                                                                                                                           :<|> ((AuthResult
                                                                                                                                    Token
                                                                                                                                  -> DocumentID
                                                                                                                                  -> RevisionSelector
                                                                                                                                  -> TextElementID
                                                                                                                                  -> Handler
                                                                                                                                       (Maybe
                                                                                                                                          TextElementRevision))
                                                                                                                                 :<|> ((AuthResult
                                                                                                                                          Token
                                                                                                                                        -> DocumentID
                                                                                                                                        -> TextElementID
                                                                                                                                        -> Handler
                                                                                                                                             (Maybe
                                                                                                                                                (Rendered
                                                                                                                                                   DraftRevision)))
                                                                                                                                       :<|> ((AuthResult
                                                                                                                                                Token
                                                                                                                                              -> DocumentID
                                                                                                                                              -> TextElementID
                                                                                                                                              -> Handler
                                                                                                                                                   (Rendered
                                                                                                                                                      ConflictStatus))
                                                                                                                                             :<|> ((AuthResult
                                                                                                                                                      Token
                                                                                                                                                    -> DocumentID
                                                                                                                                                    -> TextElementID
                                                                                                                                                    -> Handler
                                                                                                                                                         ())
                                                                                                                                                   :<|> ((AuthResult
                                                                                                                                                            Token
                                                                                                                                                          -> Text
                                                                                                                                                          -> Handler
                                                                                                                                                               DocByteString)
                                                                                                                                                         :<|> (AuthResult
                                                                                                                                                                 Token
                                                                                                                                                               -> Text
                                                                                                                                                               -> Handler
                                                                                                                                                                    PDFByteString))))))))))))))))))))))))))
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token
-> DocumentID -> CreateTextElement -> Handler TextElement
postTextElementHandler
        (AuthResult Token
 -> DocumentID -> CreateTextElement -> Handler TextElement)
-> ((AuthResult Token
     -> DocumentID
     -> TextElementID
     -> Maybe Bool
     -> CreateTextRevision
     -> Handler (Rendered ConflictStatus))
    :<|> ((AuthResult Token
           -> DocumentID
           -> TextElementID
           -> TextRevisionSelector
           -> Handler (Maybe (Rendered TextElementRevision)))
          :<|> ((AuthResult Token
                 -> DocumentID
                 -> TextElementID
                 -> TextRevisionSelector
                 -> Handler PDFBytes)
                :<|> ((AuthResult Token
                       -> DocumentID
                       -> Node TextElementID
                       -> Handler (TreeRevisionWithMetaData TextElementID))
                      :<|> ((AuthResult Token
                             -> DocumentID
                             -> TreeRevisionSelector
                             -> Handler (Maybe (TreeRevisionWithMetaData TextElement)))
                            :<|> ((AuthResult Token
                                   -> DocumentID
                                   -> TreeRevisionSelector
                                   -> Handler
                                        (Maybe (TreeRevisionWithMetaData TextElementRevision)))
                                  :<|> ((AuthResult Token
                                         -> DocumentID -> TreeRevisionSelector -> Handler PDFBytes)
                                        :<|> ((AuthResult Token
                                               -> DocumentID
                                               -> TreeRevisionSelector
                                               -> Handler ZipBytes)
                                              :<|> ((AuthResult Token
                                                     -> DocumentID
                                                     -> TextElementID
                                                     -> Maybe UTCTime
                                                     -> Maybe UTCTime
                                                     -> Maybe GroupID
                                                     -> Handler TextRevisionHistory)
                                                    :<|> ((AuthResult Token
                                                           -> DocumentID
                                                           -> Maybe UTCTime
                                                           -> Maybe GroupID
                                                           -> Handler TreeRevisionHistory)
                                                          :<|> ((AuthResult Token
                                                                 -> DocumentID
                                                                 -> Maybe UTCTime
                                                                 -> Maybe GroupID
                                                                 -> Handler DocumentHistory)
                                                                :<|> ((AuthResult Token
                                                                       -> DocumentID
                                                                       -> TextElementID
                                                                       -> CreateComment
                                                                       -> Handler Comment)
                                                                      :<|> ((AuthResult Token
                                                                             -> DocumentID
                                                                             -> TextElementID
                                                                             -> Handler Comments)
                                                                            :<|> ((AuthResult Token
                                                                                   -> DocumentID
                                                                                   -> TextElementID
                                                                                   -> CommentID
                                                                                   -> Handler ())
                                                                                  :<|> ((AuthResult
                                                                                           Token
                                                                                         -> DocumentID
                                                                                         -> TextElementID
                                                                                         -> CommentID
                                                                                         -> CreateReply
                                                                                         -> Handler
                                                                                              Message)
                                                                                        :<|> ((AuthResult
                                                                                                 Token
                                                                                               -> DocumentID
                                                                                               -> RevisionSelector
                                                                                               -> Handler
                                                                                                    (FullDocument
                                                                                                       TextElementRevision))
                                                                                              :<|> ((AuthResult
                                                                                                       Token
                                                                                                     -> DocumentID
                                                                                                     -> RevisionSelector
                                                                                                     -> Handler
                                                                                                          PDFBytes)
                                                                                                    :<|> ((AuthResult
                                                                                                             Token
                                                                                                           -> DocumentID
                                                                                                           -> RevisionSelector
                                                                                                           -> Handler
                                                                                                                ZipBytes)
                                                                                                          :<|> ((AuthResult
                                                                                                                   Token
                                                                                                                 -> DocumentID
                                                                                                                 -> RevisionSelector
                                                                                                                 -> Handler
                                                                                                                      (Maybe
                                                                                                                         (TreeRevision
                                                                                                                            TextElement)))
                                                                                                                :<|> ((AuthResult
                                                                                                                         Token
                                                                                                                       -> DocumentID
                                                                                                                       -> RevisionSelector
                                                                                                                       -> TextElementID
                                                                                                                       -> Handler
                                                                                                                            (Maybe
                                                                                                                               TextElementRevision))
                                                                                                                      :<|> ((AuthResult
                                                                                                                               Token
                                                                                                                             -> DocumentID
                                                                                                                             -> TextElementID
                                                                                                                             -> Handler
                                                                                                                                  (Maybe
                                                                                                                                     (Rendered
                                                                                                                                        DraftRevision)))
                                                                                                                            :<|> ((AuthResult
                                                                                                                                     Token
                                                                                                                                   -> DocumentID
                                                                                                                                   -> TextElementID
                                                                                                                                   -> Handler
                                                                                                                                        (Rendered
                                                                                                                                           ConflictStatus))
                                                                                                                                  :<|> ((AuthResult
                                                                                                                                           Token
                                                                                                                                         -> DocumentID
                                                                                                                                         -> TextElementID
                                                                                                                                         -> Handler
                                                                                                                                              ())
                                                                                                                                        :<|> ((AuthResult
                                                                                                                                                 Token
                                                                                                                                               -> Text
                                                                                                                                               -> Handler
                                                                                                                                                    DocByteString)
                                                                                                                                              :<|> (AuthResult
                                                                                                                                                      Token
                                                                                                                                                    -> Text
                                                                                                                                                    -> Handler
                                                                                                                                                         PDFByteString)))))))))))))))))))))))))
-> (AuthResult Token
    -> DocumentID -> CreateTextElement -> Handler TextElement)
   :<|> ((AuthResult Token
          -> DocumentID
          -> TextElementID
          -> Maybe Bool
          -> CreateTextRevision
          -> Handler (Rendered ConflictStatus))
         :<|> ((AuthResult Token
                -> DocumentID
                -> TextElementID
                -> TextRevisionSelector
                -> Handler (Maybe (Rendered TextElementRevision)))
               :<|> ((AuthResult Token
                      -> DocumentID
                      -> TextElementID
                      -> TextRevisionSelector
                      -> Handler PDFBytes)
                     :<|> ((AuthResult Token
                            -> DocumentID
                            -> Node TextElementID
                            -> Handler (TreeRevisionWithMetaData TextElementID))
                           :<|> ((AuthResult Token
                                  -> DocumentID
                                  -> TreeRevisionSelector
                                  -> Handler (Maybe (TreeRevisionWithMetaData TextElement)))
                                 :<|> ((AuthResult Token
                                        -> DocumentID
                                        -> TreeRevisionSelector
                                        -> Handler
                                             (Maybe (TreeRevisionWithMetaData TextElementRevision)))
                                       :<|> ((AuthResult Token
                                              -> DocumentID
                                              -> TreeRevisionSelector
                                              -> Handler PDFBytes)
                                             :<|> ((AuthResult Token
                                                    -> DocumentID
                                                    -> TreeRevisionSelector
                                                    -> Handler ZipBytes)
                                                   :<|> ((AuthResult Token
                                                          -> DocumentID
                                                          -> TextElementID
                                                          -> Maybe UTCTime
                                                          -> Maybe UTCTime
                                                          -> Maybe GroupID
                                                          -> Handler TextRevisionHistory)
                                                         :<|> ((AuthResult Token
                                                                -> DocumentID
                                                                -> Maybe UTCTime
                                                                -> Maybe GroupID
                                                                -> Handler TreeRevisionHistory)
                                                               :<|> ((AuthResult Token
                                                                      -> DocumentID
                                                                      -> Maybe UTCTime
                                                                      -> Maybe GroupID
                                                                      -> Handler DocumentHistory)
                                                                     :<|> ((AuthResult Token
                                                                            -> DocumentID
                                                                            -> TextElementID
                                                                            -> CreateComment
                                                                            -> Handler Comment)
                                                                           :<|> ((AuthResult Token
                                                                                  -> DocumentID
                                                                                  -> TextElementID
                                                                                  -> Handler
                                                                                       Comments)
                                                                                 :<|> ((AuthResult
                                                                                          Token
                                                                                        -> DocumentID
                                                                                        -> TextElementID
                                                                                        -> CommentID
                                                                                        -> Handler
                                                                                             ())
                                                                                       :<|> ((AuthResult
                                                                                                Token
                                                                                              -> DocumentID
                                                                                              -> TextElementID
                                                                                              -> CommentID
                                                                                              -> CreateReply
                                                                                              -> Handler
                                                                                                   Message)
                                                                                             :<|> ((AuthResult
                                                                                                      Token
                                                                                                    -> DocumentID
                                                                                                    -> RevisionSelector
                                                                                                    -> Handler
                                                                                                         (FullDocument
                                                                                                            TextElementRevision))
                                                                                                   :<|> ((AuthResult
                                                                                                            Token
                                                                                                          -> DocumentID
                                                                                                          -> RevisionSelector
                                                                                                          -> Handler
                                                                                                               PDFBytes)
                                                                                                         :<|> ((AuthResult
                                                                                                                  Token
                                                                                                                -> DocumentID
                                                                                                                -> RevisionSelector
                                                                                                                -> Handler
                                                                                                                     ZipBytes)
                                                                                                               :<|> ((AuthResult
                                                                                                                        Token
                                                                                                                      -> DocumentID
                                                                                                                      -> RevisionSelector
                                                                                                                      -> Handler
                                                                                                                           (Maybe
                                                                                                                              (TreeRevision
                                                                                                                                 TextElement)))
                                                                                                                     :<|> ((AuthResult
                                                                                                                              Token
                                                                                                                            -> DocumentID
                                                                                                                            -> RevisionSelector
                                                                                                                            -> TextElementID
                                                                                                                            -> Handler
                                                                                                                                 (Maybe
                                                                                                                                    TextElementRevision))
                                                                                                                           :<|> ((AuthResult
                                                                                                                                    Token
                                                                                                                                  -> DocumentID
                                                                                                                                  -> TextElementID
                                                                                                                                  -> Handler
                                                                                                                                       (Maybe
                                                                                                                                          (Rendered
                                                                                                                                             DraftRevision)))
                                                                                                                                 :<|> ((AuthResult
                                                                                                                                          Token
                                                                                                                                        -> DocumentID
                                                                                                                                        -> TextElementID
                                                                                                                                        -> Handler
                                                                                                                                             (Rendered
                                                                                                                                                ConflictStatus))
                                                                                                                                       :<|> ((AuthResult
                                                                                                                                                Token
                                                                                                                                              -> DocumentID
                                                                                                                                              -> TextElementID
                                                                                                                                              -> Handler
                                                                                                                                                   ())
                                                                                                                                             :<|> ((AuthResult
                                                                                                                                                      Token
                                                                                                                                                    -> Text
                                                                                                                                                    -> Handler
                                                                                                                                                         DocByteString)
                                                                                                                                                   :<|> (AuthResult
                                                                                                                                                           Token
                                                                                                                                                         -> Text
                                                                                                                                                         -> Handler
                                                                                                                                                              PDFByteString)))))))))))))))))))))))))
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token
-> DocumentID
-> TextElementID
-> Maybe Bool
-> CreateTextRevision
-> Handler (Rendered ConflictStatus)
postTextRevisionHandler
        (AuthResult Token
 -> DocumentID
 -> TextElementID
 -> Maybe Bool
 -> CreateTextRevision
 -> Handler (Rendered ConflictStatus))
-> ((AuthResult Token
     -> DocumentID
     -> TextElementID
     -> TextRevisionSelector
     -> Handler (Maybe (Rendered TextElementRevision)))
    :<|> ((AuthResult Token
           -> DocumentID
           -> TextElementID
           -> TextRevisionSelector
           -> Handler PDFBytes)
          :<|> ((AuthResult Token
                 -> DocumentID
                 -> Node TextElementID
                 -> Handler (TreeRevisionWithMetaData TextElementID))
                :<|> ((AuthResult Token
                       -> DocumentID
                       -> TreeRevisionSelector
                       -> Handler (Maybe (TreeRevisionWithMetaData TextElement)))
                      :<|> ((AuthResult Token
                             -> DocumentID
                             -> TreeRevisionSelector
                             -> Handler (Maybe (TreeRevisionWithMetaData TextElementRevision)))
                            :<|> ((AuthResult Token
                                   -> DocumentID -> TreeRevisionSelector -> Handler PDFBytes)
                                  :<|> ((AuthResult Token
                                         -> DocumentID -> TreeRevisionSelector -> Handler ZipBytes)
                                        :<|> ((AuthResult Token
                                               -> DocumentID
                                               -> TextElementID
                                               -> Maybe UTCTime
                                               -> Maybe UTCTime
                                               -> Maybe GroupID
                                               -> Handler TextRevisionHistory)
                                              :<|> ((AuthResult Token
                                                     -> DocumentID
                                                     -> Maybe UTCTime
                                                     -> Maybe GroupID
                                                     -> Handler TreeRevisionHistory)
                                                    :<|> ((AuthResult Token
                                                           -> DocumentID
                                                           -> Maybe UTCTime
                                                           -> Maybe GroupID
                                                           -> Handler DocumentHistory)
                                                          :<|> ((AuthResult Token
                                                                 -> DocumentID
                                                                 -> TextElementID
                                                                 -> CreateComment
                                                                 -> Handler Comment)
                                                                :<|> ((AuthResult Token
                                                                       -> DocumentID
                                                                       -> TextElementID
                                                                       -> Handler Comments)
                                                                      :<|> ((AuthResult Token
                                                                             -> DocumentID
                                                                             -> TextElementID
                                                                             -> CommentID
                                                                             -> Handler ())
                                                                            :<|> ((AuthResult Token
                                                                                   -> DocumentID
                                                                                   -> TextElementID
                                                                                   -> CommentID
                                                                                   -> CreateReply
                                                                                   -> Handler
                                                                                        Message)
                                                                                  :<|> ((AuthResult
                                                                                           Token
                                                                                         -> DocumentID
                                                                                         -> RevisionSelector
                                                                                         -> Handler
                                                                                              (FullDocument
                                                                                                 TextElementRevision))
                                                                                        :<|> ((AuthResult
                                                                                                 Token
                                                                                               -> DocumentID
                                                                                               -> RevisionSelector
                                                                                               -> Handler
                                                                                                    PDFBytes)
                                                                                              :<|> ((AuthResult
                                                                                                       Token
                                                                                                     -> DocumentID
                                                                                                     -> RevisionSelector
                                                                                                     -> Handler
                                                                                                          ZipBytes)
                                                                                                    :<|> ((AuthResult
                                                                                                             Token
                                                                                                           -> DocumentID
                                                                                                           -> RevisionSelector
                                                                                                           -> Handler
                                                                                                                (Maybe
                                                                                                                   (TreeRevision
                                                                                                                      TextElement)))
                                                                                                          :<|> ((AuthResult
                                                                                                                   Token
                                                                                                                 -> DocumentID
                                                                                                                 -> RevisionSelector
                                                                                                                 -> TextElementID
                                                                                                                 -> Handler
                                                                                                                      (Maybe
                                                                                                                         TextElementRevision))
                                                                                                                :<|> ((AuthResult
                                                                                                                         Token
                                                                                                                       -> DocumentID
                                                                                                                       -> TextElementID
                                                                                                                       -> Handler
                                                                                                                            (Maybe
                                                                                                                               (Rendered
                                                                                                                                  DraftRevision)))
                                                                                                                      :<|> ((AuthResult
                                                                                                                               Token
                                                                                                                             -> DocumentID
                                                                                                                             -> TextElementID
                                                                                                                             -> Handler
                                                                                                                                  (Rendered
                                                                                                                                     ConflictStatus))
                                                                                                                            :<|> ((AuthResult
                                                                                                                                     Token
                                                                                                                                   -> DocumentID
                                                                                                                                   -> TextElementID
                                                                                                                                   -> Handler
                                                                                                                                        ())
                                                                                                                                  :<|> ((AuthResult
                                                                                                                                           Token
                                                                                                                                         -> Text
                                                                                                                                         -> Handler
                                                                                                                                              DocByteString)
                                                                                                                                        :<|> (AuthResult
                                                                                                                                                Token
                                                                                                                                              -> Text
                                                                                                                                              -> Handler
                                                                                                                                                   PDFByteString))))))))))))))))))))))))
-> (AuthResult Token
    -> DocumentID
    -> TextElementID
    -> Maybe Bool
    -> CreateTextRevision
    -> Handler (Rendered ConflictStatus))
   :<|> ((AuthResult Token
          -> DocumentID
          -> TextElementID
          -> TextRevisionSelector
          -> Handler (Maybe (Rendered TextElementRevision)))
         :<|> ((AuthResult Token
                -> DocumentID
                -> TextElementID
                -> TextRevisionSelector
                -> Handler PDFBytes)
               :<|> ((AuthResult Token
                      -> DocumentID
                      -> Node TextElementID
                      -> Handler (TreeRevisionWithMetaData TextElementID))
                     :<|> ((AuthResult Token
                            -> DocumentID
                            -> TreeRevisionSelector
                            -> Handler (Maybe (TreeRevisionWithMetaData TextElement)))
                           :<|> ((AuthResult Token
                                  -> DocumentID
                                  -> TreeRevisionSelector
                                  -> Handler (Maybe (TreeRevisionWithMetaData TextElementRevision)))
                                 :<|> ((AuthResult Token
                                        -> DocumentID -> TreeRevisionSelector -> Handler PDFBytes)
                                       :<|> ((AuthResult Token
                                              -> DocumentID
                                              -> TreeRevisionSelector
                                              -> Handler ZipBytes)
                                             :<|> ((AuthResult Token
                                                    -> DocumentID
                                                    -> TextElementID
                                                    -> Maybe UTCTime
                                                    -> Maybe UTCTime
                                                    -> Maybe GroupID
                                                    -> Handler TextRevisionHistory)
                                                   :<|> ((AuthResult Token
                                                          -> DocumentID
                                                          -> Maybe UTCTime
                                                          -> Maybe GroupID
                                                          -> Handler TreeRevisionHistory)
                                                         :<|> ((AuthResult Token
                                                                -> DocumentID
                                                                -> Maybe UTCTime
                                                                -> Maybe GroupID
                                                                -> Handler DocumentHistory)
                                                               :<|> ((AuthResult Token
                                                                      -> DocumentID
                                                                      -> TextElementID
                                                                      -> CreateComment
                                                                      -> Handler Comment)
                                                                     :<|> ((AuthResult Token
                                                                            -> DocumentID
                                                                            -> TextElementID
                                                                            -> Handler Comments)
                                                                           :<|> ((AuthResult Token
                                                                                  -> DocumentID
                                                                                  -> TextElementID
                                                                                  -> CommentID
                                                                                  -> Handler ())
                                                                                 :<|> ((AuthResult
                                                                                          Token
                                                                                        -> DocumentID
                                                                                        -> TextElementID
                                                                                        -> CommentID
                                                                                        -> CreateReply
                                                                                        -> Handler
                                                                                             Message)
                                                                                       :<|> ((AuthResult
                                                                                                Token
                                                                                              -> DocumentID
                                                                                              -> RevisionSelector
                                                                                              -> Handler
                                                                                                   (FullDocument
                                                                                                      TextElementRevision))
                                                                                             :<|> ((AuthResult
                                                                                                      Token
                                                                                                    -> DocumentID
                                                                                                    -> RevisionSelector
                                                                                                    -> Handler
                                                                                                         PDFBytes)
                                                                                                   :<|> ((AuthResult
                                                                                                            Token
                                                                                                          -> DocumentID
                                                                                                          -> RevisionSelector
                                                                                                          -> Handler
                                                                                                               ZipBytes)
                                                                                                         :<|> ((AuthResult
                                                                                                                  Token
                                                                                                                -> DocumentID
                                                                                                                -> RevisionSelector
                                                                                                                -> Handler
                                                                                                                     (Maybe
                                                                                                                        (TreeRevision
                                                                                                                           TextElement)))
                                                                                                               :<|> ((AuthResult
                                                                                                                        Token
                                                                                                                      -> DocumentID
                                                                                                                      -> RevisionSelector
                                                                                                                      -> TextElementID
                                                                                                                      -> Handler
                                                                                                                           (Maybe
                                                                                                                              TextElementRevision))
                                                                                                                     :<|> ((AuthResult
                                                                                                                              Token
                                                                                                                            -> DocumentID
                                                                                                                            -> TextElementID
                                                                                                                            -> Handler
                                                                                                                                 (Maybe
                                                                                                                                    (Rendered
                                                                                                                                       DraftRevision)))
                                                                                                                           :<|> ((AuthResult
                                                                                                                                    Token
                                                                                                                                  -> DocumentID
                                                                                                                                  -> TextElementID
                                                                                                                                  -> Handler
                                                                                                                                       (Rendered
                                                                                                                                          ConflictStatus))
                                                                                                                                 :<|> ((AuthResult
                                                                                                                                          Token
                                                                                                                                        -> DocumentID
                                                                                                                                        -> TextElementID
                                                                                                                                        -> Handler
                                                                                                                                             ())
                                                                                                                                       :<|> ((AuthResult
                                                                                                                                                Token
                                                                                                                                              -> Text
                                                                                                                                              -> Handler
                                                                                                                                                   DocByteString)
                                                                                                                                             :<|> (AuthResult
                                                                                                                                                     Token
                                                                                                                                                   -> Text
                                                                                                                                                   -> Handler
                                                                                                                                                        PDFByteString))))))))))))))))))))))))
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token
-> DocumentID
-> TextElementID
-> TextRevisionSelector
-> Handler (Maybe (Rendered TextElementRevision))
getTextElementRevisionHandler
        (AuthResult Token
 -> DocumentID
 -> TextElementID
 -> TextRevisionSelector
 -> Handler (Maybe (Rendered TextElementRevision)))
-> ((AuthResult Token
     -> DocumentID
     -> TextElementID
     -> TextRevisionSelector
     -> Handler PDFBytes)
    :<|> ((AuthResult Token
           -> DocumentID
           -> Node TextElementID
           -> Handler (TreeRevisionWithMetaData TextElementID))
          :<|> ((AuthResult Token
                 -> DocumentID
                 -> TreeRevisionSelector
                 -> Handler (Maybe (TreeRevisionWithMetaData TextElement)))
                :<|> ((AuthResult Token
                       -> DocumentID
                       -> TreeRevisionSelector
                       -> Handler (Maybe (TreeRevisionWithMetaData TextElementRevision)))
                      :<|> ((AuthResult Token
                             -> DocumentID -> TreeRevisionSelector -> Handler PDFBytes)
                            :<|> ((AuthResult Token
                                   -> DocumentID -> TreeRevisionSelector -> Handler ZipBytes)
                                  :<|> ((AuthResult Token
                                         -> DocumentID
                                         -> TextElementID
                                         -> Maybe UTCTime
                                         -> Maybe UTCTime
                                         -> Maybe GroupID
                                         -> Handler TextRevisionHistory)
                                        :<|> ((AuthResult Token
                                               -> DocumentID
                                               -> Maybe UTCTime
                                               -> Maybe GroupID
                                               -> Handler TreeRevisionHistory)
                                              :<|> ((AuthResult Token
                                                     -> DocumentID
                                                     -> Maybe UTCTime
                                                     -> Maybe GroupID
                                                     -> Handler DocumentHistory)
                                                    :<|> ((AuthResult Token
                                                           -> DocumentID
                                                           -> TextElementID
                                                           -> CreateComment
                                                           -> Handler Comment)
                                                          :<|> ((AuthResult Token
                                                                 -> DocumentID
                                                                 -> TextElementID
                                                                 -> Handler Comments)
                                                                :<|> ((AuthResult Token
                                                                       -> DocumentID
                                                                       -> TextElementID
                                                                       -> CommentID
                                                                       -> Handler ())
                                                                      :<|> ((AuthResult Token
                                                                             -> DocumentID
                                                                             -> TextElementID
                                                                             -> CommentID
                                                                             -> CreateReply
                                                                             -> Handler Message)
                                                                            :<|> ((AuthResult Token
                                                                                   -> DocumentID
                                                                                   -> RevisionSelector
                                                                                   -> Handler
                                                                                        (FullDocument
                                                                                           TextElementRevision))
                                                                                  :<|> ((AuthResult
                                                                                           Token
                                                                                         -> DocumentID
                                                                                         -> RevisionSelector
                                                                                         -> Handler
                                                                                              PDFBytes)
                                                                                        :<|> ((AuthResult
                                                                                                 Token
                                                                                               -> DocumentID
                                                                                               -> RevisionSelector
                                                                                               -> Handler
                                                                                                    ZipBytes)
                                                                                              :<|> ((AuthResult
                                                                                                       Token
                                                                                                     -> DocumentID
                                                                                                     -> RevisionSelector
                                                                                                     -> Handler
                                                                                                          (Maybe
                                                                                                             (TreeRevision
                                                                                                                TextElement)))
                                                                                                    :<|> ((AuthResult
                                                                                                             Token
                                                                                                           -> DocumentID
                                                                                                           -> RevisionSelector
                                                                                                           -> TextElementID
                                                                                                           -> Handler
                                                                                                                (Maybe
                                                                                                                   TextElementRevision))
                                                                                                          :<|> ((AuthResult
                                                                                                                   Token
                                                                                                                 -> DocumentID
                                                                                                                 -> TextElementID
                                                                                                                 -> Handler
                                                                                                                      (Maybe
                                                                                                                         (Rendered
                                                                                                                            DraftRevision)))
                                                                                                                :<|> ((AuthResult
                                                                                                                         Token
                                                                                                                       -> DocumentID
                                                                                                                       -> TextElementID
                                                                                                                       -> Handler
                                                                                                                            (Rendered
                                                                                                                               ConflictStatus))
                                                                                                                      :<|> ((AuthResult
                                                                                                                               Token
                                                                                                                             -> DocumentID
                                                                                                                             -> TextElementID
                                                                                                                             -> Handler
                                                                                                                                  ())
                                                                                                                            :<|> ((AuthResult
                                                                                                                                     Token
                                                                                                                                   -> Text
                                                                                                                                   -> Handler
                                                                                                                                        DocByteString)
                                                                                                                                  :<|> (AuthResult
                                                                                                                                          Token
                                                                                                                                        -> Text
                                                                                                                                        -> Handler
                                                                                                                                             PDFByteString)))))))))))))))))))))))
-> (AuthResult Token
    -> DocumentID
    -> TextElementID
    -> TextRevisionSelector
    -> Handler (Maybe (Rendered TextElementRevision)))
   :<|> ((AuthResult Token
          -> DocumentID
          -> TextElementID
          -> TextRevisionSelector
          -> Handler PDFBytes)
         :<|> ((AuthResult Token
                -> DocumentID
                -> Node TextElementID
                -> Handler (TreeRevisionWithMetaData TextElementID))
               :<|> ((AuthResult Token
                      -> DocumentID
                      -> TreeRevisionSelector
                      -> Handler (Maybe (TreeRevisionWithMetaData TextElement)))
                     :<|> ((AuthResult Token
                            -> DocumentID
                            -> TreeRevisionSelector
                            -> Handler (Maybe (TreeRevisionWithMetaData TextElementRevision)))
                           :<|> ((AuthResult Token
                                  -> DocumentID -> TreeRevisionSelector -> Handler PDFBytes)
                                 :<|> ((AuthResult Token
                                        -> DocumentID -> TreeRevisionSelector -> Handler ZipBytes)
                                       :<|> ((AuthResult Token
                                              -> DocumentID
                                              -> TextElementID
                                              -> Maybe UTCTime
                                              -> Maybe UTCTime
                                              -> Maybe GroupID
                                              -> Handler TextRevisionHistory)
                                             :<|> ((AuthResult Token
                                                    -> DocumentID
                                                    -> Maybe UTCTime
                                                    -> Maybe GroupID
                                                    -> Handler TreeRevisionHistory)
                                                   :<|> ((AuthResult Token
                                                          -> DocumentID
                                                          -> Maybe UTCTime
                                                          -> Maybe GroupID
                                                          -> Handler DocumentHistory)
                                                         :<|> ((AuthResult Token
                                                                -> DocumentID
                                                                -> TextElementID
                                                                -> CreateComment
                                                                -> Handler Comment)
                                                               :<|> ((AuthResult Token
                                                                      -> DocumentID
                                                                      -> TextElementID
                                                                      -> Handler Comments)
                                                                     :<|> ((AuthResult Token
                                                                            -> DocumentID
                                                                            -> TextElementID
                                                                            -> CommentID
                                                                            -> Handler ())
                                                                           :<|> ((AuthResult Token
                                                                                  -> DocumentID
                                                                                  -> TextElementID
                                                                                  -> CommentID
                                                                                  -> CreateReply
                                                                                  -> Handler
                                                                                       Message)
                                                                                 :<|> ((AuthResult
                                                                                          Token
                                                                                        -> DocumentID
                                                                                        -> RevisionSelector
                                                                                        -> Handler
                                                                                             (FullDocument
                                                                                                TextElementRevision))
                                                                                       :<|> ((AuthResult
                                                                                                Token
                                                                                              -> DocumentID
                                                                                              -> RevisionSelector
                                                                                              -> Handler
                                                                                                   PDFBytes)
                                                                                             :<|> ((AuthResult
                                                                                                      Token
                                                                                                    -> DocumentID
                                                                                                    -> RevisionSelector
                                                                                                    -> Handler
                                                                                                         ZipBytes)
                                                                                                   :<|> ((AuthResult
                                                                                                            Token
                                                                                                          -> DocumentID
                                                                                                          -> RevisionSelector
                                                                                                          -> Handler
                                                                                                               (Maybe
                                                                                                                  (TreeRevision
                                                                                                                     TextElement)))
                                                                                                         :<|> ((AuthResult
                                                                                                                  Token
                                                                                                                -> DocumentID
                                                                                                                -> RevisionSelector
                                                                                                                -> TextElementID
                                                                                                                -> Handler
                                                                                                                     (Maybe
                                                                                                                        TextElementRevision))
                                                                                                               :<|> ((AuthResult
                                                                                                                        Token
                                                                                                                      -> DocumentID
                                                                                                                      -> TextElementID
                                                                                                                      -> Handler
                                                                                                                           (Maybe
                                                                                                                              (Rendered
                                                                                                                                 DraftRevision)))
                                                                                                                     :<|> ((AuthResult
                                                                                                                              Token
                                                                                                                            -> DocumentID
                                                                                                                            -> TextElementID
                                                                                                                            -> Handler
                                                                                                                                 (Rendered
                                                                                                                                    ConflictStatus))
                                                                                                                           :<|> ((AuthResult
                                                                                                                                    Token
                                                                                                                                  -> DocumentID
                                                                                                                                  -> TextElementID
                                                                                                                                  -> Handler
                                                                                                                                       ())
                                                                                                                                 :<|> ((AuthResult
                                                                                                                                          Token
                                                                                                                                        -> Text
                                                                                                                                        -> Handler
                                                                                                                                             DocByteString)
                                                                                                                                       :<|> (AuthResult
                                                                                                                                               Token
                                                                                                                                             -> Text
                                                                                                                                             -> Handler
                                                                                                                                                  PDFByteString)))))))))))))))))))))))
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token
-> DocumentID
-> TextElementID
-> TextRevisionSelector
-> Handler PDFBytes
getTextRevisionPDFHandler
        (AuthResult Token
 -> DocumentID
 -> TextElementID
 -> TextRevisionSelector
 -> Handler PDFBytes)
-> ((AuthResult Token
     -> DocumentID
     -> Node TextElementID
     -> Handler (TreeRevisionWithMetaData TextElementID))
    :<|> ((AuthResult Token
           -> DocumentID
           -> TreeRevisionSelector
           -> Handler (Maybe (TreeRevisionWithMetaData TextElement)))
          :<|> ((AuthResult Token
                 -> DocumentID
                 -> TreeRevisionSelector
                 -> Handler (Maybe (TreeRevisionWithMetaData TextElementRevision)))
                :<|> ((AuthResult Token
                       -> DocumentID -> TreeRevisionSelector -> Handler PDFBytes)
                      :<|> ((AuthResult Token
                             -> DocumentID -> TreeRevisionSelector -> Handler ZipBytes)
                            :<|> ((AuthResult Token
                                   -> DocumentID
                                   -> TextElementID
                                   -> Maybe UTCTime
                                   -> Maybe UTCTime
                                   -> Maybe GroupID
                                   -> Handler TextRevisionHistory)
                                  :<|> ((AuthResult Token
                                         -> DocumentID
                                         -> Maybe UTCTime
                                         -> Maybe GroupID
                                         -> Handler TreeRevisionHistory)
                                        :<|> ((AuthResult Token
                                               -> DocumentID
                                               -> Maybe UTCTime
                                               -> Maybe GroupID
                                               -> Handler DocumentHistory)
                                              :<|> ((AuthResult Token
                                                     -> DocumentID
                                                     -> TextElementID
                                                     -> CreateComment
                                                     -> Handler Comment)
                                                    :<|> ((AuthResult Token
                                                           -> DocumentID
                                                           -> TextElementID
                                                           -> Handler Comments)
                                                          :<|> ((AuthResult Token
                                                                 -> DocumentID
                                                                 -> TextElementID
                                                                 -> CommentID
                                                                 -> Handler ())
                                                                :<|> ((AuthResult Token
                                                                       -> DocumentID
                                                                       -> TextElementID
                                                                       -> CommentID
                                                                       -> CreateReply
                                                                       -> Handler Message)
                                                                      :<|> ((AuthResult Token
                                                                             -> DocumentID
                                                                             -> RevisionSelector
                                                                             -> Handler
                                                                                  (FullDocument
                                                                                     TextElementRevision))
                                                                            :<|> ((AuthResult Token
                                                                                   -> DocumentID
                                                                                   -> RevisionSelector
                                                                                   -> Handler
                                                                                        PDFBytes)
                                                                                  :<|> ((AuthResult
                                                                                           Token
                                                                                         -> DocumentID
                                                                                         -> RevisionSelector
                                                                                         -> Handler
                                                                                              ZipBytes)
                                                                                        :<|> ((AuthResult
                                                                                                 Token
                                                                                               -> DocumentID
                                                                                               -> RevisionSelector
                                                                                               -> Handler
                                                                                                    (Maybe
                                                                                                       (TreeRevision
                                                                                                          TextElement)))
                                                                                              :<|> ((AuthResult
                                                                                                       Token
                                                                                                     -> DocumentID
                                                                                                     -> RevisionSelector
                                                                                                     -> TextElementID
                                                                                                     -> Handler
                                                                                                          (Maybe
                                                                                                             TextElementRevision))
                                                                                                    :<|> ((AuthResult
                                                                                                             Token
                                                                                                           -> DocumentID
                                                                                                           -> TextElementID
                                                                                                           -> Handler
                                                                                                                (Maybe
                                                                                                                   (Rendered
                                                                                                                      DraftRevision)))
                                                                                                          :<|> ((AuthResult
                                                                                                                   Token
                                                                                                                 -> DocumentID
                                                                                                                 -> TextElementID
                                                                                                                 -> Handler
                                                                                                                      (Rendered
                                                                                                                         ConflictStatus))
                                                                                                                :<|> ((AuthResult
                                                                                                                         Token
                                                                                                                       -> DocumentID
                                                                                                                       -> TextElementID
                                                                                                                       -> Handler
                                                                                                                            ())
                                                                                                                      :<|> ((AuthResult
                                                                                                                               Token
                                                                                                                             -> Text
                                                                                                                             -> Handler
                                                                                                                                  DocByteString)
                                                                                                                            :<|> (AuthResult
                                                                                                                                    Token
                                                                                                                                  -> Text
                                                                                                                                  -> Handler
                                                                                                                                       PDFByteString))))))))))))))))))))))
-> (AuthResult Token
    -> DocumentID
    -> TextElementID
    -> TextRevisionSelector
    -> Handler PDFBytes)
   :<|> ((AuthResult Token
          -> DocumentID
          -> Node TextElementID
          -> Handler (TreeRevisionWithMetaData TextElementID))
         :<|> ((AuthResult Token
                -> DocumentID
                -> TreeRevisionSelector
                -> Handler (Maybe (TreeRevisionWithMetaData TextElement)))
               :<|> ((AuthResult Token
                      -> DocumentID
                      -> TreeRevisionSelector
                      -> Handler (Maybe (TreeRevisionWithMetaData TextElementRevision)))
                     :<|> ((AuthResult Token
                            -> DocumentID -> TreeRevisionSelector -> Handler PDFBytes)
                           :<|> ((AuthResult Token
                                  -> DocumentID -> TreeRevisionSelector -> Handler ZipBytes)
                                 :<|> ((AuthResult Token
                                        -> DocumentID
                                        -> TextElementID
                                        -> Maybe UTCTime
                                        -> Maybe UTCTime
                                        -> Maybe GroupID
                                        -> Handler TextRevisionHistory)
                                       :<|> ((AuthResult Token
                                              -> DocumentID
                                              -> Maybe UTCTime
                                              -> Maybe GroupID
                                              -> Handler TreeRevisionHistory)
                                             :<|> ((AuthResult Token
                                                    -> DocumentID
                                                    -> Maybe UTCTime
                                                    -> Maybe GroupID
                                                    -> Handler DocumentHistory)
                                                   :<|> ((AuthResult Token
                                                          -> DocumentID
                                                          -> TextElementID
                                                          -> CreateComment
                                                          -> Handler Comment)
                                                         :<|> ((AuthResult Token
                                                                -> DocumentID
                                                                -> TextElementID
                                                                -> Handler Comments)
                                                               :<|> ((AuthResult Token
                                                                      -> DocumentID
                                                                      -> TextElementID
                                                                      -> CommentID
                                                                      -> Handler ())
                                                                     :<|> ((AuthResult Token
                                                                            -> DocumentID
                                                                            -> TextElementID
                                                                            -> CommentID
                                                                            -> CreateReply
                                                                            -> Handler Message)
                                                                           :<|> ((AuthResult Token
                                                                                  -> DocumentID
                                                                                  -> RevisionSelector
                                                                                  -> Handler
                                                                                       (FullDocument
                                                                                          TextElementRevision))
                                                                                 :<|> ((AuthResult
                                                                                          Token
                                                                                        -> DocumentID
                                                                                        -> RevisionSelector
                                                                                        -> Handler
                                                                                             PDFBytes)
                                                                                       :<|> ((AuthResult
                                                                                                Token
                                                                                              -> DocumentID
                                                                                              -> RevisionSelector
                                                                                              -> Handler
                                                                                                   ZipBytes)
                                                                                             :<|> ((AuthResult
                                                                                                      Token
                                                                                                    -> DocumentID
                                                                                                    -> RevisionSelector
                                                                                                    -> Handler
                                                                                                         (Maybe
                                                                                                            (TreeRevision
                                                                                                               TextElement)))
                                                                                                   :<|> ((AuthResult
                                                                                                            Token
                                                                                                          -> DocumentID
                                                                                                          -> RevisionSelector
                                                                                                          -> TextElementID
                                                                                                          -> Handler
                                                                                                               (Maybe
                                                                                                                  TextElementRevision))
                                                                                                         :<|> ((AuthResult
                                                                                                                  Token
                                                                                                                -> DocumentID
                                                                                                                -> TextElementID
                                                                                                                -> Handler
                                                                                                                     (Maybe
                                                                                                                        (Rendered
                                                                                                                           DraftRevision)))
                                                                                                               :<|> ((AuthResult
                                                                                                                        Token
                                                                                                                      -> DocumentID
                                                                                                                      -> TextElementID
                                                                                                                      -> Handler
                                                                                                                           (Rendered
                                                                                                                              ConflictStatus))
                                                                                                                     :<|> ((AuthResult
                                                                                                                              Token
                                                                                                                            -> DocumentID
                                                                                                                            -> TextElementID
                                                                                                                            -> Handler
                                                                                                                                 ())
                                                                                                                           :<|> ((AuthResult
                                                                                                                                    Token
                                                                                                                                  -> Text
                                                                                                                                  -> Handler
                                                                                                                                       DocByteString)
                                                                                                                                 :<|> (AuthResult
                                                                                                                                         Token
                                                                                                                                       -> Text
                                                                                                                                       -> Handler
                                                                                                                                            PDFByteString))))))))))))))))))))))
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token
-> DocumentID
-> Node TextElementID
-> Handler (TreeRevisionWithMetaData TextElementID)
postTreeRevisionHandler
        (AuthResult Token
 -> DocumentID
 -> Node TextElementID
 -> Handler (TreeRevisionWithMetaData TextElementID))
-> ((AuthResult Token
     -> DocumentID
     -> TreeRevisionSelector
     -> Handler (Maybe (TreeRevisionWithMetaData TextElement)))
    :<|> ((AuthResult Token
           -> DocumentID
           -> TreeRevisionSelector
           -> Handler (Maybe (TreeRevisionWithMetaData TextElementRevision)))
          :<|> ((AuthResult Token
                 -> DocumentID -> TreeRevisionSelector -> Handler PDFBytes)
                :<|> ((AuthResult Token
                       -> DocumentID -> TreeRevisionSelector -> Handler ZipBytes)
                      :<|> ((AuthResult Token
                             -> DocumentID
                             -> TextElementID
                             -> Maybe UTCTime
                             -> Maybe UTCTime
                             -> Maybe GroupID
                             -> Handler TextRevisionHistory)
                            :<|> ((AuthResult Token
                                   -> DocumentID
                                   -> Maybe UTCTime
                                   -> Maybe GroupID
                                   -> Handler TreeRevisionHistory)
                                  :<|> ((AuthResult Token
                                         -> DocumentID
                                         -> Maybe UTCTime
                                         -> Maybe GroupID
                                         -> Handler DocumentHistory)
                                        :<|> ((AuthResult Token
                                               -> DocumentID
                                               -> TextElementID
                                               -> CreateComment
                                               -> Handler Comment)
                                              :<|> ((AuthResult Token
                                                     -> DocumentID
                                                     -> TextElementID
                                                     -> Handler Comments)
                                                    :<|> ((AuthResult Token
                                                           -> DocumentID
                                                           -> TextElementID
                                                           -> CommentID
                                                           -> Handler ())
                                                          :<|> ((AuthResult Token
                                                                 -> DocumentID
                                                                 -> TextElementID
                                                                 -> CommentID
                                                                 -> CreateReply
                                                                 -> Handler Message)
                                                                :<|> ((AuthResult Token
                                                                       -> DocumentID
                                                                       -> RevisionSelector
                                                                       -> Handler
                                                                            (FullDocument
                                                                               TextElementRevision))
                                                                      :<|> ((AuthResult Token
                                                                             -> DocumentID
                                                                             -> RevisionSelector
                                                                             -> Handler PDFBytes)
                                                                            :<|> ((AuthResult Token
                                                                                   -> DocumentID
                                                                                   -> RevisionSelector
                                                                                   -> Handler
                                                                                        ZipBytes)
                                                                                  :<|> ((AuthResult
                                                                                           Token
                                                                                         -> DocumentID
                                                                                         -> RevisionSelector
                                                                                         -> Handler
                                                                                              (Maybe
                                                                                                 (TreeRevision
                                                                                                    TextElement)))
                                                                                        :<|> ((AuthResult
                                                                                                 Token
                                                                                               -> DocumentID
                                                                                               -> RevisionSelector
                                                                                               -> TextElementID
                                                                                               -> Handler
                                                                                                    (Maybe
                                                                                                       TextElementRevision))
                                                                                              :<|> ((AuthResult
                                                                                                       Token
                                                                                                     -> DocumentID
                                                                                                     -> TextElementID
                                                                                                     -> Handler
                                                                                                          (Maybe
                                                                                                             (Rendered
                                                                                                                DraftRevision)))
                                                                                                    :<|> ((AuthResult
                                                                                                             Token
                                                                                                           -> DocumentID
                                                                                                           -> TextElementID
                                                                                                           -> Handler
                                                                                                                (Rendered
                                                                                                                   ConflictStatus))
                                                                                                          :<|> ((AuthResult
                                                                                                                   Token
                                                                                                                 -> DocumentID
                                                                                                                 -> TextElementID
                                                                                                                 -> Handler
                                                                                                                      ())
                                                                                                                :<|> ((AuthResult
                                                                                                                         Token
                                                                                                                       -> Text
                                                                                                                       -> Handler
                                                                                                                            DocByteString)
                                                                                                                      :<|> (AuthResult
                                                                                                                              Token
                                                                                                                            -> Text
                                                                                                                            -> Handler
                                                                                                                                 PDFByteString)))))))))))))))))))))
-> (AuthResult Token
    -> DocumentID
    -> Node TextElementID
    -> Handler (TreeRevisionWithMetaData TextElementID))
   :<|> ((AuthResult Token
          -> DocumentID
          -> TreeRevisionSelector
          -> Handler (Maybe (TreeRevisionWithMetaData TextElement)))
         :<|> ((AuthResult Token
                -> DocumentID
                -> TreeRevisionSelector
                -> Handler (Maybe (TreeRevisionWithMetaData TextElementRevision)))
               :<|> ((AuthResult Token
                      -> DocumentID -> TreeRevisionSelector -> Handler PDFBytes)
                     :<|> ((AuthResult Token
                            -> DocumentID -> TreeRevisionSelector -> Handler ZipBytes)
                           :<|> ((AuthResult Token
                                  -> DocumentID
                                  -> TextElementID
                                  -> Maybe UTCTime
                                  -> Maybe UTCTime
                                  -> Maybe GroupID
                                  -> Handler TextRevisionHistory)
                                 :<|> ((AuthResult Token
                                        -> DocumentID
                                        -> Maybe UTCTime
                                        -> Maybe GroupID
                                        -> Handler TreeRevisionHistory)
                                       :<|> ((AuthResult Token
                                              -> DocumentID
                                              -> Maybe UTCTime
                                              -> Maybe GroupID
                                              -> Handler DocumentHistory)
                                             :<|> ((AuthResult Token
                                                    -> DocumentID
                                                    -> TextElementID
                                                    -> CreateComment
                                                    -> Handler Comment)
                                                   :<|> ((AuthResult Token
                                                          -> DocumentID
                                                          -> TextElementID
                                                          -> Handler Comments)
                                                         :<|> ((AuthResult Token
                                                                -> DocumentID
                                                                -> TextElementID
                                                                -> CommentID
                                                                -> Handler ())
                                                               :<|> ((AuthResult Token
                                                                      -> DocumentID
                                                                      -> TextElementID
                                                                      -> CommentID
                                                                      -> CreateReply
                                                                      -> Handler Message)
                                                                     :<|> ((AuthResult Token
                                                                            -> DocumentID
                                                                            -> RevisionSelector
                                                                            -> Handler
                                                                                 (FullDocument
                                                                                    TextElementRevision))
                                                                           :<|> ((AuthResult Token
                                                                                  -> DocumentID
                                                                                  -> RevisionSelector
                                                                                  -> Handler
                                                                                       PDFBytes)
                                                                                 :<|> ((AuthResult
                                                                                          Token
                                                                                        -> DocumentID
                                                                                        -> RevisionSelector
                                                                                        -> Handler
                                                                                             ZipBytes)
                                                                                       :<|> ((AuthResult
                                                                                                Token
                                                                                              -> DocumentID
                                                                                              -> RevisionSelector
                                                                                              -> Handler
                                                                                                   (Maybe
                                                                                                      (TreeRevision
                                                                                                         TextElement)))
                                                                                             :<|> ((AuthResult
                                                                                                      Token
                                                                                                    -> DocumentID
                                                                                                    -> RevisionSelector
                                                                                                    -> TextElementID
                                                                                                    -> Handler
                                                                                                         (Maybe
                                                                                                            TextElementRevision))
                                                                                                   :<|> ((AuthResult
                                                                                                            Token
                                                                                                          -> DocumentID
                                                                                                          -> TextElementID
                                                                                                          -> Handler
                                                                                                               (Maybe
                                                                                                                  (Rendered
                                                                                                                     DraftRevision)))
                                                                                                         :<|> ((AuthResult
                                                                                                                  Token
                                                                                                                -> DocumentID
                                                                                                                -> TextElementID
                                                                                                                -> Handler
                                                                                                                     (Rendered
                                                                                                                        ConflictStatus))
                                                                                                               :<|> ((AuthResult
                                                                                                                        Token
                                                                                                                      -> DocumentID
                                                                                                                      -> TextElementID
                                                                                                                      -> Handler
                                                                                                                           ())
                                                                                                                     :<|> ((AuthResult
                                                                                                                              Token
                                                                                                                            -> Text
                                                                                                                            -> Handler
                                                                                                                                 DocByteString)
                                                                                                                           :<|> (AuthResult
                                                                                                                                   Token
                                                                                                                                 -> Text
                                                                                                                                 -> Handler
                                                                                                                                      PDFByteString)))))))))))))))))))))
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token
-> DocumentID
-> TreeRevisionSelector
-> Handler (Maybe (TreeRevisionWithMetaData TextElement))
getTreeRevisionHandler
        (AuthResult Token
 -> DocumentID
 -> TreeRevisionSelector
 -> Handler (Maybe (TreeRevisionWithMetaData TextElement)))
-> ((AuthResult Token
     -> DocumentID
     -> TreeRevisionSelector
     -> Handler (Maybe (TreeRevisionWithMetaData TextElementRevision)))
    :<|> ((AuthResult Token
           -> DocumentID -> TreeRevisionSelector -> Handler PDFBytes)
          :<|> ((AuthResult Token
                 -> DocumentID -> TreeRevisionSelector -> Handler ZipBytes)
                :<|> ((AuthResult Token
                       -> DocumentID
                       -> TextElementID
                       -> Maybe UTCTime
                       -> Maybe UTCTime
                       -> Maybe GroupID
                       -> Handler TextRevisionHistory)
                      :<|> ((AuthResult Token
                             -> DocumentID
                             -> Maybe UTCTime
                             -> Maybe GroupID
                             -> Handler TreeRevisionHistory)
                            :<|> ((AuthResult Token
                                   -> DocumentID
                                   -> Maybe UTCTime
                                   -> Maybe GroupID
                                   -> Handler DocumentHistory)
                                  :<|> ((AuthResult Token
                                         -> DocumentID
                                         -> TextElementID
                                         -> CreateComment
                                         -> Handler Comment)
                                        :<|> ((AuthResult Token
                                               -> DocumentID -> TextElementID -> Handler Comments)
                                              :<|> ((AuthResult Token
                                                     -> DocumentID
                                                     -> TextElementID
                                                     -> CommentID
                                                     -> Handler ())
                                                    :<|> ((AuthResult Token
                                                           -> DocumentID
                                                           -> TextElementID
                                                           -> CommentID
                                                           -> CreateReply
                                                           -> Handler Message)
                                                          :<|> ((AuthResult Token
                                                                 -> DocumentID
                                                                 -> RevisionSelector
                                                                 -> Handler
                                                                      (FullDocument
                                                                         TextElementRevision))
                                                                :<|> ((AuthResult Token
                                                                       -> DocumentID
                                                                       -> RevisionSelector
                                                                       -> Handler PDFBytes)
                                                                      :<|> ((AuthResult Token
                                                                             -> DocumentID
                                                                             -> RevisionSelector
                                                                             -> Handler ZipBytes)
                                                                            :<|> ((AuthResult Token
                                                                                   -> DocumentID
                                                                                   -> RevisionSelector
                                                                                   -> Handler
                                                                                        (Maybe
                                                                                           (TreeRevision
                                                                                              TextElement)))
                                                                                  :<|> ((AuthResult
                                                                                           Token
                                                                                         -> DocumentID
                                                                                         -> RevisionSelector
                                                                                         -> TextElementID
                                                                                         -> Handler
                                                                                              (Maybe
                                                                                                 TextElementRevision))
                                                                                        :<|> ((AuthResult
                                                                                                 Token
                                                                                               -> DocumentID
                                                                                               -> TextElementID
                                                                                               -> Handler
                                                                                                    (Maybe
                                                                                                       (Rendered
                                                                                                          DraftRevision)))
                                                                                              :<|> ((AuthResult
                                                                                                       Token
                                                                                                     -> DocumentID
                                                                                                     -> TextElementID
                                                                                                     -> Handler
                                                                                                          (Rendered
                                                                                                             ConflictStatus))
                                                                                                    :<|> ((AuthResult
                                                                                                             Token
                                                                                                           -> DocumentID
                                                                                                           -> TextElementID
                                                                                                           -> Handler
                                                                                                                ())
                                                                                                          :<|> ((AuthResult
                                                                                                                   Token
                                                                                                                 -> Text
                                                                                                                 -> Handler
                                                                                                                      DocByteString)
                                                                                                                :<|> (AuthResult
                                                                                                                        Token
                                                                                                                      -> Text
                                                                                                                      -> Handler
                                                                                                                           PDFByteString))))))))))))))))))))
-> (AuthResult Token
    -> DocumentID
    -> TreeRevisionSelector
    -> Handler (Maybe (TreeRevisionWithMetaData TextElement)))
   :<|> ((AuthResult Token
          -> DocumentID
          -> TreeRevisionSelector
          -> Handler (Maybe (TreeRevisionWithMetaData TextElementRevision)))
         :<|> ((AuthResult Token
                -> DocumentID -> TreeRevisionSelector -> Handler PDFBytes)
               :<|> ((AuthResult Token
                      -> DocumentID -> TreeRevisionSelector -> Handler ZipBytes)
                     :<|> ((AuthResult Token
                            -> DocumentID
                            -> TextElementID
                            -> Maybe UTCTime
                            -> Maybe UTCTime
                            -> Maybe GroupID
                            -> Handler TextRevisionHistory)
                           :<|> ((AuthResult Token
                                  -> DocumentID
                                  -> Maybe UTCTime
                                  -> Maybe GroupID
                                  -> Handler TreeRevisionHistory)
                                 :<|> ((AuthResult Token
                                        -> DocumentID
                                        -> Maybe UTCTime
                                        -> Maybe GroupID
                                        -> Handler DocumentHistory)
                                       :<|> ((AuthResult Token
                                              -> DocumentID
                                              -> TextElementID
                                              -> CreateComment
                                              -> Handler Comment)
                                             :<|> ((AuthResult Token
                                                    -> DocumentID
                                                    -> TextElementID
                                                    -> Handler Comments)
                                                   :<|> ((AuthResult Token
                                                          -> DocumentID
                                                          -> TextElementID
                                                          -> CommentID
                                                          -> Handler ())
                                                         :<|> ((AuthResult Token
                                                                -> DocumentID
                                                                -> TextElementID
                                                                -> CommentID
                                                                -> CreateReply
                                                                -> Handler Message)
                                                               :<|> ((AuthResult Token
                                                                      -> DocumentID
                                                                      -> RevisionSelector
                                                                      -> Handler
                                                                           (FullDocument
                                                                              TextElementRevision))
                                                                     :<|> ((AuthResult Token
                                                                            -> DocumentID
                                                                            -> RevisionSelector
                                                                            -> Handler PDFBytes)
                                                                           :<|> ((AuthResult Token
                                                                                  -> DocumentID
                                                                                  -> RevisionSelector
                                                                                  -> Handler
                                                                                       ZipBytes)
                                                                                 :<|> ((AuthResult
                                                                                          Token
                                                                                        -> DocumentID
                                                                                        -> RevisionSelector
                                                                                        -> Handler
                                                                                             (Maybe
                                                                                                (TreeRevision
                                                                                                   TextElement)))
                                                                                       :<|> ((AuthResult
                                                                                                Token
                                                                                              -> DocumentID
                                                                                              -> RevisionSelector
                                                                                              -> TextElementID
                                                                                              -> Handler
                                                                                                   (Maybe
                                                                                                      TextElementRevision))
                                                                                             :<|> ((AuthResult
                                                                                                      Token
                                                                                                    -> DocumentID
                                                                                                    -> TextElementID
                                                                                                    -> Handler
                                                                                                         (Maybe
                                                                                                            (Rendered
                                                                                                               DraftRevision)))
                                                                                                   :<|> ((AuthResult
                                                                                                            Token
                                                                                                          -> DocumentID
                                                                                                          -> TextElementID
                                                                                                          -> Handler
                                                                                                               (Rendered
                                                                                                                  ConflictStatus))
                                                                                                         :<|> ((AuthResult
                                                                                                                  Token
                                                                                                                -> DocumentID
                                                                                                                -> TextElementID
                                                                                                                -> Handler
                                                                                                                     ())
                                                                                                               :<|> ((AuthResult
                                                                                                                        Token
                                                                                                                      -> Text
                                                                                                                      -> Handler
                                                                                                                           DocByteString)
                                                                                                                     :<|> (AuthResult
                                                                                                                             Token
                                                                                                                           -> Text
                                                                                                                           -> Handler
                                                                                                                                PDFByteString))))))))))))))))))))
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token
-> DocumentID
-> TreeRevisionSelector
-> Handler (Maybe (TreeRevisionWithMetaData TextElementRevision))
getTreeRevisionFullHandler
        (AuthResult Token
 -> DocumentID
 -> TreeRevisionSelector
 -> Handler (Maybe (TreeRevisionWithMetaData TextElementRevision)))
-> ((AuthResult Token
     -> DocumentID -> TreeRevisionSelector -> Handler PDFBytes)
    :<|> ((AuthResult Token
           -> DocumentID -> TreeRevisionSelector -> Handler ZipBytes)
          :<|> ((AuthResult Token
                 -> DocumentID
                 -> TextElementID
                 -> Maybe UTCTime
                 -> Maybe UTCTime
                 -> Maybe GroupID
                 -> Handler TextRevisionHistory)
                :<|> ((AuthResult Token
                       -> DocumentID
                       -> Maybe UTCTime
                       -> Maybe GroupID
                       -> Handler TreeRevisionHistory)
                      :<|> ((AuthResult Token
                             -> DocumentID
                             -> Maybe UTCTime
                             -> Maybe GroupID
                             -> Handler DocumentHistory)
                            :<|> ((AuthResult Token
                                   -> DocumentID
                                   -> TextElementID
                                   -> CreateComment
                                   -> Handler Comment)
                                  :<|> ((AuthResult Token
                                         -> DocumentID -> TextElementID -> Handler Comments)
                                        :<|> ((AuthResult Token
                                               -> DocumentID
                                               -> TextElementID
                                               -> CommentID
                                               -> Handler ())
                                              :<|> ((AuthResult Token
                                                     -> DocumentID
                                                     -> TextElementID
                                                     -> CommentID
                                                     -> CreateReply
                                                     -> Handler Message)
                                                    :<|> ((AuthResult Token
                                                           -> DocumentID
                                                           -> RevisionSelector
                                                           -> Handler
                                                                (FullDocument TextElementRevision))
                                                          :<|> ((AuthResult Token
                                                                 -> DocumentID
                                                                 -> RevisionSelector
                                                                 -> Handler PDFBytes)
                                                                :<|> ((AuthResult Token
                                                                       -> DocumentID
                                                                       -> RevisionSelector
                                                                       -> Handler ZipBytes)
                                                                      :<|> ((AuthResult Token
                                                                             -> DocumentID
                                                                             -> RevisionSelector
                                                                             -> Handler
                                                                                  (Maybe
                                                                                     (TreeRevision
                                                                                        TextElement)))
                                                                            :<|> ((AuthResult Token
                                                                                   -> DocumentID
                                                                                   -> RevisionSelector
                                                                                   -> TextElementID
                                                                                   -> Handler
                                                                                        (Maybe
                                                                                           TextElementRevision))
                                                                                  :<|> ((AuthResult
                                                                                           Token
                                                                                         -> DocumentID
                                                                                         -> TextElementID
                                                                                         -> Handler
                                                                                              (Maybe
                                                                                                 (Rendered
                                                                                                    DraftRevision)))
                                                                                        :<|> ((AuthResult
                                                                                                 Token
                                                                                               -> DocumentID
                                                                                               -> TextElementID
                                                                                               -> Handler
                                                                                                    (Rendered
                                                                                                       ConflictStatus))
                                                                                              :<|> ((AuthResult
                                                                                                       Token
                                                                                                     -> DocumentID
                                                                                                     -> TextElementID
                                                                                                     -> Handler
                                                                                                          ())
                                                                                                    :<|> ((AuthResult
                                                                                                             Token
                                                                                                           -> Text
                                                                                                           -> Handler
                                                                                                                DocByteString)
                                                                                                          :<|> (AuthResult
                                                                                                                  Token
                                                                                                                -> Text
                                                                                                                -> Handler
                                                                                                                     PDFByteString)))))))))))))))))))
-> (AuthResult Token
    -> DocumentID
    -> TreeRevisionSelector
    -> Handler (Maybe (TreeRevisionWithMetaData TextElementRevision)))
   :<|> ((AuthResult Token
          -> DocumentID -> TreeRevisionSelector -> Handler PDFBytes)
         :<|> ((AuthResult Token
                -> DocumentID -> TreeRevisionSelector -> Handler ZipBytes)
               :<|> ((AuthResult Token
                      -> DocumentID
                      -> TextElementID
                      -> Maybe UTCTime
                      -> Maybe UTCTime
                      -> Maybe GroupID
                      -> Handler TextRevisionHistory)
                     :<|> ((AuthResult Token
                            -> DocumentID
                            -> Maybe UTCTime
                            -> Maybe GroupID
                            -> Handler TreeRevisionHistory)
                           :<|> ((AuthResult Token
                                  -> DocumentID
                                  -> Maybe UTCTime
                                  -> Maybe GroupID
                                  -> Handler DocumentHistory)
                                 :<|> ((AuthResult Token
                                        -> DocumentID
                                        -> TextElementID
                                        -> CreateComment
                                        -> Handler Comment)
                                       :<|> ((AuthResult Token
                                              -> DocumentID -> TextElementID -> Handler Comments)
                                             :<|> ((AuthResult Token
                                                    -> DocumentID
                                                    -> TextElementID
                                                    -> CommentID
                                                    -> Handler ())
                                                   :<|> ((AuthResult Token
                                                          -> DocumentID
                                                          -> TextElementID
                                                          -> CommentID
                                                          -> CreateReply
                                                          -> Handler Message)
                                                         :<|> ((AuthResult Token
                                                                -> DocumentID
                                                                -> RevisionSelector
                                                                -> Handler
                                                                     (FullDocument
                                                                        TextElementRevision))
                                                               :<|> ((AuthResult Token
                                                                      -> DocumentID
                                                                      -> RevisionSelector
                                                                      -> Handler PDFBytes)
                                                                     :<|> ((AuthResult Token
                                                                            -> DocumentID
                                                                            -> RevisionSelector
                                                                            -> Handler ZipBytes)
                                                                           :<|> ((AuthResult Token
                                                                                  -> DocumentID
                                                                                  -> RevisionSelector
                                                                                  -> Handler
                                                                                       (Maybe
                                                                                          (TreeRevision
                                                                                             TextElement)))
                                                                                 :<|> ((AuthResult
                                                                                          Token
                                                                                        -> DocumentID
                                                                                        -> RevisionSelector
                                                                                        -> TextElementID
                                                                                        -> Handler
                                                                                             (Maybe
                                                                                                TextElementRevision))
                                                                                       :<|> ((AuthResult
                                                                                                Token
                                                                                              -> DocumentID
                                                                                              -> TextElementID
                                                                                              -> Handler
                                                                                                   (Maybe
                                                                                                      (Rendered
                                                                                                         DraftRevision)))
                                                                                             :<|> ((AuthResult
                                                                                                      Token
                                                                                                    -> DocumentID
                                                                                                    -> TextElementID
                                                                                                    -> Handler
                                                                                                         (Rendered
                                                                                                            ConflictStatus))
                                                                                                   :<|> ((AuthResult
                                                                                                            Token
                                                                                                          -> DocumentID
                                                                                                          -> TextElementID
                                                                                                          -> Handler
                                                                                                               ())
                                                                                                         :<|> ((AuthResult
                                                                                                                  Token
                                                                                                                -> Text
                                                                                                                -> Handler
                                                                                                                     DocByteString)
                                                                                                               :<|> (AuthResult
                                                                                                                       Token
                                                                                                                     -> Text
                                                                                                                     -> Handler
                                                                                                                          PDFByteString)))))))))))))))))))
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token
-> DocumentID -> TreeRevisionSelector -> Handler PDFBytes
getTreeRevisionPDFHandler
        (AuthResult Token
 -> DocumentID -> TreeRevisionSelector -> Handler PDFBytes)
-> ((AuthResult Token
     -> DocumentID -> TreeRevisionSelector -> Handler ZipBytes)
    :<|> ((AuthResult Token
           -> DocumentID
           -> TextElementID
           -> Maybe UTCTime
           -> Maybe UTCTime
           -> Maybe GroupID
           -> Handler TextRevisionHistory)
          :<|> ((AuthResult Token
                 -> DocumentID
                 -> Maybe UTCTime
                 -> Maybe GroupID
                 -> Handler TreeRevisionHistory)
                :<|> ((AuthResult Token
                       -> DocumentID
                       -> Maybe UTCTime
                       -> Maybe GroupID
                       -> Handler DocumentHistory)
                      :<|> ((AuthResult Token
                             -> DocumentID -> TextElementID -> CreateComment -> Handler Comment)
                            :<|> ((AuthResult Token
                                   -> DocumentID -> TextElementID -> Handler Comments)
                                  :<|> ((AuthResult Token
                                         -> DocumentID -> TextElementID -> CommentID -> Handler ())
                                        :<|> ((AuthResult Token
                                               -> DocumentID
                                               -> TextElementID
                                               -> CommentID
                                               -> CreateReply
                                               -> Handler Message)
                                              :<|> ((AuthResult Token
                                                     -> DocumentID
                                                     -> RevisionSelector
                                                     -> Handler (FullDocument TextElementRevision))
                                                    :<|> ((AuthResult Token
                                                           -> DocumentID
                                                           -> RevisionSelector
                                                           -> Handler PDFBytes)
                                                          :<|> ((AuthResult Token
                                                                 -> DocumentID
                                                                 -> RevisionSelector
                                                                 -> Handler ZipBytes)
                                                                :<|> ((AuthResult Token
                                                                       -> DocumentID
                                                                       -> RevisionSelector
                                                                       -> Handler
                                                                            (Maybe
                                                                               (TreeRevision
                                                                                  TextElement)))
                                                                      :<|> ((AuthResult Token
                                                                             -> DocumentID
                                                                             -> RevisionSelector
                                                                             -> TextElementID
                                                                             -> Handler
                                                                                  (Maybe
                                                                                     TextElementRevision))
                                                                            :<|> ((AuthResult Token
                                                                                   -> DocumentID
                                                                                   -> TextElementID
                                                                                   -> Handler
                                                                                        (Maybe
                                                                                           (Rendered
                                                                                              DraftRevision)))
                                                                                  :<|> ((AuthResult
                                                                                           Token
                                                                                         -> DocumentID
                                                                                         -> TextElementID
                                                                                         -> Handler
                                                                                              (Rendered
                                                                                                 ConflictStatus))
                                                                                        :<|> ((AuthResult
                                                                                                 Token
                                                                                               -> DocumentID
                                                                                               -> TextElementID
                                                                                               -> Handler
                                                                                                    ())
                                                                                              :<|> ((AuthResult
                                                                                                       Token
                                                                                                     -> Text
                                                                                                     -> Handler
                                                                                                          DocByteString)
                                                                                                    :<|> (AuthResult
                                                                                                            Token
                                                                                                          -> Text
                                                                                                          -> Handler
                                                                                                               PDFByteString))))))))))))))))))
-> (AuthResult Token
    -> DocumentID -> TreeRevisionSelector -> Handler PDFBytes)
   :<|> ((AuthResult Token
          -> DocumentID -> TreeRevisionSelector -> Handler ZipBytes)
         :<|> ((AuthResult Token
                -> DocumentID
                -> TextElementID
                -> Maybe UTCTime
                -> Maybe UTCTime
                -> Maybe GroupID
                -> Handler TextRevisionHistory)
               :<|> ((AuthResult Token
                      -> DocumentID
                      -> Maybe UTCTime
                      -> Maybe GroupID
                      -> Handler TreeRevisionHistory)
                     :<|> ((AuthResult Token
                            -> DocumentID
                            -> Maybe UTCTime
                            -> Maybe GroupID
                            -> Handler DocumentHistory)
                           :<|> ((AuthResult Token
                                  -> DocumentID
                                  -> TextElementID
                                  -> CreateComment
                                  -> Handler Comment)
                                 :<|> ((AuthResult Token
                                        -> DocumentID -> TextElementID -> Handler Comments)
                                       :<|> ((AuthResult Token
                                              -> DocumentID
                                              -> TextElementID
                                              -> CommentID
                                              -> Handler ())
                                             :<|> ((AuthResult Token
                                                    -> DocumentID
                                                    -> TextElementID
                                                    -> CommentID
                                                    -> CreateReply
                                                    -> Handler Message)
                                                   :<|> ((AuthResult Token
                                                          -> DocumentID
                                                          -> RevisionSelector
                                                          -> Handler
                                                               (FullDocument TextElementRevision))
                                                         :<|> ((AuthResult Token
                                                                -> DocumentID
                                                                -> RevisionSelector
                                                                -> Handler PDFBytes)
                                                               :<|> ((AuthResult Token
                                                                      -> DocumentID
                                                                      -> RevisionSelector
                                                                      -> Handler ZipBytes)
                                                                     :<|> ((AuthResult Token
                                                                            -> DocumentID
                                                                            -> RevisionSelector
                                                                            -> Handler
                                                                                 (Maybe
                                                                                    (TreeRevision
                                                                                       TextElement)))
                                                                           :<|> ((AuthResult Token
                                                                                  -> DocumentID
                                                                                  -> RevisionSelector
                                                                                  -> TextElementID
                                                                                  -> Handler
                                                                                       (Maybe
                                                                                          TextElementRevision))
                                                                                 :<|> ((AuthResult
                                                                                          Token
                                                                                        -> DocumentID
                                                                                        -> TextElementID
                                                                                        -> Handler
                                                                                             (Maybe
                                                                                                (Rendered
                                                                                                   DraftRevision)))
                                                                                       :<|> ((AuthResult
                                                                                                Token
                                                                                              -> DocumentID
                                                                                              -> TextElementID
                                                                                              -> Handler
                                                                                                   (Rendered
                                                                                                      ConflictStatus))
                                                                                             :<|> ((AuthResult
                                                                                                      Token
                                                                                                    -> DocumentID
                                                                                                    -> TextElementID
                                                                                                    -> Handler
                                                                                                         ())
                                                                                                   :<|> ((AuthResult
                                                                                                            Token
                                                                                                          -> Text
                                                                                                          -> Handler
                                                                                                               DocByteString)
                                                                                                         :<|> (AuthResult
                                                                                                                 Token
                                                                                                               -> Text
                                                                                                               -> Handler
                                                                                                                    PDFByteString))))))))))))))))))
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token
-> DocumentID -> TreeRevisionSelector -> Handler ZipBytes
getTreeRevisionHTMLHandler
        (AuthResult Token
 -> DocumentID -> TreeRevisionSelector -> Handler ZipBytes)
-> ((AuthResult Token
     -> DocumentID
     -> TextElementID
     -> Maybe UTCTime
     -> Maybe UTCTime
     -> Maybe GroupID
     -> Handler TextRevisionHistory)
    :<|> ((AuthResult Token
           -> DocumentID
           -> Maybe UTCTime
           -> Maybe GroupID
           -> Handler TreeRevisionHistory)
          :<|> ((AuthResult Token
                 -> DocumentID
                 -> Maybe UTCTime
                 -> Maybe GroupID
                 -> Handler DocumentHistory)
                :<|> ((AuthResult Token
                       -> DocumentID -> TextElementID -> CreateComment -> Handler Comment)
                      :<|> ((AuthResult Token
                             -> DocumentID -> TextElementID -> Handler Comments)
                            :<|> ((AuthResult Token
                                   -> DocumentID -> TextElementID -> CommentID -> Handler ())
                                  :<|> ((AuthResult Token
                                         -> DocumentID
                                         -> TextElementID
                                         -> CommentID
                                         -> CreateReply
                                         -> Handler Message)
                                        :<|> ((AuthResult Token
                                               -> DocumentID
                                               -> RevisionSelector
                                               -> Handler (FullDocument TextElementRevision))
                                              :<|> ((AuthResult Token
                                                     -> DocumentID
                                                     -> RevisionSelector
                                                     -> Handler PDFBytes)
                                                    :<|> ((AuthResult Token
                                                           -> DocumentID
                                                           -> RevisionSelector
                                                           -> Handler ZipBytes)
                                                          :<|> ((AuthResult Token
                                                                 -> DocumentID
                                                                 -> RevisionSelector
                                                                 -> Handler
                                                                      (Maybe
                                                                         (TreeRevision
                                                                            TextElement)))
                                                                :<|> ((AuthResult Token
                                                                       -> DocumentID
                                                                       -> RevisionSelector
                                                                       -> TextElementID
                                                                       -> Handler
                                                                            (Maybe
                                                                               TextElementRevision))
                                                                      :<|> ((AuthResult Token
                                                                             -> DocumentID
                                                                             -> TextElementID
                                                                             -> Handler
                                                                                  (Maybe
                                                                                     (Rendered
                                                                                        DraftRevision)))
                                                                            :<|> ((AuthResult Token
                                                                                   -> DocumentID
                                                                                   -> TextElementID
                                                                                   -> Handler
                                                                                        (Rendered
                                                                                           ConflictStatus))
                                                                                  :<|> ((AuthResult
                                                                                           Token
                                                                                         -> DocumentID
                                                                                         -> TextElementID
                                                                                         -> Handler
                                                                                              ())
                                                                                        :<|> ((AuthResult
                                                                                                 Token
                                                                                               -> Text
                                                                                               -> Handler
                                                                                                    DocByteString)
                                                                                              :<|> (AuthResult
                                                                                                      Token
                                                                                                    -> Text
                                                                                                    -> Handler
                                                                                                         PDFByteString)))))))))))))))))
-> (AuthResult Token
    -> DocumentID -> TreeRevisionSelector -> Handler ZipBytes)
   :<|> ((AuthResult Token
          -> DocumentID
          -> TextElementID
          -> Maybe UTCTime
          -> Maybe UTCTime
          -> Maybe GroupID
          -> Handler TextRevisionHistory)
         :<|> ((AuthResult Token
                -> DocumentID
                -> Maybe UTCTime
                -> Maybe GroupID
                -> Handler TreeRevisionHistory)
               :<|> ((AuthResult Token
                      -> DocumentID
                      -> Maybe UTCTime
                      -> Maybe GroupID
                      -> Handler DocumentHistory)
                     :<|> ((AuthResult Token
                            -> DocumentID -> TextElementID -> CreateComment -> Handler Comment)
                           :<|> ((AuthResult Token
                                  -> DocumentID -> TextElementID -> Handler Comments)
                                 :<|> ((AuthResult Token
                                        -> DocumentID -> TextElementID -> CommentID -> Handler ())
                                       :<|> ((AuthResult Token
                                              -> DocumentID
                                              -> TextElementID
                                              -> CommentID
                                              -> CreateReply
                                              -> Handler Message)
                                             :<|> ((AuthResult Token
                                                    -> DocumentID
                                                    -> RevisionSelector
                                                    -> Handler (FullDocument TextElementRevision))
                                                   :<|> ((AuthResult Token
                                                          -> DocumentID
                                                          -> RevisionSelector
                                                          -> Handler PDFBytes)
                                                         :<|> ((AuthResult Token
                                                                -> DocumentID
                                                                -> RevisionSelector
                                                                -> Handler ZipBytes)
                                                               :<|> ((AuthResult Token
                                                                      -> DocumentID
                                                                      -> RevisionSelector
                                                                      -> Handler
                                                                           (Maybe
                                                                              (TreeRevision
                                                                                 TextElement)))
                                                                     :<|> ((AuthResult Token
                                                                            -> DocumentID
                                                                            -> RevisionSelector
                                                                            -> TextElementID
                                                                            -> Handler
                                                                                 (Maybe
                                                                                    TextElementRevision))
                                                                           :<|> ((AuthResult Token
                                                                                  -> DocumentID
                                                                                  -> TextElementID
                                                                                  -> Handler
                                                                                       (Maybe
                                                                                          (Rendered
                                                                                             DraftRevision)))
                                                                                 :<|> ((AuthResult
                                                                                          Token
                                                                                        -> DocumentID
                                                                                        -> TextElementID
                                                                                        -> Handler
                                                                                             (Rendered
                                                                                                ConflictStatus))
                                                                                       :<|> ((AuthResult
                                                                                                Token
                                                                                              -> DocumentID
                                                                                              -> TextElementID
                                                                                              -> Handler
                                                                                                   ())
                                                                                             :<|> ((AuthResult
                                                                                                      Token
                                                                                                    -> Text
                                                                                                    -> Handler
                                                                                                         DocByteString)
                                                                                                   :<|> (AuthResult
                                                                                                           Token
                                                                                                         -> Text
                                                                                                         -> Handler
                                                                                                              PDFByteString)))))))))))))))))
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token
-> DocumentID
-> TextElementID
-> Maybe UTCTime
-> Maybe UTCTime
-> Maybe GroupID
-> Handler TextRevisionHistory
getTextHistoryHandler
        (AuthResult Token
 -> DocumentID
 -> TextElementID
 -> Maybe UTCTime
 -> Maybe UTCTime
 -> Maybe GroupID
 -> Handler TextRevisionHistory)
-> ((AuthResult Token
     -> DocumentID
     -> Maybe UTCTime
     -> Maybe GroupID
     -> Handler TreeRevisionHistory)
    :<|> ((AuthResult Token
           -> DocumentID
           -> Maybe UTCTime
           -> Maybe GroupID
           -> Handler DocumentHistory)
          :<|> ((AuthResult Token
                 -> DocumentID -> TextElementID -> CreateComment -> Handler Comment)
                :<|> ((AuthResult Token
                       -> DocumentID -> TextElementID -> Handler Comments)
                      :<|> ((AuthResult Token
                             -> DocumentID -> TextElementID -> CommentID -> Handler ())
                            :<|> ((AuthResult Token
                                   -> DocumentID
                                   -> TextElementID
                                   -> CommentID
                                   -> CreateReply
                                   -> Handler Message)
                                  :<|> ((AuthResult Token
                                         -> DocumentID
                                         -> RevisionSelector
                                         -> Handler (FullDocument TextElementRevision))
                                        :<|> ((AuthResult Token
                                               -> DocumentID
                                               -> RevisionSelector
                                               -> Handler PDFBytes)
                                              :<|> ((AuthResult Token
                                                     -> DocumentID
                                                     -> RevisionSelector
                                                     -> Handler ZipBytes)
                                                    :<|> ((AuthResult Token
                                                           -> DocumentID
                                                           -> RevisionSelector
                                                           -> Handler
                                                                (Maybe (TreeRevision TextElement)))
                                                          :<|> ((AuthResult Token
                                                                 -> DocumentID
                                                                 -> RevisionSelector
                                                                 -> TextElementID
                                                                 -> Handler
                                                                      (Maybe TextElementRevision))
                                                                :<|> ((AuthResult Token
                                                                       -> DocumentID
                                                                       -> TextElementID
                                                                       -> Handler
                                                                            (Maybe
                                                                               (Rendered
                                                                                  DraftRevision)))
                                                                      :<|> ((AuthResult Token
                                                                             -> DocumentID
                                                                             -> TextElementID
                                                                             -> Handler
                                                                                  (Rendered
                                                                                     ConflictStatus))
                                                                            :<|> ((AuthResult Token
                                                                                   -> DocumentID
                                                                                   -> TextElementID
                                                                                   -> Handler ())
                                                                                  :<|> ((AuthResult
                                                                                           Token
                                                                                         -> Text
                                                                                         -> Handler
                                                                                              DocByteString)
                                                                                        :<|> (AuthResult
                                                                                                Token
                                                                                              -> Text
                                                                                              -> Handler
                                                                                                   PDFByteString))))))))))))))))
-> (AuthResult Token
    -> DocumentID
    -> TextElementID
    -> Maybe UTCTime
    -> Maybe UTCTime
    -> Maybe GroupID
    -> Handler TextRevisionHistory)
   :<|> ((AuthResult Token
          -> DocumentID
          -> Maybe UTCTime
          -> Maybe GroupID
          -> Handler TreeRevisionHistory)
         :<|> ((AuthResult Token
                -> DocumentID
                -> Maybe UTCTime
                -> Maybe GroupID
                -> Handler DocumentHistory)
               :<|> ((AuthResult Token
                      -> DocumentID -> TextElementID -> CreateComment -> Handler Comment)
                     :<|> ((AuthResult Token
                            -> DocumentID -> TextElementID -> Handler Comments)
                           :<|> ((AuthResult Token
                                  -> DocumentID -> TextElementID -> CommentID -> Handler ())
                                 :<|> ((AuthResult Token
                                        -> DocumentID
                                        -> TextElementID
                                        -> CommentID
                                        -> CreateReply
                                        -> Handler Message)
                                       :<|> ((AuthResult Token
                                              -> DocumentID
                                              -> RevisionSelector
                                              -> Handler (FullDocument TextElementRevision))
                                             :<|> ((AuthResult Token
                                                    -> DocumentID
                                                    -> RevisionSelector
                                                    -> Handler PDFBytes)
                                                   :<|> ((AuthResult Token
                                                          -> DocumentID
                                                          -> RevisionSelector
                                                          -> Handler ZipBytes)
                                                         :<|> ((AuthResult Token
                                                                -> DocumentID
                                                                -> RevisionSelector
                                                                -> Handler
                                                                     (Maybe
                                                                        (TreeRevision TextElement)))
                                                               :<|> ((AuthResult Token
                                                                      -> DocumentID
                                                                      -> RevisionSelector
                                                                      -> TextElementID
                                                                      -> Handler
                                                                           (Maybe
                                                                              TextElementRevision))
                                                                     :<|> ((AuthResult Token
                                                                            -> DocumentID
                                                                            -> TextElementID
                                                                            -> Handler
                                                                                 (Maybe
                                                                                    (Rendered
                                                                                       DraftRevision)))
                                                                           :<|> ((AuthResult Token
                                                                                  -> DocumentID
                                                                                  -> TextElementID
                                                                                  -> Handler
                                                                                       (Rendered
                                                                                          ConflictStatus))
                                                                                 :<|> ((AuthResult
                                                                                          Token
                                                                                        -> DocumentID
                                                                                        -> TextElementID
                                                                                        -> Handler
                                                                                             ())
                                                                                       :<|> ((AuthResult
                                                                                                Token
                                                                                              -> Text
                                                                                              -> Handler
                                                                                                   DocByteString)
                                                                                             :<|> (AuthResult
                                                                                                     Token
                                                                                                   -> Text
                                                                                                   -> Handler
                                                                                                        PDFByteString))))))))))))))))
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token
-> DocumentID
-> Maybe UTCTime
-> Maybe GroupID
-> Handler TreeRevisionHistory
getTreeHistoryHandler
        (AuthResult Token
 -> DocumentID
 -> Maybe UTCTime
 -> Maybe GroupID
 -> Handler TreeRevisionHistory)
-> ((AuthResult Token
     -> DocumentID
     -> Maybe UTCTime
     -> Maybe GroupID
     -> Handler DocumentHistory)
    :<|> ((AuthResult Token
           -> DocumentID -> TextElementID -> CreateComment -> Handler Comment)
          :<|> ((AuthResult Token
                 -> DocumentID -> TextElementID -> Handler Comments)
                :<|> ((AuthResult Token
                       -> DocumentID -> TextElementID -> CommentID -> Handler ())
                      :<|> ((AuthResult Token
                             -> DocumentID
                             -> TextElementID
                             -> CommentID
                             -> CreateReply
                             -> Handler Message)
                            :<|> ((AuthResult Token
                                   -> DocumentID
                                   -> RevisionSelector
                                   -> Handler (FullDocument TextElementRevision))
                                  :<|> ((AuthResult Token
                                         -> DocumentID -> RevisionSelector -> Handler PDFBytes)
                                        :<|> ((AuthResult Token
                                               -> DocumentID
                                               -> RevisionSelector
                                               -> Handler ZipBytes)
                                              :<|> ((AuthResult Token
                                                     -> DocumentID
                                                     -> RevisionSelector
                                                     -> Handler (Maybe (TreeRevision TextElement)))
                                                    :<|> ((AuthResult Token
                                                           -> DocumentID
                                                           -> RevisionSelector
                                                           -> TextElementID
                                                           -> Handler (Maybe TextElementRevision))
                                                          :<|> ((AuthResult Token
                                                                 -> DocumentID
                                                                 -> TextElementID
                                                                 -> Handler
                                                                      (Maybe
                                                                         (Rendered DraftRevision)))
                                                                :<|> ((AuthResult Token
                                                                       -> DocumentID
                                                                       -> TextElementID
                                                                       -> Handler
                                                                            (Rendered
                                                                               ConflictStatus))
                                                                      :<|> ((AuthResult Token
                                                                             -> DocumentID
                                                                             -> TextElementID
                                                                             -> Handler ())
                                                                            :<|> ((AuthResult Token
                                                                                   -> Text
                                                                                   -> Handler
                                                                                        DocByteString)
                                                                                  :<|> (AuthResult
                                                                                          Token
                                                                                        -> Text
                                                                                        -> Handler
                                                                                             PDFByteString)))))))))))))))
-> (AuthResult Token
    -> DocumentID
    -> Maybe UTCTime
    -> Maybe GroupID
    -> Handler TreeRevisionHistory)
   :<|> ((AuthResult Token
          -> DocumentID
          -> Maybe UTCTime
          -> Maybe GroupID
          -> Handler DocumentHistory)
         :<|> ((AuthResult Token
                -> DocumentID -> TextElementID -> CreateComment -> Handler Comment)
               :<|> ((AuthResult Token
                      -> DocumentID -> TextElementID -> Handler Comments)
                     :<|> ((AuthResult Token
                            -> DocumentID -> TextElementID -> CommentID -> Handler ())
                           :<|> ((AuthResult Token
                                  -> DocumentID
                                  -> TextElementID
                                  -> CommentID
                                  -> CreateReply
                                  -> Handler Message)
                                 :<|> ((AuthResult Token
                                        -> DocumentID
                                        -> RevisionSelector
                                        -> Handler (FullDocument TextElementRevision))
                                       :<|> ((AuthResult Token
                                              -> DocumentID -> RevisionSelector -> Handler PDFBytes)
                                             :<|> ((AuthResult Token
                                                    -> DocumentID
                                                    -> RevisionSelector
                                                    -> Handler ZipBytes)
                                                   :<|> ((AuthResult Token
                                                          -> DocumentID
                                                          -> RevisionSelector
                                                          -> Handler
                                                               (Maybe (TreeRevision TextElement)))
                                                         :<|> ((AuthResult Token
                                                                -> DocumentID
                                                                -> RevisionSelector
                                                                -> TextElementID
                                                                -> Handler
                                                                     (Maybe TextElementRevision))
                                                               :<|> ((AuthResult Token
                                                                      -> DocumentID
                                                                      -> TextElementID
                                                                      -> Handler
                                                                           (Maybe
                                                                              (Rendered
                                                                                 DraftRevision)))
                                                                     :<|> ((AuthResult Token
                                                                            -> DocumentID
                                                                            -> TextElementID
                                                                            -> Handler
                                                                                 (Rendered
                                                                                    ConflictStatus))
                                                                           :<|> ((AuthResult Token
                                                                                  -> DocumentID
                                                                                  -> TextElementID
                                                                                  -> Handler ())
                                                                                 :<|> ((AuthResult
                                                                                          Token
                                                                                        -> Text
                                                                                        -> Handler
                                                                                             DocByteString)
                                                                                       :<|> (AuthResult
                                                                                               Token
                                                                                             -> Text
                                                                                             -> Handler
                                                                                                  PDFByteString)))))))))))))))
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token
-> DocumentID
-> Maybe UTCTime
-> Maybe GroupID
-> Handler DocumentHistory
getDocumentHistoryHandler
        (AuthResult Token
 -> DocumentID
 -> Maybe UTCTime
 -> Maybe GroupID
 -> Handler DocumentHistory)
-> ((AuthResult Token
     -> DocumentID -> TextElementID -> CreateComment -> Handler Comment)
    :<|> ((AuthResult Token
           -> DocumentID -> TextElementID -> Handler Comments)
          :<|> ((AuthResult Token
                 -> DocumentID -> TextElementID -> CommentID -> Handler ())
                :<|> ((AuthResult Token
                       -> DocumentID
                       -> TextElementID
                       -> CommentID
                       -> CreateReply
                       -> Handler Message)
                      :<|> ((AuthResult Token
                             -> DocumentID
                             -> RevisionSelector
                             -> Handler (FullDocument TextElementRevision))
                            :<|> ((AuthResult Token
                                   -> DocumentID -> RevisionSelector -> Handler PDFBytes)
                                  :<|> ((AuthResult Token
                                         -> DocumentID -> RevisionSelector -> Handler ZipBytes)
                                        :<|> ((AuthResult Token
                                               -> DocumentID
                                               -> RevisionSelector
                                               -> Handler (Maybe (TreeRevision TextElement)))
                                              :<|> ((AuthResult Token
                                                     -> DocumentID
                                                     -> RevisionSelector
                                                     -> TextElementID
                                                     -> Handler (Maybe TextElementRevision))
                                                    :<|> ((AuthResult Token
                                                           -> DocumentID
                                                           -> TextElementID
                                                           -> Handler
                                                                (Maybe (Rendered DraftRevision)))
                                                          :<|> ((AuthResult Token
                                                                 -> DocumentID
                                                                 -> TextElementID
                                                                 -> Handler
                                                                      (Rendered ConflictStatus))
                                                                :<|> ((AuthResult Token
                                                                       -> DocumentID
                                                                       -> TextElementID
                                                                       -> Handler ())
                                                                      :<|> ((AuthResult Token
                                                                             -> Text
                                                                             -> Handler
                                                                                  DocByteString)
                                                                            :<|> (AuthResult Token
                                                                                  -> Text
                                                                                  -> Handler
                                                                                       PDFByteString))))))))))))))
-> (AuthResult Token
    -> DocumentID
    -> Maybe UTCTime
    -> Maybe GroupID
    -> Handler DocumentHistory)
   :<|> ((AuthResult Token
          -> DocumentID -> TextElementID -> CreateComment -> Handler Comment)
         :<|> ((AuthResult Token
                -> DocumentID -> TextElementID -> Handler Comments)
               :<|> ((AuthResult Token
                      -> DocumentID -> TextElementID -> CommentID -> Handler ())
                     :<|> ((AuthResult Token
                            -> DocumentID
                            -> TextElementID
                            -> CommentID
                            -> CreateReply
                            -> Handler Message)
                           :<|> ((AuthResult Token
                                  -> DocumentID
                                  -> RevisionSelector
                                  -> Handler (FullDocument TextElementRevision))
                                 :<|> ((AuthResult Token
                                        -> DocumentID -> RevisionSelector -> Handler PDFBytes)
                                       :<|> ((AuthResult Token
                                              -> DocumentID -> RevisionSelector -> Handler ZipBytes)
                                             :<|> ((AuthResult Token
                                                    -> DocumentID
                                                    -> RevisionSelector
                                                    -> Handler (Maybe (TreeRevision TextElement)))
                                                   :<|> ((AuthResult Token
                                                          -> DocumentID
                                                          -> RevisionSelector
                                                          -> TextElementID
                                                          -> Handler (Maybe TextElementRevision))
                                                         :<|> ((AuthResult Token
                                                                -> DocumentID
                                                                -> TextElementID
                                                                -> Handler
                                                                     (Maybe
                                                                        (Rendered DraftRevision)))
                                                               :<|> ((AuthResult Token
                                                                      -> DocumentID
                                                                      -> TextElementID
                                                                      -> Handler
                                                                           (Rendered
                                                                              ConflictStatus))
                                                                     :<|> ((AuthResult Token
                                                                            -> DocumentID
                                                                            -> TextElementID
                                                                            -> Handler ())
                                                                           :<|> ((AuthResult Token
                                                                                  -> Text
                                                                                  -> Handler
                                                                                       DocByteString)
                                                                                 :<|> (AuthResult
                                                                                         Token
                                                                                       -> Text
                                                                                       -> Handler
                                                                                            PDFByteString))))))))))))))
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token
-> DocumentID -> TextElementID -> CreateComment -> Handler Comment
postCommentHandler
        (AuthResult Token
 -> DocumentID -> TextElementID -> CreateComment -> Handler Comment)
-> ((AuthResult Token
     -> DocumentID -> TextElementID -> Handler Comments)
    :<|> ((AuthResult Token
           -> DocumentID -> TextElementID -> CommentID -> Handler ())
          :<|> ((AuthResult Token
                 -> DocumentID
                 -> TextElementID
                 -> CommentID
                 -> CreateReply
                 -> Handler Message)
                :<|> ((AuthResult Token
                       -> DocumentID
                       -> RevisionSelector
                       -> Handler (FullDocument TextElementRevision))
                      :<|> ((AuthResult Token
                             -> DocumentID -> RevisionSelector -> Handler PDFBytes)
                            :<|> ((AuthResult Token
                                   -> DocumentID -> RevisionSelector -> Handler ZipBytes)
                                  :<|> ((AuthResult Token
                                         -> DocumentID
                                         -> RevisionSelector
                                         -> Handler (Maybe (TreeRevision TextElement)))
                                        :<|> ((AuthResult Token
                                               -> DocumentID
                                               -> RevisionSelector
                                               -> TextElementID
                                               -> Handler (Maybe TextElementRevision))
                                              :<|> ((AuthResult Token
                                                     -> DocumentID
                                                     -> TextElementID
                                                     -> Handler (Maybe (Rendered DraftRevision)))
                                                    :<|> ((AuthResult Token
                                                           -> DocumentID
                                                           -> TextElementID
                                                           -> Handler (Rendered ConflictStatus))
                                                          :<|> ((AuthResult Token
                                                                 -> DocumentID
                                                                 -> TextElementID
                                                                 -> Handler ())
                                                                :<|> ((AuthResult Token
                                                                       -> Text
                                                                       -> Handler DocByteString)
                                                                      :<|> (AuthResult Token
                                                                            -> Text
                                                                            -> Handler
                                                                                 PDFByteString)))))))))))))
-> (AuthResult Token
    -> DocumentID -> TextElementID -> CreateComment -> Handler Comment)
   :<|> ((AuthResult Token
          -> DocumentID -> TextElementID -> Handler Comments)
         :<|> ((AuthResult Token
                -> DocumentID -> TextElementID -> CommentID -> Handler ())
               :<|> ((AuthResult Token
                      -> DocumentID
                      -> TextElementID
                      -> CommentID
                      -> CreateReply
                      -> Handler Message)
                     :<|> ((AuthResult Token
                            -> DocumentID
                            -> RevisionSelector
                            -> Handler (FullDocument TextElementRevision))
                           :<|> ((AuthResult Token
                                  -> DocumentID -> RevisionSelector -> Handler PDFBytes)
                                 :<|> ((AuthResult Token
                                        -> DocumentID -> RevisionSelector -> Handler ZipBytes)
                                       :<|> ((AuthResult Token
                                              -> DocumentID
                                              -> RevisionSelector
                                              -> Handler (Maybe (TreeRevision TextElement)))
                                             :<|> ((AuthResult Token
                                                    -> DocumentID
                                                    -> RevisionSelector
                                                    -> TextElementID
                                                    -> Handler (Maybe TextElementRevision))
                                                   :<|> ((AuthResult Token
                                                          -> DocumentID
                                                          -> TextElementID
                                                          -> Handler
                                                               (Maybe (Rendered DraftRevision)))
                                                         :<|> ((AuthResult Token
                                                                -> DocumentID
                                                                -> TextElementID
                                                                -> Handler
                                                                     (Rendered ConflictStatus))
                                                               :<|> ((AuthResult Token
                                                                      -> DocumentID
                                                                      -> TextElementID
                                                                      -> Handler ())
                                                                     :<|> ((AuthResult Token
                                                                            -> Text
                                                                            -> Handler
                                                                                 DocByteString)
                                                                           :<|> (AuthResult Token
                                                                                 -> Text
                                                                                 -> Handler
                                                                                      PDFByteString)))))))))))))
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token -> DocumentID -> TextElementID -> Handler Comments
getCommentsHandler
        (AuthResult Token
 -> DocumentID -> TextElementID -> Handler Comments)
-> ((AuthResult Token
     -> DocumentID -> TextElementID -> CommentID -> Handler ())
    :<|> ((AuthResult Token
           -> DocumentID
           -> TextElementID
           -> CommentID
           -> CreateReply
           -> Handler Message)
          :<|> ((AuthResult Token
                 -> DocumentID
                 -> RevisionSelector
                 -> Handler (FullDocument TextElementRevision))
                :<|> ((AuthResult Token
                       -> DocumentID -> RevisionSelector -> Handler PDFBytes)
                      :<|> ((AuthResult Token
                             -> DocumentID -> RevisionSelector -> Handler ZipBytes)
                            :<|> ((AuthResult Token
                                   -> DocumentID
                                   -> RevisionSelector
                                   -> Handler (Maybe (TreeRevision TextElement)))
                                  :<|> ((AuthResult Token
                                         -> DocumentID
                                         -> RevisionSelector
                                         -> TextElementID
                                         -> Handler (Maybe TextElementRevision))
                                        :<|> ((AuthResult Token
                                               -> DocumentID
                                               -> TextElementID
                                               -> Handler (Maybe (Rendered DraftRevision)))
                                              :<|> ((AuthResult Token
                                                     -> DocumentID
                                                     -> TextElementID
                                                     -> Handler (Rendered ConflictStatus))
                                                    :<|> ((AuthResult Token
                                                           -> DocumentID
                                                           -> TextElementID
                                                           -> Handler ())
                                                          :<|> ((AuthResult Token
                                                                 -> Text -> Handler DocByteString)
                                                                :<|> (AuthResult Token
                                                                      -> Text
                                                                      -> Handler
                                                                           PDFByteString))))))))))))
-> (AuthResult Token
    -> DocumentID -> TextElementID -> Handler Comments)
   :<|> ((AuthResult Token
          -> DocumentID -> TextElementID -> CommentID -> Handler ())
         :<|> ((AuthResult Token
                -> DocumentID
                -> TextElementID
                -> CommentID
                -> CreateReply
                -> Handler Message)
               :<|> ((AuthResult Token
                      -> DocumentID
                      -> RevisionSelector
                      -> Handler (FullDocument TextElementRevision))
                     :<|> ((AuthResult Token
                            -> DocumentID -> RevisionSelector -> Handler PDFBytes)
                           :<|> ((AuthResult Token
                                  -> DocumentID -> RevisionSelector -> Handler ZipBytes)
                                 :<|> ((AuthResult Token
                                        -> DocumentID
                                        -> RevisionSelector
                                        -> Handler (Maybe (TreeRevision TextElement)))
                                       :<|> ((AuthResult Token
                                              -> DocumentID
                                              -> RevisionSelector
                                              -> TextElementID
                                              -> Handler (Maybe TextElementRevision))
                                             :<|> ((AuthResult Token
                                                    -> DocumentID
                                                    -> TextElementID
                                                    -> Handler (Maybe (Rendered DraftRevision)))
                                                   :<|> ((AuthResult Token
                                                          -> DocumentID
                                                          -> TextElementID
                                                          -> Handler (Rendered ConflictStatus))
                                                         :<|> ((AuthResult Token
                                                                -> DocumentID
                                                                -> TextElementID
                                                                -> Handler ())
                                                               :<|> ((AuthResult Token
                                                                      -> Text
                                                                      -> Handler DocByteString)
                                                                     :<|> (AuthResult Token
                                                                           -> Text
                                                                           -> Handler
                                                                                PDFByteString))))))))))))
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token
-> DocumentID -> TextElementID -> CommentID -> Handler ()
resolveCommentHandler
        (AuthResult Token
 -> DocumentID -> TextElementID -> CommentID -> Handler ())
-> ((AuthResult Token
     -> DocumentID
     -> TextElementID
     -> CommentID
     -> CreateReply
     -> Handler Message)
    :<|> ((AuthResult Token
           -> DocumentID
           -> RevisionSelector
           -> Handler (FullDocument TextElementRevision))
          :<|> ((AuthResult Token
                 -> DocumentID -> RevisionSelector -> Handler PDFBytes)
                :<|> ((AuthResult Token
                       -> DocumentID -> RevisionSelector -> Handler ZipBytes)
                      :<|> ((AuthResult Token
                             -> DocumentID
                             -> RevisionSelector
                             -> Handler (Maybe (TreeRevision TextElement)))
                            :<|> ((AuthResult Token
                                   -> DocumentID
                                   -> RevisionSelector
                                   -> TextElementID
                                   -> Handler (Maybe TextElementRevision))
                                  :<|> ((AuthResult Token
                                         -> DocumentID
                                         -> TextElementID
                                         -> Handler (Maybe (Rendered DraftRevision)))
                                        :<|> ((AuthResult Token
                                               -> DocumentID
                                               -> TextElementID
                                               -> Handler (Rendered ConflictStatus))
                                              :<|> ((AuthResult Token
                                                     -> DocumentID -> TextElementID -> Handler ())
                                                    :<|> ((AuthResult Token
                                                           -> Text -> Handler DocByteString)
                                                          :<|> (AuthResult Token
                                                                -> Text
                                                                -> Handler PDFByteString)))))))))))
-> (AuthResult Token
    -> DocumentID -> TextElementID -> CommentID -> Handler ())
   :<|> ((AuthResult Token
          -> DocumentID
          -> TextElementID
          -> CommentID
          -> CreateReply
          -> Handler Message)
         :<|> ((AuthResult Token
                -> DocumentID
                -> RevisionSelector
                -> Handler (FullDocument TextElementRevision))
               :<|> ((AuthResult Token
                      -> DocumentID -> RevisionSelector -> Handler PDFBytes)
                     :<|> ((AuthResult Token
                            -> DocumentID -> RevisionSelector -> Handler ZipBytes)
                           :<|> ((AuthResult Token
                                  -> DocumentID
                                  -> RevisionSelector
                                  -> Handler (Maybe (TreeRevision TextElement)))
                                 :<|> ((AuthResult Token
                                        -> DocumentID
                                        -> RevisionSelector
                                        -> TextElementID
                                        -> Handler (Maybe TextElementRevision))
                                       :<|> ((AuthResult Token
                                              -> DocumentID
                                              -> TextElementID
                                              -> Handler (Maybe (Rendered DraftRevision)))
                                             :<|> ((AuthResult Token
                                                    -> DocumentID
                                                    -> TextElementID
                                                    -> Handler (Rendered ConflictStatus))
                                                   :<|> ((AuthResult Token
                                                          -> DocumentID
                                                          -> TextElementID
                                                          -> Handler ())
                                                         :<|> ((AuthResult Token
                                                                -> Text -> Handler DocByteString)
                                                               :<|> (AuthResult Token
                                                                     -> Text
                                                                     -> Handler
                                                                          PDFByteString)))))))))))
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token
-> DocumentID
-> TextElementID
-> CommentID
-> CreateReply
-> Handler Message
createReplyHandler
        (AuthResult Token
 -> DocumentID
 -> TextElementID
 -> CommentID
 -> CreateReply
 -> Handler Message)
-> ((AuthResult Token
     -> DocumentID
     -> RevisionSelector
     -> Handler (FullDocument TextElementRevision))
    :<|> ((AuthResult Token
           -> DocumentID -> RevisionSelector -> Handler PDFBytes)
          :<|> ((AuthResult Token
                 -> DocumentID -> RevisionSelector -> Handler ZipBytes)
                :<|> ((AuthResult Token
                       -> DocumentID
                       -> RevisionSelector
                       -> Handler (Maybe (TreeRevision TextElement)))
                      :<|> ((AuthResult Token
                             -> DocumentID
                             -> RevisionSelector
                             -> TextElementID
                             -> Handler (Maybe TextElementRevision))
                            :<|> ((AuthResult Token
                                   -> DocumentID
                                   -> TextElementID
                                   -> Handler (Maybe (Rendered DraftRevision)))
                                  :<|> ((AuthResult Token
                                         -> DocumentID
                                         -> TextElementID
                                         -> Handler (Rendered ConflictStatus))
                                        :<|> ((AuthResult Token
                                               -> DocumentID -> TextElementID -> Handler ())
                                              :<|> ((AuthResult Token
                                                     -> Text -> Handler DocByteString)
                                                    :<|> (AuthResult Token
                                                          -> Text -> Handler PDFByteString))))))))))
-> (AuthResult Token
    -> DocumentID
    -> TextElementID
    -> CommentID
    -> CreateReply
    -> Handler Message)
   :<|> ((AuthResult Token
          -> DocumentID
          -> RevisionSelector
          -> Handler (FullDocument TextElementRevision))
         :<|> ((AuthResult Token
                -> DocumentID -> RevisionSelector -> Handler PDFBytes)
               :<|> ((AuthResult Token
                      -> DocumentID -> RevisionSelector -> Handler ZipBytes)
                     :<|> ((AuthResult Token
                            -> DocumentID
                            -> RevisionSelector
                            -> Handler (Maybe (TreeRevision TextElement)))
                           :<|> ((AuthResult Token
                                  -> DocumentID
                                  -> RevisionSelector
                                  -> TextElementID
                                  -> Handler (Maybe TextElementRevision))
                                 :<|> ((AuthResult Token
                                        -> DocumentID
                                        -> TextElementID
                                        -> Handler (Maybe (Rendered DraftRevision)))
                                       :<|> ((AuthResult Token
                                              -> DocumentID
                                              -> TextElementID
                                              -> Handler (Rendered ConflictStatus))
                                             :<|> ((AuthResult Token
                                                    -> DocumentID -> TextElementID -> Handler ())
                                                   :<|> ((AuthResult Token
                                                          -> Text -> Handler DocByteString)
                                                         :<|> (AuthResult Token
                                                               -> Text
                                                               -> Handler PDFByteString))))))))))
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token
-> DocumentID
-> RevisionSelector
-> Handler (FullDocument TextElementRevision)
getDocumentRevisionHandler
        (AuthResult Token
 -> DocumentID
 -> RevisionSelector
 -> Handler (FullDocument TextElementRevision))
-> ((AuthResult Token
     -> DocumentID -> RevisionSelector -> Handler PDFBytes)
    :<|> ((AuthResult Token
           -> DocumentID -> RevisionSelector -> Handler ZipBytes)
          :<|> ((AuthResult Token
                 -> DocumentID
                 -> RevisionSelector
                 -> Handler (Maybe (TreeRevision TextElement)))
                :<|> ((AuthResult Token
                       -> DocumentID
                       -> RevisionSelector
                       -> TextElementID
                       -> Handler (Maybe TextElementRevision))
                      :<|> ((AuthResult Token
                             -> DocumentID
                             -> TextElementID
                             -> Handler (Maybe (Rendered DraftRevision)))
                            :<|> ((AuthResult Token
                                   -> DocumentID
                                   -> TextElementID
                                   -> Handler (Rendered ConflictStatus))
                                  :<|> ((AuthResult Token
                                         -> DocumentID -> TextElementID -> Handler ())
                                        :<|> ((AuthResult Token -> Text -> Handler DocByteString)
                                              :<|> (AuthResult Token
                                                    -> Text -> Handler PDFByteString)))))))))
-> (AuthResult Token
    -> DocumentID
    -> RevisionSelector
    -> Handler (FullDocument TextElementRevision))
   :<|> ((AuthResult Token
          -> DocumentID -> RevisionSelector -> Handler PDFBytes)
         :<|> ((AuthResult Token
                -> DocumentID -> RevisionSelector -> Handler ZipBytes)
               :<|> ((AuthResult Token
                      -> DocumentID
                      -> RevisionSelector
                      -> Handler (Maybe (TreeRevision TextElement)))
                     :<|> ((AuthResult Token
                            -> DocumentID
                            -> RevisionSelector
                            -> TextElementID
                            -> Handler (Maybe TextElementRevision))
                           :<|> ((AuthResult Token
                                  -> DocumentID
                                  -> TextElementID
                                  -> Handler (Maybe (Rendered DraftRevision)))
                                 :<|> ((AuthResult Token
                                        -> DocumentID
                                        -> TextElementID
                                        -> Handler (Rendered ConflictStatus))
                                       :<|> ((AuthResult Token
                                              -> DocumentID -> TextElementID -> Handler ())
                                             :<|> ((AuthResult Token
                                                    -> Text -> Handler DocByteString)
                                                   :<|> (AuthResult Token
                                                         -> Text -> Handler PDFByteString)))))))))
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token
-> DocumentID -> RevisionSelector -> Handler PDFBytes
getDocumentRevisionPDFHandler
        (AuthResult Token
 -> DocumentID -> RevisionSelector -> Handler PDFBytes)
-> ((AuthResult Token
     -> DocumentID -> RevisionSelector -> Handler ZipBytes)
    :<|> ((AuthResult Token
           -> DocumentID
           -> RevisionSelector
           -> Handler (Maybe (TreeRevision TextElement)))
          :<|> ((AuthResult Token
                 -> DocumentID
                 -> RevisionSelector
                 -> TextElementID
                 -> Handler (Maybe TextElementRevision))
                :<|> ((AuthResult Token
                       -> DocumentID
                       -> TextElementID
                       -> Handler (Maybe (Rendered DraftRevision)))
                      :<|> ((AuthResult Token
                             -> DocumentID
                             -> TextElementID
                             -> Handler (Rendered ConflictStatus))
                            :<|> ((AuthResult Token
                                   -> DocumentID -> TextElementID -> Handler ())
                                  :<|> ((AuthResult Token -> Text -> Handler DocByteString)
                                        :<|> (AuthResult Token
                                              -> Text -> Handler PDFByteString))))))))
-> (AuthResult Token
    -> DocumentID -> RevisionSelector -> Handler PDFBytes)
   :<|> ((AuthResult Token
          -> DocumentID -> RevisionSelector -> Handler ZipBytes)
         :<|> ((AuthResult Token
                -> DocumentID
                -> RevisionSelector
                -> Handler (Maybe (TreeRevision TextElement)))
               :<|> ((AuthResult Token
                      -> DocumentID
                      -> RevisionSelector
                      -> TextElementID
                      -> Handler (Maybe TextElementRevision))
                     :<|> ((AuthResult Token
                            -> DocumentID
                            -> TextElementID
                            -> Handler (Maybe (Rendered DraftRevision)))
                           :<|> ((AuthResult Token
                                  -> DocumentID
                                  -> TextElementID
                                  -> Handler (Rendered ConflictStatus))
                                 :<|> ((AuthResult Token
                                        -> DocumentID -> TextElementID -> Handler ())
                                       :<|> ((AuthResult Token -> Text -> Handler DocByteString)
                                             :<|> (AuthResult Token
                                                   -> Text -> Handler PDFByteString))))))))
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token
-> DocumentID -> RevisionSelector -> Handler ZipBytes
getDocumentRevisionHTMLHandler
        (AuthResult Token
 -> DocumentID -> RevisionSelector -> Handler ZipBytes)
-> ((AuthResult Token
     -> DocumentID
     -> RevisionSelector
     -> Handler (Maybe (TreeRevision TextElement)))
    :<|> ((AuthResult Token
           -> DocumentID
           -> RevisionSelector
           -> TextElementID
           -> Handler (Maybe TextElementRevision))
          :<|> ((AuthResult Token
                 -> DocumentID
                 -> TextElementID
                 -> Handler (Maybe (Rendered DraftRevision)))
                :<|> ((AuthResult Token
                       -> DocumentID
                       -> TextElementID
                       -> Handler (Rendered ConflictStatus))
                      :<|> ((AuthResult Token
                             -> DocumentID -> TextElementID -> Handler ())
                            :<|> ((AuthResult Token -> Text -> Handler DocByteString)
                                  :<|> (AuthResult Token -> Text -> Handler PDFByteString)))))))
-> (AuthResult Token
    -> DocumentID -> RevisionSelector -> Handler ZipBytes)
   :<|> ((AuthResult Token
          -> DocumentID
          -> RevisionSelector
          -> Handler (Maybe (TreeRevision TextElement)))
         :<|> ((AuthResult Token
                -> DocumentID
                -> RevisionSelector
                -> TextElementID
                -> Handler (Maybe TextElementRevision))
               :<|> ((AuthResult Token
                      -> DocumentID
                      -> TextElementID
                      -> Handler (Maybe (Rendered DraftRevision)))
                     :<|> ((AuthResult Token
                            -> DocumentID
                            -> TextElementID
                            -> Handler (Rendered ConflictStatus))
                           :<|> ((AuthResult Token
                                  -> DocumentID -> TextElementID -> Handler ())
                                 :<|> ((AuthResult Token -> Text -> Handler DocByteString)
                                       :<|> (AuthResult Token
                                             -> Text -> Handler PDFByteString)))))))
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token
-> DocumentID
-> RevisionSelector
-> Handler (Maybe (TreeRevision TextElement))
getDocumentRevisionTreeHandler
        (AuthResult Token
 -> DocumentID
 -> RevisionSelector
 -> Handler (Maybe (TreeRevision TextElement)))
-> ((AuthResult Token
     -> DocumentID
     -> RevisionSelector
     -> TextElementID
     -> Handler (Maybe TextElementRevision))
    :<|> ((AuthResult Token
           -> DocumentID
           -> TextElementID
           -> Handler (Maybe (Rendered DraftRevision)))
          :<|> ((AuthResult Token
                 -> DocumentID
                 -> TextElementID
                 -> Handler (Rendered ConflictStatus))
                :<|> ((AuthResult Token
                       -> DocumentID -> TextElementID -> Handler ())
                      :<|> ((AuthResult Token -> Text -> Handler DocByteString)
                            :<|> (AuthResult Token -> Text -> Handler PDFByteString))))))
-> (AuthResult Token
    -> DocumentID
    -> RevisionSelector
    -> Handler (Maybe (TreeRevision TextElement)))
   :<|> ((AuthResult Token
          -> DocumentID
          -> RevisionSelector
          -> TextElementID
          -> Handler (Maybe TextElementRevision))
         :<|> ((AuthResult Token
                -> DocumentID
                -> TextElementID
                -> Handler (Maybe (Rendered DraftRevision)))
               :<|> ((AuthResult Token
                      -> DocumentID
                      -> TextElementID
                      -> Handler (Rendered ConflictStatus))
                     :<|> ((AuthResult Token
                            -> DocumentID -> TextElementID -> Handler ())
                           :<|> ((AuthResult Token -> Text -> Handler DocByteString)
                                 :<|> (AuthResult Token -> Text -> Handler PDFByteString))))))
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token
-> DocumentID
-> RevisionSelector
-> TextElementID
-> Handler (Maybe TextElementRevision)
getDocumentRevisionTextHandler
        (AuthResult Token
 -> DocumentID
 -> RevisionSelector
 -> TextElementID
 -> Handler (Maybe TextElementRevision))
-> ((AuthResult Token
     -> DocumentID
     -> TextElementID
     -> Handler (Maybe (Rendered DraftRevision)))
    :<|> ((AuthResult Token
           -> DocumentID
           -> TextElementID
           -> Handler (Rendered ConflictStatus))
          :<|> ((AuthResult Token
                 -> DocumentID -> TextElementID -> Handler ())
                :<|> ((AuthResult Token -> Text -> Handler DocByteString)
                      :<|> (AuthResult Token -> Text -> Handler PDFByteString)))))
-> (AuthResult Token
    -> DocumentID
    -> RevisionSelector
    -> TextElementID
    -> Handler (Maybe TextElementRevision))
   :<|> ((AuthResult Token
          -> DocumentID
          -> TextElementID
          -> Handler (Maybe (Rendered DraftRevision)))
         :<|> ((AuthResult Token
                -> DocumentID
                -> TextElementID
                -> Handler (Rendered ConflictStatus))
               :<|> ((AuthResult Token
                      -> DocumentID -> TextElementID -> Handler ())
                     :<|> ((AuthResult Token -> Text -> Handler DocByteString)
                           :<|> (AuthResult Token -> Text -> Handler PDFByteString)))))
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token
-> DocumentID
-> TextElementID
-> Handler (Maybe (Rendered DraftRevision))
getDraftTextRevisionHandler
        (AuthResult Token
 -> DocumentID
 -> TextElementID
 -> Handler (Maybe (Rendered DraftRevision)))
-> ((AuthResult Token
     -> DocumentID
     -> TextElementID
     -> Handler (Rendered ConflictStatus))
    :<|> ((AuthResult Token
           -> DocumentID -> TextElementID -> Handler ())
          :<|> ((AuthResult Token -> Text -> Handler DocByteString)
                :<|> (AuthResult Token -> Text -> Handler PDFByteString))))
-> (AuthResult Token
    -> DocumentID
    -> TextElementID
    -> Handler (Maybe (Rendered DraftRevision)))
   :<|> ((AuthResult Token
          -> DocumentID
          -> TextElementID
          -> Handler (Rendered ConflictStatus))
         :<|> ((AuthResult Token
                -> DocumentID -> TextElementID -> Handler ())
               :<|> ((AuthResult Token -> Text -> Handler DocByteString)
                     :<|> (AuthResult Token -> Text -> Handler PDFByteString))))
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token
-> DocumentID -> TextElementID -> Handler (Rendered ConflictStatus)
publishDraftTextRevisionHandler
        (AuthResult Token
 -> DocumentID
 -> TextElementID
 -> Handler (Rendered ConflictStatus))
-> ((AuthResult Token -> DocumentID -> TextElementID -> Handler ())
    :<|> ((AuthResult Token -> Text -> Handler DocByteString)
          :<|> (AuthResult Token -> Text -> Handler PDFByteString)))
-> (AuthResult Token
    -> DocumentID
    -> TextElementID
    -> Handler (Rendered ConflictStatus))
   :<|> ((AuthResult Token
          -> DocumentID -> TextElementID -> Handler ())
         :<|> ((AuthResult Token -> Text -> Handler DocByteString)
               :<|> (AuthResult Token -> Text -> Handler PDFByteString)))
forall a b. a -> b -> a :<|> b
:<|> AuthResult Token -> DocumentID -> TextElementID -> Handler ()
discardDraftTextRevisionHandler
        (AuthResult Token -> DocumentID -> TextElementID -> Handler ())
-> ((AuthResult Token -> Text -> Handler DocByteString)
    :<|> (AuthResult Token -> Text -> Handler PDFByteString))
-> (AuthResult Token -> DocumentID -> TextElementID -> Handler ())
   :<|> ((AuthResult Token -> Text -> Handler DocByteString)
         :<|> (AuthResult Token -> Text -> Handler PDFByteString))
forall a b. a -> b -> a :<|> b
:<|> (AuthResult Token -> Text -> Handler DocByteString)
:<|> (AuthResult Token -> Text -> Handler PDFByteString)
Server RenderAPI
renderServer

postDocumentHandler
    :: AuthResult Auth.Token
    -> CreateDocument
    -> Handler (FullDocument (Rendered TextElementRevision))
postDocumentHandler :: AuthResult Token
-> CreateDocument
-> Handler (FullDocument (Rendered TextElementRevision))
postDocumentHandler AuthResult Token
auth CreateDocument
doc = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    (Connection
 -> IO
      (Either
         SessionError
         (Result (FullDocument (Rendered TextElementRevision)))))
-> Handler (FullDocument (Rendered TextElementRevision))
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection
  -> IO
       (Either
          SessionError
          (Result (FullDocument (Rendered TextElementRevision)))))
 -> Handler (FullDocument (Rendered TextElementRevision)))
-> (Connection
    -> IO
         (Either
            SessionError
            (Result (FullDocument (Rendered TextElementRevision)))))
-> Handler (FullDocument (Rendered TextElementRevision))
forall a b. (a -> b) -> a -> b
$
        HasqlTransaction
  (Result (FullDocument (Rendered TextElementRevision)))
-> Connection
-> IO
     (Either
        SessionError
        (Result (FullDocument (Rendered TextElementRevision))))
forall a.
HasqlTransaction a -> Connection -> IO (Either SessionError a)
runTransaction (HasqlTransaction
   (Result (FullDocument (Rendered TextElementRevision)))
 -> Connection
 -> IO
      (Either
         SessionError
         (Result (FullDocument (Rendered TextElementRevision)))))
-> HasqlTransaction
     (Result (FullDocument (Rendered TextElementRevision)))
-> Connection
-> IO
     (Either
        SessionError
        (Result (FullDocument (Rendered TextElementRevision))))
forall a b. (a -> b) -> a -> b
$
            UserID
-> GroupID
-> Text
-> FlaggedInputTree'
-> HasqlTransaction
     (Result (FullDocument (Rendered TextElementRevision)))
forall (m :: * -> *).
(HasCreateDocument m, HasLogMessage m, HasCreateTextElement m,
 HasCreateTextRevision m, HasGetTextElementRevision m,
 HasExistsComment m, HasCreateTreeRevision m, HasGetTreeRevision m,
 HasGetRevisionKey m, HasGetDocument m, HasRollback m,
 HasDraftTextRevision m) =>
UserID
-> GroupID
-> Text
-> FlaggedInputTree'
-> m (Result (FullDocument (Rendered TextElementRevision)))
Docs.newDefaultDocument
                UserID
userID
                (CreateDocument -> GroupID
CreateDocument.groupID CreateDocument
doc)
                (CreateDocument -> Text
CreateDocument.title CreateDocument
doc)
                FlaggedInputTree'
fpoTree

getDocumentHandler
    :: AuthResult Auth.Token
    -> DocumentID
    -> Handler Document
getDocumentHandler :: AuthResult Token -> DocumentID -> Handler Document
getDocumentHandler AuthResult Token
auth DocumentID
docID = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    (Connection -> IO (Either SessionError (Result Document)))
-> Handler Document
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection -> IO (Either SessionError (Result Document)))
 -> Handler Document)
-> (Connection -> IO (Either SessionError (Result Document)))
-> Handler Document
forall a b. (a -> b) -> a -> b
$ HasqlSession (Result Document)
-> Connection -> IO (Either SessionError (Result Document))
forall a.
HasqlSession a -> Connection -> IO (Either SessionError a)
run (HasqlSession (Result Document)
 -> Connection -> IO (Either SessionError (Result Document)))
-> HasqlSession (Result Document)
-> Connection
-> IO (Either SessionError (Result Document))
forall a b. (a -> b) -> a -> b
$ UserID -> DocumentID -> HasqlSession (Result Document)
forall (m :: * -> *).
(HasGetDocument m, HasLogMessage m) =>
UserID -> DocumentID -> m (Result Document)
Docs.getDocument UserID
userID DocumentID
docID

getDocumentsHandler
    :: AuthResult Auth.Token
    -> Maybe UserID
    -> Maybe GroupID
    -> Handler Documents
getDocumentsHandler :: AuthResult Token
-> Maybe UserID -> Maybe GroupID -> Handler Documents
getDocumentsHandler AuthResult Token
auth Maybe UserID
byUserID Maybe GroupID
byGroupID = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    Vector Document
result <- (Connection -> IO (Either SessionError (Result (Vector Document))))
-> Handler (Vector Document)
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection
  -> IO (Either SessionError (Result (Vector Document))))
 -> Handler (Vector Document))
-> (Connection
    -> IO (Either SessionError (Result (Vector Document))))
-> Handler (Vector Document)
forall a b. (a -> b) -> a -> b
$ HasqlSession (Result (Vector Document))
-> Connection
-> IO (Either SessionError (Result (Vector Document)))
forall a.
HasqlSession a -> Connection -> IO (Either SessionError a)
run (HasqlSession (Result (Vector Document))
 -> Connection
 -> IO (Either SessionError (Result (Vector Document))))
-> HasqlSession (Result (Vector Document))
-> Connection
-> IO (Either SessionError (Result (Vector Document)))
forall a b. (a -> b) -> a -> b
$ UserID
-> Maybe UserID
-> Maybe GroupID
-> HasqlSession (Result (Vector Document))
forall (m :: * -> *).
(HasGetDocument m, HasLogMessage m) =>
UserID
-> Maybe UserID -> Maybe GroupID -> m (Result (Vector Document))
Docs.getDocuments UserID
userID Maybe UserID
byUserID Maybe GroupID
byGroupID
    Documents -> Handler Documents
forall a. a -> Handler a
forall (m :: * -> *) a. Monad m => a -> m a
return (Documents -> Handler Documents) -> Documents -> Handler Documents
forall a b. (a -> b) -> a -> b
$
        Documents
            { documents :: Vector Document
Documents.documents = Vector Document
result
            , query :: DocumentsQuery
Documents.query =
                DocumentsQuery
                    { user :: Maybe UserID
Documents.user = Maybe UserID
byUserID
                    , group :: Maybe GroupID
Documents.group = Maybe GroupID
byGroupID
                    }
            }

postTextElementHandler
    :: AuthResult Auth.Token
    -> DocumentID
    -> CreateTextElement
    -> Handler TextElement
postTextElementHandler :: AuthResult Token
-> DocumentID -> CreateTextElement -> Handler TextElement
postTextElementHandler AuthResult Token
auth DocumentID
docID CreateTextElement
element = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    (Connection -> IO (Either SessionError (Result TextElement)))
-> Handler TextElement
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection -> IO (Either SessionError (Result TextElement)))
 -> Handler TextElement)
-> (Connection -> IO (Either SessionError (Result TextElement)))
-> Handler TextElement
forall a b. (a -> b) -> a -> b
$
        HasqlSession (Result TextElement)
-> Connection -> IO (Either SessionError (Result TextElement))
forall a.
HasqlSession a -> Connection -> IO (Either SessionError a)
run (HasqlSession (Result TextElement)
 -> Connection -> IO (Either SessionError (Result TextElement)))
-> HasqlSession (Result TextElement)
-> Connection
-> IO (Either SessionError (Result TextElement))
forall a b. (a -> b) -> a -> b
$
            UserID
-> DocumentID -> Text -> Text -> HasqlSession (Result TextElement)
forall (m :: * -> *).
(HasCreateTextElement m, HasLogMessage m) =>
UserID -> DocumentID -> Text -> Text -> m (Result TextElement)
Docs.createTextElement
                UserID
userID
                DocumentID
docID
                (CreateTextElement -> Text
CreateTextElement.kind CreateTextElement
element)
                (CreateTextElement -> Text
CreateTextElement.type_ CreateTextElement
element)

postTextRevisionHandler
    :: AuthResult Auth.Token
    -> DocumentID
    -> TextElementID
    -> Maybe Bool
    -> CreateTextRevision
    -> Handler (Rendered ConflictStatus)
postTextRevisionHandler :: AuthResult Token
-> DocumentID
-> TextElementID
-> Maybe Bool
-> CreateTextRevision
-> Handler (Rendered ConflictStatus)
postTextRevisionHandler AuthResult Token
auth DocumentID
docID TextElementID
textID Maybe Bool
mIsAutoSave CreateTextRevision
revision = do
    let isAutoSave :: Bool
isAutoSave = Bool -> Maybe Bool -> Bool
forall a. a -> Maybe a -> a
fromMaybe Bool
False Maybe Bool
mIsAutoSave -- Default to False if not provided
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    (Connection
 -> IO (Either SessionError (Result (Rendered ConflictStatus))))
-> Handler (Rendered ConflictStatus)
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection
  -> IO (Either SessionError (Result (Rendered ConflictStatus))))
 -> Handler (Rendered ConflictStatus))
-> (Connection
    -> IO (Either SessionError (Result (Rendered ConflictStatus))))
-> Handler (Rendered ConflictStatus)
forall a b. (a -> b) -> a -> b
$
        HasqlTransaction (Result (Rendered ConflictStatus))
-> Connection
-> IO (Either SessionError (Result (Rendered ConflictStatus)))
forall a.
HasqlTransaction a -> Connection -> IO (Either SessionError a)
runTransaction (HasqlTransaction (Result (Rendered ConflictStatus))
 -> Connection
 -> IO (Either SessionError (Result (Rendered ConflictStatus))))
-> HasqlTransaction (Result (Rendered ConflictStatus))
-> Connection
-> IO (Either SessionError (Result (Rendered ConflictStatus)))
forall a b. (a -> b) -> a -> b
$
            UserID
-> NewTextRevision
-> HasqlTransaction (Result (Rendered ConflictStatus))
forall (m :: * -> *).
(HasCreateTextRevision m, HasGetTextElementRevision m,
 HasExistsComment m, HasLogMessage m, HasGetTreeRevision m,
 HasGetRevisionKey m, HasGetDocument m, HasDraftTextRevision m) =>
UserID -> NewTextRevision -> m (Result (Rendered ConflictStatus))
Docs.createTextRevision UserID
userID (NewTextRevision
 -> HasqlTransaction (Result (Rendered ConflictStatus)))
-> NewTextRevision
-> HasqlTransaction (Result (Rendered ConflictStatus))
forall a b. (a -> b) -> a -> b
$
                TextElementRef
-> Maybe TextRevisionID
-> Text
-> Vector CommentAnchor
-> Bool
-> NewTextRevision
NewTextRevision
                    (DocumentID -> TextElementID -> TextElementRef
TextElementRef DocumentID
docID TextElementID
textID)
                    (CreateTextRevision -> Maybe TextRevisionID
CreateTextRevision.parent CreateTextRevision
revision)
                    (CreateTextRevision -> Text
CreateTextRevision.content CreateTextRevision
revision)
                    (CreateTextRevision -> Vector CommentAnchor
CreateTextRevision.commentAnchors CreateTextRevision
revision)
                    Bool
isAutoSave

getTextElementRevisionHandler
    :: AuthResult Auth.Token
    -> DocumentID
    -> TextElementID
    -> TextRevisionSelector
    -> Handler (Maybe (Rendered TextElementRevision))
getTextElementRevisionHandler :: AuthResult Token
-> DocumentID
-> TextElementID
-> TextRevisionSelector
-> Handler (Maybe (Rendered TextElementRevision))
getTextElementRevisionHandler AuthResult Token
auth DocumentID
docID TextElementID
textID TextRevisionSelector
revision = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    (Connection
 -> IO
      (Either
         SessionError (Result (Maybe (Rendered TextElementRevision)))))
-> Handler (Maybe (Rendered TextElementRevision))
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection
  -> IO
       (Either
          SessionError (Result (Maybe (Rendered TextElementRevision)))))
 -> Handler (Maybe (Rendered TextElementRevision)))
-> (Connection
    -> IO
         (Either
            SessionError (Result (Maybe (Rendered TextElementRevision)))))
-> Handler (Maybe (Rendered TextElementRevision))
forall a b. (a -> b) -> a -> b
$
        HasqlSession (Result (Maybe (Rendered TextElementRevision)))
-> Connection
-> IO
     (Either
        SessionError (Result (Maybe (Rendered TextElementRevision))))
forall a.
HasqlSession a -> Connection -> IO (Either SessionError a)
run (HasqlSession (Result (Maybe (Rendered TextElementRevision)))
 -> Connection
 -> IO
      (Either
         SessionError (Result (Maybe (Rendered TextElementRevision)))))
-> HasqlSession (Result (Maybe (Rendered TextElementRevision)))
-> Connection
-> IO
     (Either
        SessionError (Result (Maybe (Rendered TextElementRevision))))
forall a b. (a -> b) -> a -> b
$
            UserID
-> TextRevisionRef
-> HasqlSession (Result (Maybe (Rendered TextElementRevision)))
forall (m :: * -> *).
(HasGetTextElementRevision m, HasGetTreeRevision m,
 HasGetRevisionKey m, HasGetDocument m, HasLogMessage m) =>
UserID
-> TextRevisionRef
-> m (Result (Maybe (Rendered TextElementRevision)))
Docs.getTextElementRevision UserID
userID (TextRevisionRef
 -> HasqlSession (Result (Maybe (Rendered TextElementRevision))))
-> TextRevisionRef
-> HasqlSession (Result (Maybe (Rendered TextElementRevision)))
forall a b. (a -> b) -> a -> b
$
                TextElementRef -> TextRevisionSelector -> TextRevisionRef
TextRevisionRef (DocumentID -> TextElementID -> TextElementRef
TextElementRef DocumentID
docID TextElementID
textID) TextRevisionSelector
revision

getTextRevisionPDFHandler
    :: AuthResult Auth.Token
    -> DocumentID
    -> TextElementID
    -> TextRevisionSelector
    -> Handler PDFBytes
getTextRevisionPDFHandler :: AuthResult Token
-> DocumentID
-> TextElementID
-> TextRevisionSelector
-> Handler PDFBytes
getTextRevisionPDFHandler AuthResult Token
auth DocumentID
docID TextElementID
textID TextRevisionSelector
revision = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    (Connection -> IO (Either SessionError (Result PDFBytes)))
-> Handler PDFBytes
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection -> IO (Either SessionError (Result PDFBytes)))
 -> Handler PDFBytes)
-> (Connection -> IO (Either SessionError (Result PDFBytes)))
-> Handler PDFBytes
forall a b. (a -> b) -> a -> b
$
        HasqlSession (Result PDFBytes)
-> Connection -> IO (Either SessionError (Result PDFBytes))
forall a.
HasqlSession a -> Connection -> IO (Either SessionError a)
run (HasqlSession (Result PDFBytes)
 -> Connection -> IO (Either SessionError (Result PDFBytes)))
-> HasqlSession (Result PDFBytes)
-> Connection
-> IO (Either SessionError (Result PDFBytes))
forall a b. (a -> b) -> a -> b
$
            UserID -> TextRevisionRef -> HasqlSession (Result PDFBytes)
forall (m :: * -> *).
(HasGetTreeRevision m, HasLogMessage m,
 HasGetTextElementRevision m, HasGetRevisionKey m, HasGetDocument m,
 MonadIO m) =>
UserID -> TextRevisionRef -> m (Result PDFBytes)
Docs.getTextRevisionPDF UserID
userID (TextRevisionRef -> HasqlSession (Result PDFBytes))
-> TextRevisionRef -> HasqlSession (Result PDFBytes)
forall a b. (a -> b) -> a -> b
$
                TextElementRef -> TextRevisionSelector -> TextRevisionRef
TextRevisionRef
                    (DocumentID -> TextElementID -> TextElementRef
TextElementRef DocumentID
docID TextElementID
textID)
                    TextRevisionSelector
revision

postTreeRevisionHandler
    :: AuthResult Auth.Token
    -> DocumentID
    -> Node TextElementID
    -> Handler (TreeRevisionWithMetaData TextElementID)
postTreeRevisionHandler :: AuthResult Token
-> DocumentID
-> Node TextElementID
-> Handler (TreeRevisionWithMetaData TextElementID)
postTreeRevisionHandler AuthResult Token
auth DocumentID
docID Node TextElementID
node = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    (Connection
 -> IO
      (Either
         SessionError (Result (TreeRevisionWithMetaData TextElementID))))
-> Handler (TreeRevisionWithMetaData TextElementID)
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection
  -> IO
       (Either
          SessionError (Result (TreeRevisionWithMetaData TextElementID))))
 -> Handler (TreeRevisionWithMetaData TextElementID))
-> (Connection
    -> IO
         (Either
            SessionError (Result (TreeRevisionWithMetaData TextElementID))))
-> Handler (TreeRevisionWithMetaData TextElementID)
forall a b. (a -> b) -> a -> b
$ HasqlTransaction (Result (TreeRevisionWithMetaData TextElementID))
-> Connection
-> IO
     (Either
        SessionError (Result (TreeRevisionWithMetaData TextElementID)))
forall a.
HasqlTransaction a -> Connection -> IO (Either SessionError a)
runTransaction (HasqlTransaction (Result (TreeRevisionWithMetaData TextElementID))
 -> Connection
 -> IO
      (Either
         SessionError (Result (TreeRevisionWithMetaData TextElementID))))
-> HasqlTransaction
     (Result (TreeRevisionWithMetaData TextElementID))
-> Connection
-> IO
     (Either
        SessionError (Result (TreeRevisionWithMetaData TextElementID)))
forall a b. (a -> b) -> a -> b
$ UserID
-> DocumentID
-> Node TextElementID
-> HasqlTransaction
     (Result (TreeRevisionWithMetaData TextElementID))
forall (m :: * -> *).
(HasCreateTreeRevision m, HasLogMessage m,
 HasGetTextElementRevision m, HasGetTreeRevision m,
 HasRollback m) =>
UserID
-> DocumentID
-> Node TextElementID
-> m (Result (TreeRevisionWithMetaData TextElementID))
Docs.createTreeRevision UserID
userID DocumentID
docID Node TextElementID
node

getTreeRevisionFullHandler
    :: AuthResult Auth.Token
    -> DocumentID
    -> TreeRevisionSelector
    -> Handler (Maybe (TreeRevisionWithMetaData TextElementRevision))
getTreeRevisionFullHandler :: AuthResult Token
-> DocumentID
-> TreeRevisionSelector
-> Handler (Maybe (TreeRevisionWithMetaData TextElementRevision))
getTreeRevisionFullHandler AuthResult Token
auth DocumentID
docID TreeRevisionSelector
revision = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    (Connection
 -> IO
      (Either
         SessionError
         (Result (Maybe (TreeRevisionWithMetaData TextElementRevision)))))
-> Handler (Maybe (TreeRevisionWithMetaData TextElementRevision))
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection
  -> IO
       (Either
          SessionError
          (Result (Maybe (TreeRevisionWithMetaData TextElementRevision)))))
 -> Handler (Maybe (TreeRevisionWithMetaData TextElementRevision)))
-> (Connection
    -> IO
         (Either
            SessionError
            (Result (Maybe (TreeRevisionWithMetaData TextElementRevision)))))
-> Handler (Maybe (TreeRevisionWithMetaData TextElementRevision))
forall a b. (a -> b) -> a -> b
$
        HasqlSession
  (Result (Maybe (TreeRevisionWithMetaData TextElementRevision)))
-> Connection
-> IO
     (Either
        SessionError
        (Result (Maybe (TreeRevisionWithMetaData TextElementRevision))))
forall a.
HasqlSession a -> Connection -> IO (Either SessionError a)
run (HasqlSession
   (Result (Maybe (TreeRevisionWithMetaData TextElementRevision)))
 -> Connection
 -> IO
      (Either
         SessionError
         (Result (Maybe (TreeRevisionWithMetaData TextElementRevision)))))
-> HasqlSession
     (Result (Maybe (TreeRevisionWithMetaData TextElementRevision)))
-> Connection
-> IO
     (Either
        SessionError
        (Result (Maybe (TreeRevisionWithMetaData TextElementRevision))))
forall a b. (a -> b) -> a -> b
$
            UserID
-> TreeRevisionRef
-> HasqlSession
     (Result (Maybe (TreeRevisionWithMetaData TextElementRevision)))
forall (m :: * -> *).
(HasGetTreeRevision m, HasLogMessage m,
 HasGetTextElementRevision m) =>
UserID
-> TreeRevisionRef
-> m (Result
        (Maybe (TreeRevisionWithMetaData TextElementRevision)))
Docs.getFullTreeRevision UserID
userID (TreeRevisionRef
 -> HasqlSession
      (Result (Maybe (TreeRevisionWithMetaData TextElementRevision))))
-> TreeRevisionRef
-> HasqlSession
     (Result (Maybe (TreeRevisionWithMetaData TextElementRevision)))
forall a b. (a -> b) -> a -> b
$
                DocumentID -> TreeRevisionSelector -> TreeRevisionRef
TreeRevisionRef DocumentID
docID TreeRevisionSelector
revision

getTreeRevisionHandler
    :: AuthResult Auth.Token
    -> DocumentID
    -> TreeRevisionSelector
    -> Handler (Maybe (TreeRevisionWithMetaData TextElement))
getTreeRevisionHandler :: AuthResult Token
-> DocumentID
-> TreeRevisionSelector
-> Handler (Maybe (TreeRevisionWithMetaData TextElement))
getTreeRevisionHandler AuthResult Token
auth DocumentID
docID TreeRevisionSelector
revision = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    (Connection
 -> IO
      (Either
         SessionError
         (Result (Maybe (TreeRevisionWithMetaData TextElement)))))
-> Handler (Maybe (TreeRevisionWithMetaData TextElement))
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection
  -> IO
       (Either
          SessionError
          (Result (Maybe (TreeRevisionWithMetaData TextElement)))))
 -> Handler (Maybe (TreeRevisionWithMetaData TextElement)))
-> (Connection
    -> IO
         (Either
            SessionError
            (Result (Maybe (TreeRevisionWithMetaData TextElement)))))
-> Handler (Maybe (TreeRevisionWithMetaData TextElement))
forall a b. (a -> b) -> a -> b
$ HasqlSession
  (Result (Maybe (TreeRevisionWithMetaData TextElement)))
-> Connection
-> IO
     (Either
        SessionError
        (Result (Maybe (TreeRevisionWithMetaData TextElement))))
forall a.
HasqlSession a -> Connection -> IO (Either SessionError a)
run (HasqlSession
   (Result (Maybe (TreeRevisionWithMetaData TextElement)))
 -> Connection
 -> IO
      (Either
         SessionError
         (Result (Maybe (TreeRevisionWithMetaData TextElement)))))
-> HasqlSession
     (Result (Maybe (TreeRevisionWithMetaData TextElement)))
-> Connection
-> IO
     (Either
        SessionError
        (Result (Maybe (TreeRevisionWithMetaData TextElement))))
forall a b. (a -> b) -> a -> b
$ UserID
-> TreeRevisionRef
-> HasqlSession
     (Result (Maybe (TreeRevisionWithMetaData TextElement)))
forall (m :: * -> *).
(HasGetTreeRevision m, HasLogMessage m,
 HasGetTextElementRevision m) =>
UserID
-> TreeRevisionRef
-> m (Result (Maybe (TreeRevisionWithMetaData TextElement)))
Docs.getTreeRevision UserID
userID (TreeRevisionRef
 -> HasqlSession
      (Result (Maybe (TreeRevisionWithMetaData TextElement))))
-> TreeRevisionRef
-> HasqlSession
     (Result (Maybe (TreeRevisionWithMetaData TextElement)))
forall a b. (a -> b) -> a -> b
$ DocumentID -> TreeRevisionSelector -> TreeRevisionRef
TreeRevisionRef DocumentID
docID TreeRevisionSelector
revision

getTreeRevisionPDFHandler
    :: AuthResult Auth.Token
    -> DocumentID
    -> TreeRevisionSelector
    -> Handler PDFBytes
getTreeRevisionPDFHandler :: AuthResult Token
-> DocumentID -> TreeRevisionSelector -> Handler PDFBytes
getTreeRevisionPDFHandler AuthResult Token
auth DocumentID
docID TreeRevisionSelector
revision = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    (Connection -> IO (Either SessionError (Result PDFBytes)))
-> Handler PDFBytes
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection -> IO (Either SessionError (Result PDFBytes)))
 -> Handler PDFBytes)
-> (Connection -> IO (Either SessionError (Result PDFBytes)))
-> Handler PDFBytes
forall a b. (a -> b) -> a -> b
$ HasqlSession (Result PDFBytes)
-> Connection -> IO (Either SessionError (Result PDFBytes))
forall a.
HasqlSession a -> Connection -> IO (Either SessionError a)
run (HasqlSession (Result PDFBytes)
 -> Connection -> IO (Either SessionError (Result PDFBytes)))
-> HasqlSession (Result PDFBytes)
-> Connection
-> IO (Either SessionError (Result PDFBytes))
forall a b. (a -> b) -> a -> b
$ UserID -> TreeRevisionRef -> HasqlSession (Result PDFBytes)
forall (m :: * -> *).
(HasGetTreeRevision m, HasLogMessage m,
 HasGetTextElementRevision m, MonadIO m) =>
UserID -> TreeRevisionRef -> m (Result PDFBytes)
Docs.getTreeRevisionPDF UserID
userID (TreeRevisionRef -> HasqlSession (Result PDFBytes))
-> TreeRevisionRef -> HasqlSession (Result PDFBytes)
forall a b. (a -> b) -> a -> b
$ DocumentID -> TreeRevisionSelector -> TreeRevisionRef
TreeRevisionRef DocumentID
docID TreeRevisionSelector
revision

getTreeRevisionHTMLHandler
    :: AuthResult Auth.Token
    -> DocumentID
    -> TreeRevisionSelector
    -> Handler ZipBytes
getTreeRevisionHTMLHandler :: AuthResult Token
-> DocumentID -> TreeRevisionSelector -> Handler ZipBytes
getTreeRevisionHTMLHandler AuthResult Token
auth DocumentID
docID TreeRevisionSelector
revision = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    (Connection -> IO (Either SessionError (Result ZipBytes)))
-> Handler ZipBytes
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection -> IO (Either SessionError (Result ZipBytes)))
 -> Handler ZipBytes)
-> (Connection -> IO (Either SessionError (Result ZipBytes)))
-> Handler ZipBytes
forall a b. (a -> b) -> a -> b
$ HasqlSession (Result ZipBytes)
-> Connection -> IO (Either SessionError (Result ZipBytes))
forall a.
HasqlSession a -> Connection -> IO (Either SessionError a)
run (HasqlSession (Result ZipBytes)
 -> Connection -> IO (Either SessionError (Result ZipBytes)))
-> HasqlSession (Result ZipBytes)
-> Connection
-> IO (Either SessionError (Result ZipBytes))
forall a b. (a -> b) -> a -> b
$ UserID -> TreeRevisionRef -> HasqlSession (Result ZipBytes)
forall (m :: * -> *).
(HasGetTreeRevision m, HasLogMessage m,
 HasGetTextElementRevision m, MonadIO m) =>
UserID -> TreeRevisionRef -> m (Result ZipBytes)
Docs.getTreeRevisionHTML UserID
userID (TreeRevisionRef -> HasqlSession (Result ZipBytes))
-> TreeRevisionRef -> HasqlSession (Result ZipBytes)
forall a b. (a -> b) -> a -> b
$ DocumentID -> TreeRevisionSelector -> TreeRevisionRef
TreeRevisionRef DocumentID
docID TreeRevisionSelector
revision

getTextHistoryHandler
    :: AuthResult Auth.Token
    -> DocumentID
    -> TextElementID
    -> Maybe UTCTime
    -> Maybe UTCTime
    -> Maybe Docs.Limit
    -> Handler TextRevisionHistory
getTextHistoryHandler :: AuthResult Token
-> DocumentID
-> TextElementID
-> Maybe UTCTime
-> Maybe UTCTime
-> Maybe GroupID
-> Handler TextRevisionHistory
getTextHistoryHandler AuthResult Token
auth DocumentID
docID TextElementID
textID Maybe UTCTime
after Maybe UTCTime
before Maybe GroupID
limit = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    (Connection
 -> IO (Either SessionError (Result TextRevisionHistory)))
-> Handler TextRevisionHistory
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection
  -> IO (Either SessionError (Result TextRevisionHistory)))
 -> Handler TextRevisionHistory)
-> (Connection
    -> IO (Either SessionError (Result TextRevisionHistory)))
-> Handler TextRevisionHistory
forall a b. (a -> b) -> a -> b
$
        HasqlSession (Result TextRevisionHistory)
-> Connection
-> IO (Either SessionError (Result TextRevisionHistory))
forall a.
HasqlSession a -> Connection -> IO (Either SessionError a)
run (HasqlSession (Result TextRevisionHistory)
 -> Connection
 -> IO (Either SessionError (Result TextRevisionHistory)))
-> HasqlSession (Result TextRevisionHistory)
-> Connection
-> IO (Either SessionError (Result TextRevisionHistory))
forall a b. (a -> b) -> a -> b
$
            UserID
-> TextElementRef
-> Maybe UTCTime
-> Maybe UTCTime
-> Maybe GroupID
-> HasqlSession (Result TextRevisionHistory)
forall (m :: * -> *).
(HasGetTextHistory m, HasLogMessage m) =>
UserID
-> TextElementRef
-> Maybe UTCTime
-> Maybe UTCTime
-> Maybe GroupID
-> m (Result TextRevisionHistory)
Docs.getTextHistory
                UserID
userID
                (DocumentID -> TextElementID -> TextElementRef
TextElementRef DocumentID
docID TextElementID
textID)
                Maybe UTCTime
after
                Maybe UTCTime
before
                Maybe GroupID
limit

getTreeHistoryHandler
    :: AuthResult Auth.Token
    -> DocumentID
    -> Maybe UTCTime
    -> Maybe Docs.Limit
    -> Handler TreeRevisionHistory
getTreeHistoryHandler :: AuthResult Token
-> DocumentID
-> Maybe UTCTime
-> Maybe GroupID
-> Handler TreeRevisionHistory
getTreeHistoryHandler AuthResult Token
auth DocumentID
docID Maybe UTCTime
before Maybe GroupID
limit = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    (Connection
 -> IO (Either SessionError (Result TreeRevisionHistory)))
-> Handler TreeRevisionHistory
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection
  -> IO (Either SessionError (Result TreeRevisionHistory)))
 -> Handler TreeRevisionHistory)
-> (Connection
    -> IO (Either SessionError (Result TreeRevisionHistory)))
-> Handler TreeRevisionHistory
forall a b. (a -> b) -> a -> b
$ HasqlSession (Result TreeRevisionHistory)
-> Connection
-> IO (Either SessionError (Result TreeRevisionHistory))
forall a.
HasqlSession a -> Connection -> IO (Either SessionError a)
run (HasqlSession (Result TreeRevisionHistory)
 -> Connection
 -> IO (Either SessionError (Result TreeRevisionHistory)))
-> HasqlSession (Result TreeRevisionHistory)
-> Connection
-> IO (Either SessionError (Result TreeRevisionHistory))
forall a b. (a -> b) -> a -> b
$ UserID
-> DocumentID
-> Maybe UTCTime
-> Maybe GroupID
-> HasqlSession (Result TreeRevisionHistory)
forall (m :: * -> *).
(HasGetTreeHistory m, HasLogMessage m) =>
UserID
-> DocumentID
-> Maybe UTCTime
-> Maybe GroupID
-> m (Result TreeRevisionHistory)
Docs.getTreeHistory UserID
userID DocumentID
docID Maybe UTCTime
before Maybe GroupID
limit

getDocumentHistoryHandler
    :: AuthResult Auth.Token
    -> DocumentID
    -> Maybe UTCTime
    -> Maybe Docs.Limit
    -> Handler DocumentHistory
getDocumentHistoryHandler :: AuthResult Token
-> DocumentID
-> Maybe UTCTime
-> Maybe GroupID
-> Handler DocumentHistory
getDocumentHistoryHandler AuthResult Token
auth DocumentID
docID Maybe UTCTime
before Maybe GroupID
limit = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    (Connection -> IO (Either SessionError (Result DocumentHistory)))
-> Handler DocumentHistory
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection -> IO (Either SessionError (Result DocumentHistory)))
 -> Handler DocumentHistory)
-> (Connection
    -> IO (Either SessionError (Result DocumentHistory)))
-> Handler DocumentHistory
forall a b. (a -> b) -> a -> b
$ HasqlSession (Result DocumentHistory)
-> Connection -> IO (Either SessionError (Result DocumentHistory))
forall a.
HasqlSession a -> Connection -> IO (Either SessionError a)
run (HasqlSession (Result DocumentHistory)
 -> Connection -> IO (Either SessionError (Result DocumentHistory)))
-> HasqlSession (Result DocumentHistory)
-> Connection
-> IO (Either SessionError (Result DocumentHistory))
forall a b. (a -> b) -> a -> b
$ UserID
-> DocumentID
-> Maybe UTCTime
-> Maybe GroupID
-> HasqlSession (Result DocumentHistory)
forall (m :: * -> *).
(HasGetDocumentHistory m, HasLogMessage m) =>
UserID
-> DocumentID
-> Maybe UTCTime
-> Maybe GroupID
-> m (Result DocumentHistory)
Docs.getDocumentHistory UserID
userID DocumentID
docID Maybe UTCTime
before Maybe GroupID
limit

postCommentHandler
    :: AuthResult Auth.Token
    -> DocumentID
    -> TextElementID
    -> CreateComment
    -> Handler Comment
postCommentHandler :: AuthResult Token
-> DocumentID -> TextElementID -> CreateComment -> Handler Comment
postCommentHandler AuthResult Token
auth DocumentID
docID TextElementID
textID CreateComment
comment = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    (Connection -> IO (Either SessionError (Result Comment)))
-> Handler Comment
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection -> IO (Either SessionError (Result Comment)))
 -> Handler Comment)
-> (Connection -> IO (Either SessionError (Result Comment)))
-> Handler Comment
forall a b. (a -> b) -> a -> b
$
        HasqlTransaction (Result Comment)
-> Connection -> IO (Either SessionError (Result Comment))
forall a.
HasqlTransaction a -> Connection -> IO (Either SessionError a)
runTransaction (HasqlTransaction (Result Comment)
 -> Connection -> IO (Either SessionError (Result Comment)))
-> HasqlTransaction (Result Comment)
-> Connection
-> IO (Either SessionError (Result Comment))
forall a b. (a -> b) -> a -> b
$
            UserID
-> TextElementRef -> Text -> HasqlTransaction (Result Comment)
forall (m :: * -> *).
(HasCreateComment m, HasLogMessage m) =>
UserID -> TextElementRef -> Text -> m (Result Comment)
Docs.createComment
                UserID
userID
                (DocumentID -> TextElementID -> TextElementRef
TextElementRef DocumentID
docID TextElementID
textID)
                (CreateComment -> Text
CreateComment.text CreateComment
comment)

getCommentsHandler
    :: AuthResult Auth.Token
    -> DocumentID
    -> TextElementID
    -> Handler Comments
getCommentsHandler :: AuthResult Token -> DocumentID -> TextElementID -> Handler Comments
getCommentsHandler AuthResult Token
auth DocumentID
docID TextElementID
textID = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    Vector Comment
comments <-
        (Connection -> IO (Either SessionError (Result (Vector Comment))))
-> Handler (Vector Comment)
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection -> IO (Either SessionError (Result (Vector Comment))))
 -> Handler (Vector Comment))
-> (Connection
    -> IO (Either SessionError (Result (Vector Comment))))
-> Handler (Vector Comment)
forall a b. (a -> b) -> a -> b
$
            HasqlSession (Result (Vector Comment))
-> Connection -> IO (Either SessionError (Result (Vector Comment)))
forall a.
HasqlSession a -> Connection -> IO (Either SessionError a)
run (HasqlSession (Result (Vector Comment))
 -> Connection
 -> IO (Either SessionError (Result (Vector Comment))))
-> HasqlSession (Result (Vector Comment))
-> Connection
-> IO (Either SessionError (Result (Vector Comment)))
forall a b. (a -> b) -> a -> b
$
                UserID -> TextElementRef -> HasqlSession (Result (Vector Comment))
forall (m :: * -> *).
(HasGetComments m, HasLogMessage m) =>
UserID -> TextElementRef -> m (Result (Vector Comment))
Docs.getComments
                    UserID
userID
                    (DocumentID -> TextElementID -> TextElementRef
TextElementRef DocumentID
docID TextElementID
textID)
    Comments -> Handler Comments
forall a. a -> Handler a
forall (m :: * -> *) a. Monad m => a -> m a
return (Comments -> Handler Comments) -> Comments -> Handler Comments
forall a b. (a -> b) -> a -> b
$ Vector Comment -> Comments
Comments Vector Comment
comments

resolveCommentHandler
    :: AuthResult Auth.Token
    -> DocumentID
    -> TextElementID
    -> CommentID
    -> Handler ()
resolveCommentHandler :: AuthResult Token
-> DocumentID -> TextElementID -> CommentID -> Handler ()
resolveCommentHandler AuthResult Token
auth DocumentID
docID TextElementID
textID CommentID
commentID = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    (Connection -> IO (Either SessionError (Result ()))) -> Handler ()
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection -> IO (Either SessionError (Result ())))
 -> Handler ())
-> (Connection -> IO (Either SessionError (Result ())))
-> Handler ()
forall a b. (a -> b) -> a -> b
$
        HasqlTransaction (Result ())
-> Connection -> IO (Either SessionError (Result ()))
forall a.
HasqlTransaction a -> Connection -> IO (Either SessionError a)
runTransaction (HasqlTransaction (Result ())
 -> Connection -> IO (Either SessionError (Result ())))
-> HasqlTransaction (Result ())
-> Connection
-> IO (Either SessionError (Result ()))
forall a b. (a -> b) -> a -> b
$
            UserID -> CommentRef -> HasqlTransaction (Result ())
forall (m :: * -> *).
(HasCreateComment m, HasLogMessage m) =>
UserID -> CommentRef -> m (Result ())
Docs.resolveComment UserID
userID (TextElementRef -> CommentID -> CommentRef
CommentRef (DocumentID -> TextElementID -> TextElementRef
TextElementRef DocumentID
docID TextElementID
textID) CommentID
commentID)

createReplyHandler
    :: AuthResult Auth.Token
    -> DocumentID
    -> TextElementID
    -> CommentID
    -> CreateReply
    -> Handler Message
createReplyHandler :: AuthResult Token
-> DocumentID
-> TextElementID
-> CommentID
-> CreateReply
-> Handler Message
createReplyHandler AuthResult Token
auth DocumentID
docID TextElementID
textID CommentID
commentID CreateReply
bodyDTO = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    (Connection -> IO (Either SessionError (Result Message)))
-> Handler Message
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB
        ((Connection -> IO (Either SessionError (Result Message)))
 -> Handler Message)
-> (Connection -> IO (Either SessionError (Result Message)))
-> Handler Message
forall a b. (a -> b) -> a -> b
$ HasqlTransaction (Result Message)
-> Connection -> IO (Either SessionError (Result Message))
forall a.
HasqlTransaction a -> Connection -> IO (Either SessionError a)
runTransaction
        (HasqlTransaction (Result Message)
 -> Connection -> IO (Either SessionError (Result Message)))
-> HasqlTransaction (Result Message)
-> Connection
-> IO (Either SessionError (Result Message))
forall a b. (a -> b) -> a -> b
$ UserID -> CommentRef -> Text -> HasqlTransaction (Result Message)
forall (m :: * -> *).
(HasCreateComment m, HasLogMessage m) =>
UserID -> CommentRef -> Text -> m (Result Message)
Docs.createReply
            UserID
userID
            (TextElementRef -> CommentID -> CommentRef
CommentRef (DocumentID -> TextElementID -> TextElementRef
TextElementRef DocumentID
docID TextElementID
textID) CommentID
commentID)
        (Text -> HasqlTransaction (Result Message))
-> Text -> HasqlTransaction (Result Message)
forall a b. (a -> b) -> a -> b
$ CreateReply -> Text
CreateReply.text
            CreateReply
bodyDTO

getDocumentRevisionHandler
    :: AuthResult Auth.Token
    -> DocumentID
    -> RevisionSelector
    -> Handler (FullDocument TextElementRevision)
getDocumentRevisionHandler :: AuthResult Token
-> DocumentID
-> RevisionSelector
-> Handler (FullDocument TextElementRevision)
getDocumentRevisionHandler AuthResult Token
auth DocumentID
docID RevisionSelector
rev = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    (Connection
 -> IO
      (Either SessionError (Result (FullDocument TextElementRevision))))
-> Handler (FullDocument TextElementRevision)
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection
  -> IO
       (Either SessionError (Result (FullDocument TextElementRevision))))
 -> Handler (FullDocument TextElementRevision))
-> (Connection
    -> IO
         (Either SessionError (Result (FullDocument TextElementRevision))))
-> Handler (FullDocument TextElementRevision)
forall a b. (a -> b) -> a -> b
$ HasqlSession (Result (FullDocument TextElementRevision))
-> Connection
-> IO
     (Either SessionError (Result (FullDocument TextElementRevision)))
forall a.
HasqlSession a -> Connection -> IO (Either SessionError a)
run (HasqlSession (Result (FullDocument TextElementRevision))
 -> Connection
 -> IO
      (Either SessionError (Result (FullDocument TextElementRevision))))
-> HasqlSession (Result (FullDocument TextElementRevision))
-> Connection
-> IO
     (Either SessionError (Result (FullDocument TextElementRevision)))
forall a b. (a -> b) -> a -> b
$ UserID
-> RevisionRef
-> HasqlSession (Result (FullDocument TextElementRevision))
forall (m :: * -> *).
(HasGetTreeRevision m, HasGetTextElementRevision m,
 HasGetRevisionKey m, HasGetDocument m, HasLogMessage m) =>
UserID
-> RevisionRef -> m (Result (FullDocument TextElementRevision))
Docs.getDocumentRevision UserID
userID (DocumentID -> RevisionSelector -> RevisionRef
RevisionRef DocumentID
docID RevisionSelector
rev)

getDocumentRevisionPDFHandler
    :: AuthResult Auth.Token
    -> DocumentID
    -> RevisionSelector
    -> Handler PDFBytes
getDocumentRevisionPDFHandler :: AuthResult Token
-> DocumentID -> RevisionSelector -> Handler PDFBytes
getDocumentRevisionPDFHandler AuthResult Token
auth DocumentID
docID RevisionSelector
revision = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    (Connection -> IO (Either SessionError (Result PDFBytes)))
-> Handler PDFBytes
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection -> IO (Either SessionError (Result PDFBytes)))
 -> Handler PDFBytes)
-> (Connection -> IO (Either SessionError (Result PDFBytes)))
-> Handler PDFBytes
forall a b. (a -> b) -> a -> b
$
        HasqlSession (Result PDFBytes)
-> Connection -> IO (Either SessionError (Result PDFBytes))
forall a.
HasqlSession a -> Connection -> IO (Either SessionError a)
run (HasqlSession (Result PDFBytes)
 -> Connection -> IO (Either SessionError (Result PDFBytes)))
-> HasqlSession (Result PDFBytes)
-> Connection
-> IO (Either SessionError (Result PDFBytes))
forall a b. (a -> b) -> a -> b
$
            UserID -> RevisionRef -> HasqlSession (Result PDFBytes)
forall (m :: * -> *).
(HasGetTreeRevision m, HasGetTextElementRevision m,
 HasGetRevisionKey m, HasGetDocument m, HasLogMessage m,
 MonadIO m) =>
UserID -> RevisionRef -> m (Result PDFBytes)
Docs.getDocumentRevisionPDF UserID
userID (RevisionRef -> HasqlSession (Result PDFBytes))
-> RevisionRef -> HasqlSession (Result PDFBytes)
forall a b. (a -> b) -> a -> b
$
                DocumentID -> RevisionSelector -> RevisionRef
RevisionRef DocumentID
docID RevisionSelector
revision

getDocumentRevisionHTMLHandler
    :: AuthResult Auth.Token
    -> DocumentID
    -> RevisionSelector
    -> Handler ZipBytes
getDocumentRevisionHTMLHandler :: AuthResult Token
-> DocumentID -> RevisionSelector -> Handler ZipBytes
getDocumentRevisionHTMLHandler AuthResult Token
auth DocumentID
docID RevisionSelector
revision = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    (Connection -> IO (Either SessionError (Result ZipBytes)))
-> Handler ZipBytes
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection -> IO (Either SessionError (Result ZipBytes)))
 -> Handler ZipBytes)
-> (Connection -> IO (Either SessionError (Result ZipBytes)))
-> Handler ZipBytes
forall a b. (a -> b) -> a -> b
$
        HasqlSession (Result ZipBytes)
-> Connection -> IO (Either SessionError (Result ZipBytes))
forall a.
HasqlSession a -> Connection -> IO (Either SessionError a)
run (HasqlSession (Result ZipBytes)
 -> Connection -> IO (Either SessionError (Result ZipBytes)))
-> HasqlSession (Result ZipBytes)
-> Connection
-> IO (Either SessionError (Result ZipBytes))
forall a b. (a -> b) -> a -> b
$
            UserID -> RevisionRef -> HasqlSession (Result ZipBytes)
forall (m :: * -> *).
(HasGetTreeRevision m, HasGetTextElementRevision m,
 HasGetRevisionKey m, HasGetDocument m, HasLogMessage m,
 MonadIO m) =>
UserID -> RevisionRef -> m (Result ZipBytes)
Docs.getDocumentRevisionHTML UserID
userID (RevisionRef -> HasqlSession (Result ZipBytes))
-> RevisionRef -> HasqlSession (Result ZipBytes)
forall a b. (a -> b) -> a -> b
$
                DocumentID -> RevisionSelector -> RevisionRef
RevisionRef DocumentID
docID RevisionSelector
revision

getDocumentRevisionTreeHandler
    :: AuthResult Auth.Token
    -> DocumentID
    -> RevisionSelector
    -> Handler (Maybe (TreeRevision TextElement))
getDocumentRevisionTreeHandler :: AuthResult Token
-> DocumentID
-> RevisionSelector
-> Handler (Maybe (TreeRevision TextElement))
getDocumentRevisionTreeHandler AuthResult Token
auth DocumentID
docID RevisionSelector
rev = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    (Connection
 -> IO
      (Either SessionError (Result (Maybe (TreeRevision TextElement)))))
-> Handler (Maybe (TreeRevision TextElement))
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection
  -> IO
       (Either SessionError (Result (Maybe (TreeRevision TextElement)))))
 -> Handler (Maybe (TreeRevision TextElement)))
-> (Connection
    -> IO
         (Either SessionError (Result (Maybe (TreeRevision TextElement)))))
-> Handler (Maybe (TreeRevision TextElement))
forall a b. (a -> b) -> a -> b
$ HasqlSession (Result (Maybe (TreeRevision TextElement)))
-> Connection
-> IO
     (Either SessionError (Result (Maybe (TreeRevision TextElement))))
forall a.
HasqlSession a -> Connection -> IO (Either SessionError a)
run (HasqlSession (Result (Maybe (TreeRevision TextElement)))
 -> Connection
 -> IO
      (Either SessionError (Result (Maybe (TreeRevision TextElement)))))
-> HasqlSession (Result (Maybe (TreeRevision TextElement)))
-> Connection
-> IO
     (Either SessionError (Result (Maybe (TreeRevision TextElement))))
forall a b. (a -> b) -> a -> b
$ UserID
-> RevisionRef
-> HasqlSession (Result (Maybe (TreeRevision TextElement)))
forall (m :: * -> *).
(HasGetTreeRevision m, HasGetRevisionKey m, HasLogMessage m) =>
UserID
-> RevisionRef -> m (Result (Maybe (TreeRevision TextElement)))
Docs.getDocumentRevisionTree UserID
userID (DocumentID -> RevisionSelector -> RevisionRef
RevisionRef DocumentID
docID RevisionSelector
rev)

getDocumentRevisionTextHandler
    :: AuthResult Auth.Token
    -> DocumentID
    -> RevisionSelector
    -> TextElementID
    -> Handler (Maybe TextElementRevision)
getDocumentRevisionTextHandler :: AuthResult Token
-> DocumentID
-> RevisionSelector
-> TextElementID
-> Handler (Maybe TextElementRevision)
getDocumentRevisionTextHandler AuthResult Token
auth DocumentID
docID RevisionSelector
rev TextElementID
textID = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    (Connection
 -> IO (Either SessionError (Result (Maybe TextElementRevision))))
-> Handler (Maybe TextElementRevision)
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection
  -> IO (Either SessionError (Result (Maybe TextElementRevision))))
 -> Handler (Maybe TextElementRevision))
-> (Connection
    -> IO (Either SessionError (Result (Maybe TextElementRevision))))
-> Handler (Maybe TextElementRevision)
forall a b. (a -> b) -> a -> b
$
        HasqlSession (Result (Maybe TextElementRevision))
-> Connection
-> IO (Either SessionError (Result (Maybe TextElementRevision)))
forall a.
HasqlSession a -> Connection -> IO (Either SessionError a)
run (HasqlSession (Result (Maybe TextElementRevision))
 -> Connection
 -> IO (Either SessionError (Result (Maybe TextElementRevision))))
-> HasqlSession (Result (Maybe TextElementRevision))
-> Connection
-> IO (Either SessionError (Result (Maybe TextElementRevision)))
forall a b. (a -> b) -> a -> b
$
            UserID
-> RevisionRef
-> TextElementID
-> HasqlSession (Result (Maybe TextElementRevision))
forall (m :: * -> *).
(HasGetTextElementRevision m, HasGetRevisionKey m,
 HasLogMessage m) =>
UserID
-> RevisionRef
-> TextElementID
-> m (Result (Maybe TextElementRevision))
Docs.getDocumentRevisionText
                UserID
userID
                (DocumentID -> RevisionSelector -> RevisionRef
RevisionRef DocumentID
docID RevisionSelector
rev)
                TextElementID
textID

-- utililty

getUser :: AuthResult Auth.Token -> Handler UserID
getUser :: AuthResult Token -> Handler UserID
getUser (Authenticated Auth.Token {Bool
UserID
subject :: UserID
isSuperadmin :: Bool
isSuperadmin :: Token -> Bool
subject :: Token -> UserID
..}) = UserID -> Handler UserID
forall a. a -> Handler a
forall (m :: * -> *) a. Monad m => a -> m a
return UserID
subject
getUser AuthResult Token
_ = ServerError -> Handler UserID
forall a. ServerError -> Handler a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError ServerError
errNotLoggedIn

withDB
    :: (Connection -> IO (Either Session.SessionError (Docs.Result a)))
    -> Handler a
withDB :: forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB Connection -> IO (Either SessionError (Result a))
io = do
    Connection
db <- Handler Connection
tryGetDBConnection
    Either SessionError (Result a)
result <- IO (Either SessionError (Result a))
-> Handler (Either SessionError (Result a))
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Either SessionError (Result a))
 -> Handler (Either SessionError (Result a)))
-> IO (Either SessionError (Result a))
-> Handler (Either SessionError (Result a))
forall a b. (a -> b) -> a -> b
$ Connection -> IO (Either SessionError (Result a))
io Connection
db
    Either SessionError (Result a) -> Handler a
forall a. Either SessionError (Result a) -> Handler a
guardedDBAccess Either SessionError (Result a)
result

guardedDBAccess
    :: Either Session.SessionError (Docs.Result a)
    -> Handler a
guardedDBAccess :: forall a. Either SessionError (Result a) -> Handler a
guardedDBAccess Either SessionError (Result a)
result = Either SessionError (Result a) -> Handler (Result a)
forall a. Either SessionError a -> Handler a
guardDBResult Either SessionError (Result a)
result Handler (Result a) -> (Result a -> Handler a) -> Handler a
forall a b. Handler a -> (a -> Handler b) -> Handler b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Result a -> Handler a
forall a. Result a -> Handler a
guardDocsResult

guardDBResult :: Either Session.SessionError a -> Handler a
guardDBResult :: forall a. Either SessionError a -> Handler a
guardDBResult (Right a
ok) = a -> Handler a
forall a. a -> Handler a
forall (m :: * -> *) a. Monad m => a -> m a
return a
ok
guardDBResult (Left SessionError
err) =
    ServerError -> Handler a
forall a. ServerError -> Handler a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (ServerError -> Handler a) -> ServerError -> Handler a
forall a b. (a -> b) -> a -> b
$
        ServerError
err500
            { errBody = LBS.pack $ "Database error: " ++ show err ++ "\n"
            }

guardDocsResult :: Docs.Result a -> Handler a
guardDocsResult :: forall a. Result a -> Handler a
guardDocsResult (Right a
ok) = a -> Handler a
forall a. a -> Handler a
forall (m :: * -> *) a. Monad m => a -> m a
return a
ok
guardDocsResult (Left Error
err) = ServerError -> Handler a
forall a. ServerError -> Handler a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (ServerError -> Handler a) -> ServerError -> Handler a
forall a b. (a -> b) -> a -> b
$ Error -> ServerError
mapErr Error
err
  where
    mapErr :: Error -> ServerError
mapErr (Docs.NoPermission DocumentID
docID Permission
perms) =
        ServerError
err403
            { errBody =
                LBS.pack $
                    "You are not allowed to "
                        ++ show perms
                        ++ " document "
                        ++ show (unDocumentID docID)
                        ++ "!\n"
            }
    mapErr (Docs.NoPermissionForUser UserID
userID) =
        ServerError
err403
            { errBody =
                LBS.pack $
                    "You are not allowed to view information about "
                        ++ show userID
                        ++ "!\n"
            }
    mapErr (Docs.NoPermissionInGroup GroupID
groupID) =
        ServerError
err403
            { errBody =
                LBS.pack $
                    "You are not an admin in group "
                        ++ show groupID
                        ++ "!\n"
            }
    mapErr Error
Docs.SuperAdminOnly =
        ServerError
err403
            { errBody =
                LBS.pack
                    "This feature is only for super admins!\n"
            }
    mapErr (Docs.DocumentNotFound DocumentID
docID) =
        ServerError
err400
            { errBody =
                LBS.pack $
                    "Document "
                        ++ show (unDocumentID docID)
                        ++ " not found!\n"
            }
    mapErr (Docs.TextElementNotFound TextElementRef
ref) =
        ServerError
err400
            { errBody =
                LBS.pack $
                    "TextElement "
                        ++ prettyPrintTextElementRef ref
                        ++ " not found!\n"
            }
    mapErr (Docs.RevisionNotFound RevisionRef
ref) =
        ServerError
err400
            { errBody =
                LBS.pack $
                    "TextRevision "
                        ++ prettyPrintRevisionRef ref
                        ++ " not found!\n"
            }
    mapErr (Docs.TextRevisionNotFound TextRevisionRef
ref) =
        ServerError
err400
            { errBody =
                LBS.pack $
                    "TextRevision "
                        ++ prettyPrintTextRevisionRef ref
                        ++ " not found!\n"
            }
    mapErr (Docs.TreeRevisionNotFound TreeRevisionRef
ref) =
        ServerError
err400
            { errBody =
                LBS.pack $
                    "TreeRevision "
                        ++ prettyPrintTreeRevisionRef ref
                        ++ " not found!\n"
            }
    mapErr (Docs.CommentNotFound CommentRef
ref) =
        ServerError
err400
            { errBody =
                LBS.pack $
                    "Comment "
                        ++ prettyPrintCommentRef ref
                        ++ " not found!\n"
            }
    mapErr (Docs.Custom Text
msg) =
        ServerError
err400
            { errBody =
                LBS.pack $
                    T.unpack msg ++ "\n"
            }
    mapErr (Docs.PDFError Text
msg) =
        ServerError
err400
            { errBody =
                LBS.pack $
                    T.unpack msg ++ "\n"
            }
    mapErr Error
Docs.ZipHTMLError =
        ServerError
err400
            { errBody = "Error creating html zip file.\n"
            }

-- | Get draft text revision for current user
getDraftTextRevisionHandler
    :: AuthResult Auth.Token
    -> DocumentID
    -> TextElementID
    -> Handler (Maybe (Rendered DraftRevision))
getDraftTextRevisionHandler :: AuthResult Token
-> DocumentID
-> TextElementID
-> Handler (Maybe (Rendered DraftRevision))
getDraftTextRevisionHandler AuthResult Token
auth DocumentID
docID TextElementID
textID = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    (Connection
 -> IO
      (Either SessionError (Result (Maybe (Rendered DraftRevision)))))
-> Handler (Maybe (Rendered DraftRevision))
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection
  -> IO
       (Either SessionError (Result (Maybe (Rendered DraftRevision)))))
 -> Handler (Maybe (Rendered DraftRevision)))
-> (Connection
    -> IO
         (Either SessionError (Result (Maybe (Rendered DraftRevision)))))
-> Handler (Maybe (Rendered DraftRevision))
forall a b. (a -> b) -> a -> b
$
        HasqlTransaction (Result (Maybe (Rendered DraftRevision)))
-> Connection
-> IO
     (Either SessionError (Result (Maybe (Rendered DraftRevision))))
forall a.
HasqlTransaction a -> Connection -> IO (Either SessionError a)
runTransaction (HasqlTransaction (Result (Maybe (Rendered DraftRevision)))
 -> Connection
 -> IO
      (Either SessionError (Result (Maybe (Rendered DraftRevision)))))
-> HasqlTransaction (Result (Maybe (Rendered DraftRevision)))
-> Connection
-> IO
     (Either SessionError (Result (Maybe (Rendered DraftRevision))))
forall a b. (a -> b) -> a -> b
$
            UserID
-> TextElementRef
-> HasqlTransaction (Result (Maybe (Rendered DraftRevision)))
forall (m :: * -> *).
(HasDraftTextRevision m, HasLogMessage m, HasGetTreeRevision m,
 HasGetTextElementRevision m, HasGetRevisionKey m,
 HasGetDocument m) =>
UserID
-> TextElementRef -> m (Result (Maybe (Rendered DraftRevision)))
Docs.getDraftTextRevision UserID
userID (TextElementRef
 -> HasqlTransaction (Result (Maybe (Rendered DraftRevision))))
-> TextElementRef
-> HasqlTransaction (Result (Maybe (Rendered DraftRevision)))
forall a b. (a -> b) -> a -> b
$
                DocumentID -> TextElementID -> TextElementRef
TextElementRef DocumentID
docID TextElementID
textID

-- | Publish draft text revision to main revision tree
publishDraftTextRevisionHandler
    :: AuthResult Auth.Token
    -> DocumentID
    -> TextElementID
    -> Handler (Rendered ConflictStatus)
publishDraftTextRevisionHandler :: AuthResult Token
-> DocumentID -> TextElementID -> Handler (Rendered ConflictStatus)
publishDraftTextRevisionHandler AuthResult Token
auth DocumentID
docID TextElementID
textID = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    (Connection
 -> IO (Either SessionError (Result (Rendered ConflictStatus))))
-> Handler (Rendered ConflictStatus)
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection
  -> IO (Either SessionError (Result (Rendered ConflictStatus))))
 -> Handler (Rendered ConflictStatus))
-> (Connection
    -> IO (Either SessionError (Result (Rendered ConflictStatus))))
-> Handler (Rendered ConflictStatus)
forall a b. (a -> b) -> a -> b
$
        HasqlTransaction (Result (Rendered ConflictStatus))
-> Connection
-> IO (Either SessionError (Result (Rendered ConflictStatus)))
forall a.
HasqlTransaction a -> Connection -> IO (Either SessionError a)
runTransaction (HasqlTransaction (Result (Rendered ConflictStatus))
 -> Connection
 -> IO (Either SessionError (Result (Rendered ConflictStatus))))
-> HasqlTransaction (Result (Rendered ConflictStatus))
-> Connection
-> IO (Either SessionError (Result (Rendered ConflictStatus)))
forall a b. (a -> b) -> a -> b
$
            UserID
-> TextElementRef
-> HasqlTransaction (Result (Rendered ConflictStatus))
forall (m :: * -> *).
(HasDraftTextRevision m, HasCreateTextRevision m,
 HasGetTextElementRevision m, HasExistsComment m,
 HasGetRevisionKey m, HasGetDocument m, HasGetTreeRevision m,
 HasLogMessage m) =>
UserID -> TextElementRef -> m (Result (Rendered ConflictStatus))
Docs.publishDraftTextRevision UserID
userID (TextElementRef
 -> HasqlTransaction (Result (Rendered ConflictStatus)))
-> TextElementRef
-> HasqlTransaction (Result (Rendered ConflictStatus))
forall a b. (a -> b) -> a -> b
$
                DocumentID -> TextElementID -> TextElementRef
TextElementRef DocumentID
docID TextElementID
textID

-- | Discard draft text revision
discardDraftTextRevisionHandler
    :: AuthResult Auth.Token
    -> DocumentID
    -> TextElementID
    -> Handler ()
discardDraftTextRevisionHandler :: AuthResult Token -> DocumentID -> TextElementID -> Handler ()
discardDraftTextRevisionHandler AuthResult Token
auth DocumentID
docID TextElementID
textID = do
    UserID
userID <- AuthResult Token -> Handler UserID
getUser AuthResult Token
auth
    (Connection -> IO (Either SessionError (Result ()))) -> Handler ()
forall a.
(Connection -> IO (Either SessionError (Result a))) -> Handler a
withDB ((Connection -> IO (Either SessionError (Result ())))
 -> Handler ())
-> (Connection -> IO (Either SessionError (Result ())))
-> Handler ()
forall a b. (a -> b) -> a -> b
$
        HasqlTransaction (Result ())
-> Connection -> IO (Either SessionError (Result ()))
forall a.
HasqlTransaction a -> Connection -> IO (Either SessionError a)
runTransaction (HasqlTransaction (Result ())
 -> Connection -> IO (Either SessionError (Result ())))
-> HasqlTransaction (Result ())
-> Connection
-> IO (Either SessionError (Result ()))
forall a b. (a -> b) -> a -> b
$
            UserID -> TextElementRef -> HasqlTransaction (Result ())
forall (m :: * -> *).
(HasDraftTextRevision m, HasLogMessage m) =>
UserID -> TextElementRef -> m (Result ())
Docs.discardDraftTextRevision UserID
userID (TextElementRef -> HasqlTransaction (Result ()))
-> TextElementRef -> HasqlTransaction (Result ())
forall a b. (a -> b) -> a -> b
$
                DocumentID -> TextElementID -> TextElementRef
TextElementRef DocumentID
docID TextElementID
textID