@reqquest/ui 1.0.0 → 1.1.0

package/dist/api.js

@@ -1,7 +1,11 @@
-import { PUBLIC_API_BASE, PUBLIC_AUTH_REDIRECT } from '$env/static/public';
+import { PUBLIC_API_BASE, PUBLIC_AUTH_REDIRECT, PUBLIC_SHOW_DUPLICATE_PROMPTS } from '$env/static/public';
 import { APIBase } from '@txstate-mws/sveltekit-utils';
-import { createClient, enumAppRequestIndexDestination, enumPromptVisibility, enumRequirementType } from './typed-client/index.js';
+import { createClient, enumAppRequestIndexDestination, enumIneligiblePhases, enumPromptVisibility, enumRequirementStatus, enumRequirementType } from './typed-client/index.js';
 import { DateTime } from 'luxon';
+import { omit, pick } from 'txstate-utils';
+import { error } from '@sveltejs/kit';
+import { applicantRequirementTypes } from './status-utils.js';
+export const showDupePrompts = PUBLIC_SHOW_DUPLICATE_PROMPTS.trim() === 'true';
 class API extends APIBase {
     client = createClient({
         url: PUBLIC_API_BASE,
@@ -16,147 +20,439 @@ class API extends APIBase {
         const response = await this.client.query({
             __name: 'GetAccess',
             access: {
+                user: {
+                    login: true,
+                    fullname: true
+                },
                 createPeriod: true,
                 createRole: true,
                 viewRoleManagement: true,
                 viewPeriodManagement: true,
                 viewReviewerInterface: true,
                 viewApplicantDashboard: true,
-                viewAppRequestList: true
+                viewAppRequestList: true,
+                createAppRequestSelf: true,
+                createAppRequestOther: true
             }
         });
         return response.access;
     }
-    async getApplicantRequests() {
+    async getAccessUsers(accessUsersFilter, pageFilter) {
+        const filter = accessUsersFilter;
+        const paged = pageFilter;
+        const response = await this.client.query({
+            __name: 'GetAccessUsers',
+            accessUsers: {
+                __args: { filter, paged },
+                login: true,
+                fullname: true,
+                groups: true,
+                roles: {
+                    name: true
+                },
+                otherIdentifiers: {
+                    id: true,
+                    label: true
+                },
+                otherInfo: true
+            },
+            pageInfo: {
+                accessUsers: {
+                    currentPage: true,
+                    totalItems: true,
+                    hasNextPage: true,
+                    perPage: true,
+                    categories: {
+                        tags: {
+                            tag: true,
+                            label: true
+                        },
+                        category: true,
+                        label: true,
+                        useInFilters: true,
+                        useInList: true
+                    }
+                }
+            }
+        });
+        return { users: response.accessUsers, pageInfo: response.pageInfo.accessUsers };
+    }
+    async getApplicantRequests(additionalFilters = {}, paged) {
+        // const filter = { own: true, ...additionalFilters }
+        const filter = { ...additionalFilters };
         const response = await this.client.query({
             __name: 'GetApplicantRequests',
             appRequests: {
-                __args: { filter: { own: true } },
+                __args: { filter, paged },
                 id: true,
                 status: true,
+                createdAt: true,
+                updatedAt: true,
+                complete: true,
+                applicant: {
+                    fullname: true,
+                    otherIdentifiers: {
+                        id: true
+                    }
+                },
                 period: {
                     name: true,
                     openDate: true,
                     closeDate: true
+                },
+                applications: {
+                    id: true,
+                    title: true,
+                    status: true,
+                    statusReason: true,
+                    requirements: {
+                        id: true,
+                        type: true,
+                        status: true,
+                        statusReason: true,
+                        prompts: {
+                            id: true,
+                            visibility: true,
+                            invalidated: true,
+                            invalidatedReason: true
+                        }
+                    }
+                },
+                actions: {
+                    acceptOffer: true,
+                    cancel: true,
+                    reopen: true,
+                    returnToApplicant: true,
+                    returnToOffer: true,
+                    submit: true
                 }
             }
         });
         return response.appRequests;
     }
-    async getNextPrompt(appRequestId, currentPromptKey) {
+    async getApplicantPrompt(appRequestId, promptId) {
         const response = await this.client.query({
-            __name: 'GetNextPrompt',
+            __name: 'GetPromptData',
             appRequests: {
                 __args: { filter: { ids: [appRequestId] } },
+                data: true,
+                dataVersion: true,
                 applications: {
+                    id: true,
                     requirements: {
+                        type: true,
+                        status: true,
+                        statusReason: true,
                         prompts: {
                             id: true,
                             key: true,
+                            title: true,
+                            description: true,
                             answered: true,
-                            visibility: true
+                            visibility: true,
+                            preloadData: true,
+                            fetchedData: true,
+                            configurationData: true,
+                            gatheredConfigData: true
                         }
                     }
                 }
             }
         });
-        let currentKeyFound = false;
-        for (const applications of response.appRequests[0]?.applications ?? []) {
-            for (const requirement of applications.requirements) {
+        if (response.appRequests.length === 0)
+            return {};
+        const appRequest = response.appRequests[0];
+        for (const application of appRequest.applications) {
+            for (const requirement of application.requirements.filter(r => applicantRequirementTypes.has(r.type))) {
                 for (const prompt of requirement.prompts) {
-                    if ((!prompt.answered || currentKeyFound) && prompt.visibility === enumPromptVisibility.AVAILABLE)
-                        return prompt;
-                    if (prompt.key === currentPromptKey && prompt.visibility === enumPromptVisibility.AVAILABLE)
-                        currentKeyFound = true;
+                    if (prompt.id === promptId)
+                        return { prompt };
                 }
             }
         }
+        return {};
+    }
+    async updatePrompt(promptId, data, validateOnly, dataVersion) {
+        const response = await this.graphqlWithUploads(`
+      mutation UpdatePrompt($promptId: ID!, $data: JsonData!, $validateOnly: Boolean!, $dataVersion: Int) {
+        updatePrompt(promptId: $promptId, data: $data, validateOnly: $validateOnly, dataVersion: $dataVersion) {
+          success
+          messages {
+            message
+            type
+            arg
+          }
+        }
+      }
+    `, { promptId, data, validateOnly, dataVersion });
+        return this.mutationForDialog(response.updatePrompt);
     }
-    async getApplyNavigation(appRequestId) {
+    async updateConfiguration(periodId, definitionKey, data, validateOnly) {
+        const response = await this.client.mutation({
+            __name: 'UpdateConfiguration',
+            updateConfiguration: {
+                __args: { periodId, key: definitionKey, data, validateOnly },
+                success: true,
+                messages: {
+                    message: true,
+                    type: true,
+                    arg: true
+                }
+            }
+        });
+        return this.mutationForDialog(response.updateConfiguration);
+    }
+    async getAppRequestData(appRequestId) {
         const response = await this.client.query({
-            __name: 'GetApplyNavigation',
+            __name: 'GetAppRequestData',
             appRequests: {
                 __args: { filter: { ids: [appRequestId] } },
                 id: true,
-                status: true,
+                data: true,
                 applications: {
-                    id: true,
-                    status: true,
-                    statusReason: true,
-                    title: true,
-                    navTitle: true,
                     requirements: {
-                        id: true,
-                        type: true,
-                        status: true,
-                        statusReason: true,
                         prompts: {
-                            id: true,
                             key: true,
-                            title: true,
-                            navTitle: true,
-                            answered: true,
-                            visibility: true
+                            gatheredConfigData: true
                         }
                     }
                 }
             }
         });
         if (response.appRequests.length === 0)
-            return { prequalPrompts: [], appRequest: undefined };
+            return { data: {}, applications: [] };
         const appRequest = response.appRequests[0];
-        const prequalPrompts = appRequest.applications.flatMap(application => application.requirements.filter(r => r.type === enumRequirementType.PREQUAL).flatMap(r => r.prompts.filter(p => p.visibility === enumPromptVisibility.AVAILABLE)));
-        const postqualPrompts = appRequest.applications.flatMap(application => application.requirements.filter(r => r.type === enumRequirementType.POSTQUAL).flatMap(r => r.prompts.filter(p => p.visibility === enumPromptVisibility.AVAILABLE)));
-        const applications = appRequest.applications.map(application => ({
-            ...application,
-            requirements: application.requirements.filter(r => r.type === enumRequirementType.QUALIFICATION).map(requirement => ({
-                ...requirement,
-                prompts: requirement.prompts.filter(p => p.visibility === enumPromptVisibility.AVAILABLE)
-            }))
-        }));
-        return { prequalPrompts, postqualPrompts, appRequest: { ...appRequest, applications } };
-    }
-    async getApplicantPrompt(appRequestId, promptKey) {
+        return appRequest;
+    }
+    static splitPromptsForApplicant(applications) {
+        const prequalPrompts = [];
+        const postqualPrompts = [];
+        const qualPrompts = [];
+        const applicationsReviewWithDupes = [];
+        const applicationsReviewNoDupes = [];
+        const applicationsForNavWithDupes = [];
+        const applicationsForNavNoDupes = [];
+        const applicationsAcceptWithDupes = [];
+        const applicationsAcceptNoDupes = [];
+        const promptsById = {};
+        const promptsByKey = {};
+        const seenForReview = new Set();
+        const seenForNav = new Set();
+        const seenForAccept = new Set();
+        const visibilitiesToShow = new Set([enumPromptVisibility.AVAILABLE, enumPromptVisibility.REQUEST_DUPE]);
+        const requirementTypesForNavigation = new Set([enumRequirementType.PREQUAL, enumRequirementType.POSTQUAL, enumRequirementType.QUALIFICATION]);
+        const requirementTypesForReview = new Set([enumRequirementType.QUALIFICATION, enumRequirementType.PREAPPROVAL, enumRequirementType.APPROVAL, enumRequirementType.WORKFLOW]);
+        for (const application of applications) {
+            const requirementsReviewWithDupes = [];
+            const requirementsReviewNoDupes = [];
+            const requirementsForNavWithDupes = [];
+            const requirementsForNavNoDupes = [];
+            const requirementsAcceptWithDupes = [];
+            const requirementsAcceptNoDupes = [];
+            for (const requirement of application.requirements) {
+                const promptsForNavWithDupes = [];
+                const promptsForNavNoDupes = [];
+                const promptsReviewNoDupes = [];
+                const promptsReviewWithDupes = [];
+                const promptsAcceptWithDupes = [];
+                const promptsAcceptNoDupes = [];
+                for (const prompt of requirement.prompts) {
+                    const retPrompt = { ...prompt, statusReasons: [{ ...pick(requirement, 'status', 'statusReason'), programName: application.title }] };
+                    const withDupesPrompt = { ...retPrompt };
+                    promptsById[prompt.id] = retPrompt;
+                    if (prompt.moot || prompt.visibility === enumPromptVisibility.UNREACHABLE)
+                        continue;
+                    promptsByKey[prompt.key] ??= [];
+                    promptsByKey[prompt.key].push(retPrompt);
+                    if (!visibilitiesToShow.has(prompt.visibility))
+                        continue;
+                    promptsReviewWithDupes.push(withDupesPrompt);
+                    if (requirementTypesForNavigation.has(requirement.type))
+                        promptsForNavWithDupes.push(withDupesPrompt);
+                    if (requirement.type === enumRequirementType.ACCEPTANCE)
+                        promptsAcceptWithDupes.push(withDupesPrompt);
+                    if (!seenForReview.has(prompt.key))
+                        promptsReviewNoDupes.push(retPrompt);
+                    seenForReview.add(prompt.key);
+                    if (requirementTypesForNavigation.has(requirement.type)) {
+                        if (!seenForNav.has(prompt.key))
+                            promptsForNavNoDupes.push(retPrompt);
+                        seenForNav.add(prompt.key);
+                    }
+                    if (requirement.type === enumRequirementType.ACCEPTANCE) {
+                        if (!seenForAccept.has(prompt.key))
+                            promptsAcceptNoDupes.push(retPrompt);
+                        seenForAccept.add(prompt.key);
+                    }
+                }
+                if (requirement.type === enumRequirementType.PREQUAL)
+                    prequalPrompts.push(...promptsForNavNoDupes);
+                else if (requirement.type === enumRequirementType.POSTQUAL)
+                    postqualPrompts.push(...promptsForNavNoDupes);
+                else if (requirementTypesForReview.has(requirement.type)) {
+                    requirementsReviewWithDupes.push({ ...requirement, prompts: promptsReviewWithDupes });
+                    requirementsReviewNoDupes.push({ ...requirement, prompts: promptsReviewNoDupes });
+                    if (requirement.type === enumRequirementType.QUALIFICATION) {
+                        qualPrompts.push(...promptsForNavNoDupes);
+                        requirementsForNavWithDupes.push({ ...requirement, prompts: promptsForNavWithDupes });
+                        requirementsForNavNoDupes.push({ ...requirement, prompts: promptsForNavNoDupes });
+                    }
+                }
+                else if (requirement.type === enumRequirementType.ACCEPTANCE) {
+                    requirementsAcceptWithDupes.push({ ...requirement, prompts: promptsAcceptWithDupes });
+                    requirementsAcceptNoDupes.push({ ...requirement, prompts: promptsAcceptNoDupes });
+                }
+            }
+            const reqsForCompletion = application.requirements.filter(r => r.type !== enumRequirementType.POSTQUAL);
+            let completionStatus = 'ELIGIBLE';
+            let completionStatusForNav = 'ELIGIBLE';
+            const warningReasons = [];
+            const warningReasonsFull = [];
+            const ineligibleReasons = [];
+            const ineligibleReasonsFull = [];
+            let hasWarning = false;
+            let hasWarningForNav = false;
+            for (const req of reqsForCompletion) {
+                const showWarnings = application.ineligiblePhase !== enumIneligiblePhases.PREQUAL || req.type === enumRequirementType.PREQUAL;
+                if (req.status === enumRequirementStatus.PENDING) {
+                    if (completionStatus !== 'INELIGIBLE')
+                        completionStatus = 'PENDING';
+                    if (completionStatusForNav !== 'INELIGIBLE' && requirementTypesForNavigation.has(req.type))
+                        completionStatusForNav = 'PENDING';
+                }
+                else if (req.status === enumRequirementStatus.WARNING) {
+                    hasWarning = true;
+                    if (requirementTypesForNavigation.has(req.type))
+                        hasWarningForNav = true;
+                    if (req.statusReason && showWarnings) {
+                        if (requirementTypesForNavigation.has(req.type))
+                            warningReasons.push(req.statusReason);
+                        warningReasonsFull.push(req.statusReason);
+                    }
+                }
+                else if (req.status === enumRequirementStatus.DISQUALIFYING) {
+                    completionStatus = 'INELIGIBLE';
+                    if (requirementTypesForNavigation.has(req.type))
+                        completionStatusForNav = 'INELIGIBLE';
+                    if (req.statusReason && showWarnings) {
+                        if (requirementTypesForNavigation.has(req.type))
+                            ineligibleReasons.push(req.statusReason);
+                        if (application.ineligiblePhase !== enumIneligiblePhases.PREQUAL || req.type !== enumRequirementType.PREQUAL)
+                            ineligibleReasonsFull.push(req.statusReason);
+                    }
+                }
+            }
+            applicationsReviewWithDupes.push({ ...application, requirements: requirementsReviewWithDupes, completionStatus, warningReasons: warningReasonsFull, ineligibleReasons: ineligibleReasonsFull, hasWarning });
+            applicationsReviewNoDupes.push({ ...application, requirements: requirementsReviewNoDupes, completionStatus, warningReasons: warningReasonsFull, ineligibleReasons: ineligibleReasonsFull, hasWarning });
+            applicationsForNavWithDupes.push({ ...application, requirements: requirementsForNavWithDupes, completionStatus: completionStatusForNav, warningReasons, ineligibleReasons, hasWarning: hasWarningForNav });
+            applicationsForNavNoDupes.push({ ...application, requirements: requirementsForNavNoDupes, completionStatus: completionStatusForNav, warningReasons, ineligibleReasons, hasWarning: hasWarningForNav });
+            applicationsAcceptWithDupes.push({ ...application, requirements: requirementsAcceptWithDupes, completionStatus, warningReasons: warningReasonsFull, ineligibleReasons: ineligibleReasonsFull, hasWarning });
+            applicationsAcceptNoDupes.push({ ...application, requirements: requirementsAcceptNoDupes, completionStatus, warningReasons: warningReasonsFull, ineligibleReasons: ineligibleReasonsFull, hasWarning });
+        }
+        for (const prompts of Object.values(promptsByKey)) {
+            const statusReasons = prompts.map(p => p.statusReasons[0]);
+            for (const prompt of prompts)
+                prompt.statusReasons = statusReasons;
+        }
+        return { prequalPrompts, postqualPrompts, qualPrompts, applicationsReviewWithDupes, applicationsReviewNoDupes, applicationsForNavWithDupes, applicationsForNavNoDupes, applicationsAcceptWithDupes, applicationsAcceptNoDupes, promptsByKey, promptsById };
+    }
+    async getAppRequestForExport(appRequestId) {
         const response = await this.client.query({
-            __name: 'GetPromptData',
+            __name: 'GetAppRequestForExport',
             appRequests: {
                 __args: { filter: { ids: [appRequestId] } },
+                id: true,
+                status: true,
                 data: true,
+                dataVersion: true,
+                period: {
+                    name: true
+                },
                 applications: {
                     id: true,
+                    status: true,
+                    ineligiblePhase: true,
+                    statusReason: true,
+                    title: true,
+                    navTitle: true,
                     requirements: {
+                        id: true,
                         type: true,
                         status: true,
                         statusReason: true,
                         prompts: {
                             id: true,
                             key: true,
+                            title: true,
+                            navTitle: true,
+                            answered: true,
                             visibility: true,
-                            fetchedData: true,
-                            configurationRelatedData: true
+                            moot: true,
+                            invalidated: true,
+                            invalidatedReason: true,
+                            configurationData: true,
+                            gatheredConfigData: true
                         }
                     }
                 }
             }
         });
         if (response.appRequests.length === 0)
-            return {};
-        const appRequest = response.appRequests[0];
-        for (const application of appRequest.applications) {
-            for (const requirement of application.requirements.filter(r => r.type === enumRequirementType.PREQUAL || r.type === enumRequirementType.QUALIFICATION || r.type === enumRequirementType.POSTQUAL)) {
-                for (const prompt of requirement.prompts) {
-                    if (prompt.key === promptKey && prompt.visibility === enumPromptVisibility.AVAILABLE)
-                        return { appRequestData: appRequest.data, prompt };
+            throw error(404, 'Application request not found');
+        const splitInfo = API.splitPromptsForApplicant(response.appRequests[0]?.applications ?? []);
+        return {
+            ...omit(splitInfo, 'applicationsForNavNoDupes', 'applicationsForNavWithDupes', 'applicationsReviewNoDupes', 'applicationsReviewWithDupes'),
+            applicationsForNav: showDupePrompts ? splitInfo.applicationsForNavWithDupes : splitInfo.applicationsForNavNoDupes,
+            applicationsReview: showDupePrompts ? splitInfo.applicationsReviewWithDupes : splitInfo.applicationsReviewNoDupes,
+            applicationsAccept: showDupePrompts ? splitInfo.applicationsAcceptWithDupes : splitInfo.applicationsAcceptNoDupes,
+            appRequest: response.appRequests[0]
+        };
+    }
+    async createAppRequest(periodId, login, validateOnly) {
+        const messages = [];
+        if (!periodId)
+            messages.push({ message: 'You must select a period to create an application.', type: 'error', path: 'periodId' });
+        if (!login)
+            messages.push({ message: 'You must provide a login to create an application.', type: 'error', path: 'login' });
+        if (messages.length > 0)
+            return { success: false, messages, data: { periodId, login }, id: undefined };
+        const response = await this.client.mutation({
+            __name: 'CreateAppRequest',
+            createAppRequest: {
+                __args: { periodId: periodId, login: login, validateOnly },
+                success: true,
+                messages: {
+                    message: true,
+                    type: true,
+                    arg: true
+                },
+                appRequest: {
+                    id: true
                 }
             }
+        });
+        return { ...this.mutationForDialog(response.createAppRequest), id: response.createAppRequest.appRequest?.id };
+    }
+    async appRequestPhaseChange(appRequestId, phaseChange) {
+        const response = await this.graphql(`
+      mutation AppRequestPhaseChange($appRequestId: ID!) {
+        ${phaseChange}(appRequestId: $appRequestId) {
+          success
+          messages {
+            message
+            type
+            arg
+          }
         }
-        return { appRequestData: appRequest.data };
+      }
+    `, { appRequestId });
+        return this.mutationForDialog(response[phaseChange]);
     }
-    async updatePrompt(promptId, data, validateOnly) {
+    async cancelAppRequest(appRequestId, dataVersion) {
         const response = await this.client.mutation({
-            __name: 'UpdatePrompt',
-            updatePrompt: {
-                __args: { promptId, data, validateOnly },
+            __name: 'CancelAppRequest',
+            cancelAppRequest: {
+                __args: { appRequestId, dataVersion },
                 success: true,
                 messages: {
                     message: true,
@@ -165,13 +461,13 @@ class API extends APIBase {
                 }
             }
         });
-        return this.mutationForDialog(response.updatePrompt);
+        return this.mutationForDialog(response.cancelAppRequest);
     }
-    async updateConfiguration(periodId, definitionKey, data, validateOnly) {
+    async reopenAppRequest(appRequestId) {
         const response = await this.client.mutation({
-            __name: 'UpdateConfiguration',
-            updateConfiguration: {
-                __args: { periodId, key: definitionKey, data, validateOnly },
+            __name: 'ReopenAppRequest',
+            reopenAppRequest: {
+                __args: { appRequestId },
                 success: true,
                 messages: {
                     message: true,
@@ -180,26 +476,42 @@ class API extends APIBase {
                 }
             }
         });
-        return this.mutationForDialog(response.updateConfiguration);
+        return this.mutationForDialog(response.reopenAppRequest);
     }
-    async getAppRequestData(appRequestId) {
-        const response = await this.client.query({
-            __name: 'GetAppRequestData',
-            appRequests: {
-                __args: { filter: { ids: [appRequestId] } },
-                id: true,
-                data: true
+    async advanceWorkflow(applicationId) {
+        const response = await this.client.mutation({
+            __name: 'AdvanceWorkflow',
+            advanceWorkflow: {
+                __args: { applicationId },
+                success: true,
+                messages: {
+                    message: true,
+                    type: true,
+                    arg: true
+                }
             }
         });
-        if (response.appRequests.length === 0)
-            return {};
-        const appRequest = response.appRequests[0];
-        return appRequest.data;
+        return this.mutationForDialog(response.advanceWorkflow);
     }
-    async submitAppRequest(appRequestId) {
+    async reverseWorkflow(applicationId) {
         const response = await this.client.mutation({
-            __name: 'SubmitAppRequest',
-            submitAppRequest: {
+            __name: 'ReverseWorkflow',
+            reverseWorkflow: {
+                __args: { applicationId },
+                success: true,
+                messages: {
+                    message: true,
+                    type: true,
+                    arg: true
+                }
+            }
+        });
+        return this.mutationForDialog(response.reverseWorkflow);
+    }
+    async closeAppRequest(appRequestId) {
+        const response = await this.client.mutation({
+            __name: 'CloseAppRequest',
+            closeAppRequest: {
                 __args: { appRequestId },
                 success: true,
                 messages: {
@@ -209,14 +521,24 @@ class API extends APIBase {
                 }
             }
         });
-        return this.mutationForDialog(response.submitAppRequest);
+        return this.mutationForDialog(response.closeAppRequest);
     }
-    async getAppRequests(filter, dest = enumAppRequestIndexDestination.APP_REQUEST_LIST) {
+    async getAppRequests(filter, paged, dest = enumAppRequestIndexDestination.APP_REQUEST_LIST) {
+        const processedFilter = {
+            ...filter,
+            indexes: filter?.indexes ? Object.entries(filter.indexes).map(([category, tags]) => ({ category, tags })) : undefined
+        };
         const response = await this.client.query({
             __name: 'GetAppRequests',
             appRequests: {
-                __args: { filter },
+                __args: { filter: processedFilter, paged },
                 id: true,
+                createdAt: true,
+                closedAt: true,
+                updatedAt: true,
+                applications: {
+                    title: true
+                },
                 applicant: {
                     login: true,
                     fullname: true
@@ -237,13 +559,7 @@ class API extends APIBase {
                     }
                 },
                 actions: {
-                    cancel: true,
-                    close: true,
-                    reopen: true,
-                    return: true,
-                    review: true,
-                    offer: true,
-                    submit: true
+                    review: true
                 }
             },
             appRequestIndexes: {
@@ -257,6 +573,24 @@ class API extends APIBase {
                     value: true,
                     label: true
                 }
+            },
+            pageInfo: {
+                appRequests: {
+                    currentPage: true,
+                    totalItems: true,
+                    hasNextPage: true,
+                    perPage: true,
+                    categories: {
+                        tags: {
+                            tag: true,
+                            label: true
+                        },
+                        category: true,
+                        label: true,
+                        useInFilters: true,
+                        useInList: true
+                    }
+                }
             }
         });
         return response;
@@ -280,6 +614,9 @@ class API extends APIBase {
             __name: 'GetBasicRequestData',
             appRequests: {
                 __args: { filter: { ids: [appRequestId] } },
+                complete: true,
+                status: true,
+                closedAt: true,
                 applicant: {
                     login: true,
                     fullname: true,
@@ -291,7 +628,30 @@ class API extends APIBase {
                 },
                 period: {
                     id: true,
-                    name: true
+                    name: true,
+                    code: true,
+                    openDate: true,
+                    closeDate: true,
+                    archiveDate: true
+                },
+                applications: {
+                    id: true,
+                    navTitle: true,
+                    programKey: true
+                },
+                actions: {
+                    acceptOffer: true,
+                    cancel: true,
+                    close: true,
+                    completeRequest: true,
+                    completeReview: true,
+                    reopen: true,
+                    returnToApplicant: true,
+                    returnToNonBlocking: true,
+                    returnToOffer: true,
+                    returnToReview: true,
+                    review: true,
+                    submit: true
                 }
             }
         });
@@ -299,7 +659,7 @@ class API extends APIBase {
             return undefined;
         return response.appRequests[0];
     }
-    async getReviewData(appRequestId) {
+    async getReviewData(appRequestId, visibilities = [enumPromptVisibility.AVAILABLE, enumPromptVisibility.REQUEST_DUPE]) {
         const response = await this.client.query({
             __name: 'GetReviewData',
             appRequests: {
@@ -309,17 +669,39 @@ class API extends APIBase {
                 data: true,
                 applications: {
                     id: true,
+                    phase: true,
                     status: true,
                     statusReason: true,
                     title: true,
                     navTitle: true,
+                    programKey: true,
+                    workflowStage: {
+                        key: true,
+                        blocking: true
+                    },
+                    nextWorkflowStage: {
+                        key: true,
+                        title: true
+                    },
+                    previousWorkflowStage: {
+                        key: true,
+                        title: true
+                    },
+                    actions: {
+                        advanceWorkflow: true,
+                        reverseWorkflow: true
+                    },
                     requirements: {
                         id: true,
                         type: true,
                         title: true,
                         status: true,
                         statusReason: true,
-                        reachable: true,
+                        workflowStage: {
+                            key: true,
+                            title: true,
+                            blocking: true
+                        },
                         prompts: {
                             id: true,
                             key: true,
@@ -327,26 +709,47 @@ class API extends APIBase {
                             navTitle: true,
                             answered: true,
                             visibility: true,
+                            configurationData: true,
+                            gatheredConfigData: true,
+                            moot: true,
+                            invalidated: true,
+                            invalidatedReason: true,
+                            preloadData: true,
+                            fetchedData: true,
                             actions: {
                                 update: true
                             }
                         }
                     }
+                },
+                actions: {
+                    acceptOffer: true,
+                    cancel: true,
+                    close: true,
+                    completeRequest: true,
+                    completeReview: true,
+                    reopen: true,
+                    returnToApplicant: true,
+                    returnToNonBlocking: true,
+                    returnToOffer: true,
+                    returnToReview: true,
+                    review: true,
+                    submit: true
                 }
             }
         });
         if (response.appRequests.length === 0)
             return undefined;
         const appRequest = response.appRequests[0];
-        return { ...appRequest, applications: appRequest.applications.map(a => ({ ...a, requirements: a.requirements.filter(r => r.reachable).map(r => ({ ...r, prompts: r.prompts.filter(p => p.visibility !== enumPromptVisibility.UNREACHABLE) })) })) };
+        return { ...appRequest, applications: appRequest.applications.map(a => ({ ...a, requirements: a.requirements.map(r => ({ ...r, prompts: r.prompts.filter(p => visibilities.includes(p.visibility)) })) })) };
     }
-    async getRequestActivity(appRequestId, filters) {
+    async getRequestActivity(appRequestId, filters, paged) {
         const response = await this.client.query({
             __name: 'GetRequestActivity',
             appRequests: {
                 __args: { filter: { ids: [appRequestId] } },
                 activity: {
-                    __args: { filters },
+                    __args: { filters, paged },
                     id: true,
                     user: {
                         login: true,
@@ -361,14 +764,25 @@ class API extends APIBase {
                     data: true,
                     createdAt: true
                 }
+            },
+            pageInfo: {
+                appRequestsActivity: {
+                    currentPage: true,
+                    totalItems: true,
+                    hasNextPage: true,
+                    perPage: true
+                }
             }
         });
         if (response.appRequests.length === 0)
             return undefined;
-        return response.appRequests[0].activity.map(activity => ({
-            ...activity,
-            createdAt: DateTime.fromISO(activity.createdAt)
-        }));
+        return {
+            activity: response.appRequests[0].activity.map(activity => ({
+                ...activity,
+                createdAt: DateTime.fromISO(activity.createdAt)
+            })),
+            pageInfo: response.pageInfo.appRequestsActivity
+        };
     }
     async getPromptData(appRequestId, promptId) {
         const response = await this.client.query({
@@ -379,7 +793,8 @@ class API extends APIBase {
                     __args: { promptId },
                     data: true,
                     preloadData: true,
-                    configurationRelatedData: true,
+                    configurationData: true,
+                    gatheredConfigData: true,
                     fetchedData: true
                 }
             }
@@ -393,13 +808,101 @@ class API extends APIBase {
             periods: {
                 id: true,
                 name: true,
+                code: true,
                 openDate: true,
                 closeDate: true,
-                archiveDate: true
+                archiveDate: true,
+                reviewed: true,
+                actions: {
+                    update: true,
+                    delete: true,
+                    createAppRequest: true
+                }
             }
         });
         return response.periods;
     }
+    async getOpenPeriods() {
+        const response = await this.client.query({
+            __name: 'GetOpenPeriods',
+            periods: {
+                __args: { filter: { openNow: true } },
+                id: true,
+                name: true,
+                code: true,
+                openDate: true,
+                closeDate: true,
+                archiveDate: true,
+                reviewed: true
+            }
+        });
+        return response.periods;
+    }
+    async createPeriod(period, validateOnly, copyPeriodId) {
+        const response = await this.client.mutation({
+            __name: 'CreatePeriod',
+            createPeriod: {
+                __args: { period, validateOnly, copyPeriodId },
+                success: true,
+                messages: {
+                    message: true,
+                    type: true,
+                    arg: true
+                }
+            }
+        });
+        return api.mutationForDialog(response.createPeriod, { prefix: 'period' });
+    }
+    async updatePeriod(periodId, period, validateOnly) {
+        const response = await this.client.mutation({
+            __name: 'UpdatePeriod',
+            updatePeriod: {
+                __args: { periodId, update: period, validateOnly },
+                success: true,
+                messages: {
+                    message: true,
+                    type: true,
+                    arg: true
+                }
+            }
+        });
+        return this.mutationForDialog(response.updatePeriod, { prefix: 'period' });
+    }
+    async markPeriodReviewed(periodId, validateOnly) {
+        const response = await this.client.mutation({
+            __name: 'MarkPeriodReviewed',
+            markPeriodReviewed: {
+                __args: { periodId, validateOnly },
+                success: true,
+                messages: {
+                    message: true,
+                    type: true,
+                    arg: true
+                }
+            }
+        });
+        return this.mutationForDialog(response.markPeriodReviewed, { prefix: 'period' });
+    }
+    async deletePeriod(periodId) {
+        const response = await this.client.mutation({
+            __name: 'DeletePeriod',
+            deletePeriod: {
+                __args: { periodId },
+                success: true
+            }
+        });
+        return response.deletePeriod.success;
+    }
+    async disablePeriodProgramRequirements(periodId, requirementKey, disabled) {
+        const response = await this.client.mutation({
+            __name: 'updatePeriodProgram',
+            updatePeriodRequirement: {
+                __args: { periodId, requirementKey, disabled },
+                success: true
+            }
+        });
+        return response.updatePeriodRequirement.success;
+    }
     async getPeriodConfigurations(periodId) {
         const response = await this.client.query({
             __name: 'GetPeriodConfigurations',
@@ -411,6 +914,7 @@ class API extends APIBase {
                 openDate: true,
                 closeDate: true,
                 archiveDate: true,
+                reviewed: true,
                 programs: {
                     key: true,
                     title: true,
@@ -420,6 +924,7 @@ class API extends APIBase {
                         title: true,
                         description: true,
                         enabled: true,
+                        type: true,
                         configuration: {
                             data: true,
                             actions: {
@@ -446,6 +951,19 @@ class API extends APIBase {
         const period = response.periods[0];
         return { programs: period.programs, period };
     }
+    async getConfigurationFetched(periodId, definitionKey) {
+        const response = await this.client.query({
+            __name: 'GetConfigurationFetched',
+            periods: {
+                __args: { filter: { ids: [periodId] } },
+                configurations: {
+                    __args: { filter: { keys: [definitionKey] } },
+                    fetchedData: true
+                }
+            }
+        });
+        return response.periods[0].configurations[0]?.fetchedData ?? {};
+    }
     async getRoleList() {
         const response = await this.client.query({
             __name: 'GetRoleList',
@@ -453,14 +971,29 @@ class API extends APIBase {
                 id: true,
                 name: true,
                 description: true,
-                groups: true,
+                groups: {
+                    groupName: true,
+                    managers: {
+                        fullname: true,
+                        email: true
+                    },
+                    dateAdded: true,
+                    dateCreated: true
+                },
                 actions: {
                     update: true,
                     delete: true
                 }
             }
         });
-        return response.roles;
+        if (response.roles.length === 0)
+            return undefined;
+        const roles = response.roles;
+        return roles.map(role => ({ ...role, groups: role.groups.map((group) => ({
+                ...group,
+                dateAdded: DateTime.fromISO(group.dateAdded),
+                dateCreated: group.dateCreated ? DateTime.fromISO(group.dateCreated) : undefined
+            })) }));
     }
     async getRoleDetails(roleId) {
         const response = await this.client.query({
@@ -470,10 +1003,18 @@ class API extends APIBase {
                 id: true,
                 name: true,
                 description: true,
-                groups: true,
+                groups: {
+                    groupName: true,
+                    managers: {
+                        fullname: true,
+                        email: true
+                    },
+                    dateAdded: true,
+                    dateCreated: true
+                },
                 grants: {
                     id: true,
-                    subjectType: {
+                    controlGroup: {
                         name: true,
                         title: true,
                         description: true
@@ -500,12 +1041,16 @@ class API extends APIBase {
         if (!response.roles.length)
             return undefined;
         const role = response.roles[0];
-        return role;
+        return { ...role, groups: role.groups.map((group) => ({
+                ...group,
+                dateAdded: DateTime.fromISO(group.dateAdded),
+                dateCreated: group.dateCreated ? DateTime.fromISO(group.dateCreated) : undefined
+            })) };
     }
     async getAuthorizationInfo() {
         const response = await this.client.query({
             __name: 'GetAuthorizationInfo',
-            subjectTypes: {
+            controlGroups: {
                 name: true,
                 title: true,
                 description: true,
@@ -525,9 +1070,9 @@ class API extends APIBase {
                 }
             }
         });
-        return response.subjectTypes;
+        return response.controlGroups;
     }
-    async upsertRole(roleId, role, validateOnly) {
+    async upsertRole(roleId, role, validateOnly, copyRoleId) {
         if (roleId != null) {
             const response = await this.client.mutation({
                 __name: 'UpdateRole',
@@ -547,7 +1092,7 @@ class API extends APIBase {
             const response = await this.client.mutation({
                 __name: 'CreateRole',
                 roleCreate: {
-                    __args: { role, validateOnly },
+                    __args: { role, copyRoleId, validateOnly },
                     success: true,
                     messages: {
                         message: true,