Module

FPO.Data.Request

This module provides functions for making HTTP requests, including GET and POST requests. It supports various response formats such as String, JSON, Document, and Blob. The functions use the Affjax library to handle asynchronous HTTP requests.

#LoadState​

data LoadState a

High-level requests --------------------------------------------------- State of an asynchronous load operation. It can either be in a loading state or have successfully loaded data.

Constructors

Instances

#addGroup​

addGroup :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => GroupCreate -> HalogenM st act slots msg m (Either AppError GroupID)

#changeRole​

changeRole :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => GroupID -> UserID -> Role -> HalogenM st act slots msg m (Either AppError Unit)

#createNewDocument​

createNewDocument :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => NewDocumentCreateDto -> HalogenM st act slots msg m (Either AppError FullDocument)

#deleteIgnore​

deleteIgnore :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => String -> HalogenM st act slots msg m (Either AppError Unit)

#fromLoading​

fromLoading :: forall a. LoadState a -> a -> a

Extracts the loaded value from a LoadState, providing a default if not loaded.

#getAuthorizedUser​

getAuthorizedUser :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => GroupID -> HalogenM st act slots msg m (Either AppError (Maybe FullUserDto))

Fetches the authorized user for a specific group. Returns Nothing if the user is not existing or not authorized.

#getBlob​

getBlob :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => String -> HalogenM st act slots msg m (Either AppError Blob)

#getBlobOrError​

getBlobOrError :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => String -> HalogenM st act slots msg m (Either AppError (Either String Blob))

#getCommentSections​

getCommentSections :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => DocumentID -> Int -> HalogenM st act slots msg m (Either AppError CommentSections)

#getDocument​

getDocument :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => String -> HalogenM st act slots msg m (Either AppError Document)

#getDocumentHeader​

getDocumentHeader :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => DocumentID -> HalogenM st act slots msg m (Either AppError DocumentHeader)

#getDocumentsQueryFromURL​

getDocumentsQueryFromURL :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => String -> HalogenM st act slots msg m (Either AppError DocumentQuery)

#getGroup​

getGroup :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => GroupID -> HalogenM st act slots msg m (Either AppError GroupDto)

#getGroups​

getGroups :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => HalogenM st act slots msg m (Either AppError (Array GroupOverview))

#getIgnore​

getIgnore :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => String -> HalogenM st act slots msg m (Either AppError Unit)

#getIgnoreSilent​

getIgnoreSilent :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => String -> HalogenM st act slots msg m (Either AppError Unit)

Silent variant of getIgnore — no toasts, no redirects on error.

#getDocumentHistory​

getDocumentHistory :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => DocumentID -> Maybe DocDate -> Maybe Int -> HalogenM st act slots msg m (Either AppError DocumentHistory)

Fetches document-wide history from /docs/{documentID}/history endpoint. This includes both tree revisions (structure changes) and text revisions (content changes). Parameters:

  • dID: The document ID
  • before: Optional date to filter history items before this date
  • limit: Optional maximum number of items to return

#getJson​

getJson :: forall a st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => (Json -> Either JsonDecodeError a) -> String -> HalogenM st act slots msg m (Either AppError a)

#getJsonSilent​

getJsonSilent :: forall a st act slots msg m. MonadAff m => MonadStore Action Store m => (Json -> Either JsonDecodeError a) -> String -> HalogenM st act slots msg m (Either AppError a)

Silent variant of getJson — no toasts, no redirects on error.

#getString​

getString :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => String -> HalogenM st act slots msg m (Either AppError String)

Simplified Error-Handling HTTP Methods ---------------------------------- Error-handling versions of basic HTTP methods

#getTextElemHistory​

getTextElemHistory :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => DocumentID -> TextElementID -> Maybe DocDate -> Maybe DocDate -> Maybe Int -> HalogenM st act slots msg m (Either AppError FullTextElementHistory)

#getTreeHistory​

getTreeHistory :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => DocumentID -> Maybe DocDate -> Maybe Int -> HalogenM st act slots msg m (Either AppError TreeRevisionHistory)

Fetches tree revision history from /docs/{documentID}/tree/history endpoint. This includes only tree revisions (document structure changes). Parameters:

  • dID: The document ID
  • before: Optional date to filter history items before this date
  • limit: Optional maximum number of items to return

#getUser​

getUser :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => HalogenM st act slots msg m (Either AppError FullUserDto)

Error-handling versions of domain-specific functions

#getUserSilent​

getUserSilent :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => HalogenM st act slots msg m (Either AppError FullUserDto)

Silent variant of getUser — no toasts, no redirects on error. Use this when a 401 is an expected / normal outcome (e.g. Navbar checking whether the user is logged in, Home page probe).

#getUserDocuments​

getUserDocuments :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => UserID -> HalogenM st act slots msg m (Either AppError (Array DocumentHeader))

#getUserGroups​

getUserGroups :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => HalogenM st act slots msg m (Either AppError (Array GroupOverview))

#getUserWithId​

getUserWithId :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => String -> HalogenM st act slots msg m (Either AppError FullUserDto)

#getUsers​

getUsers :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => HalogenM st act slots msg m (Either AppError (Array UserOverviewDto))

#handleAppError​

handleAppError :: forall st act slots msg m. MonadAff m => Navigate m => MonadStore Action Store m => AppError -> HalogenM st act slots msg m Unit

Helper function to handle app errors.

For AuthError (401), we always read the current browser URL via currentPath instead of relying on the store's currentRoute. This avoids two classes of bugs:

  1. The store's currentRoute may be stale when the user just navigated (pushState updated the URL, but the async NavigateQ hasn't updated the store yet). Using the browser URL ensures the redirect target is the page the user intended to visit.
  2. No dependency on a global flag — the old handleRequestError flag caused race conditions when the Navbar's silent user-check overlapped with other components' API calls.

#patchGroup​

patchGroup :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => GroupID -> GroupPatch -> HalogenM st act slots msg m (Either AppError GroupOverview)

Updates a group's name and/or description via PATCH

#patchJson​

patchJson :: forall a st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => (Json -> Either JsonDecodeError a) -> String -> Json -> HalogenM st act slots msg m (Either AppError a)

#patchString​

patchString :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => String -> Json -> HalogenM st act slots msg m (Either AppError String)

#postBlob​

postBlob :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => String -> Json -> HalogenM st act slots msg m (Either AppError Blob)

#postBlobOrError​

postBlobOrError :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => String -> Json -> HalogenM st act slots msg m (Either AppError (Either String Blob))

Makes a POST request that can handle both Blob success and String error responses Currently used for PDF generation to be able to display the internal error case.

#postDocument​

postDocument :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => String -> Json -> HalogenM st act slots msg m (Either AppError Document)

#postIgnore​

postIgnore :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => String -> Json -> HalogenM st act slots msg m (Either AppError Unit)

#postIgnoreOrError​

postIgnoreOrError :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => String -> Json -> HalogenM st act slots msg m (Either AppError (Either String Unit))

#postJson​

postJson :: forall a st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => (Json -> Either JsonDecodeError a) -> String -> Json -> HalogenM st act slots msg m (Either AppError a)

#postRenderHtml​

postRenderHtml :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => String -> HalogenM st act slots msg m (Either AppError String)

#postString​

postString :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => String -> Json -> HalogenM st act slots msg m (Either AppError String)

#postStringSilent​

postStringSilent :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => String -> Json -> HalogenM st act slots msg m (Either AppError String)

Silent variant of postString — no toasts, no redirects on error.

#postText​

postText :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => DocumentID -> PostTextDto -> HalogenM st act slots msg m (Either AppError PostTextDto)

#putIgnore​

putIgnore :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => String -> Json -> HalogenM st act slots msg m (Either AppError Unit)

#putJson​

putJson :: forall a st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => (Json -> Either JsonDecodeError a) -> String -> Json -> HalogenM st act slots msg m (Either AppError a)

#removeUser​

removeUser :: forall st act slots msg m. MonadAff m => MonadStore Action Store m => Navigate m => GroupID -> UserID -> HalogenM st act slots msg m (Either AppError Unit)

Modules