@reqquest/ui 1.0.0

package/dist/api.js

@@ -0,0 +1,618 @@
+import { PUBLIC_API_BASE, PUBLIC_AUTH_REDIRECT } from '$env/static/public';
+import { APIBase } from '@txstate-mws/sveltekit-utils';
+import { createClient, enumAppRequestIndexDestination, enumPromptVisibility, enumRequirementType } from './typed-client/index.js';
+import { DateTime } from 'luxon';
+class API extends APIBase {
+    client = createClient({
+        url: PUBLIC_API_BASE,
+        fetcher: async (operation) => {
+            if (Array.isArray(operation))
+                throw new Error('Batching not supported');
+            const data = await this.graphql(operation.query, operation.variables);
+            return { data };
+        }
+    });
+    async getAccess() {
+        const response = await this.client.query({
+            __name: 'GetAccess',
+            access: {
+                createPeriod: true,
+                createRole: true,
+                viewRoleManagement: true,
+                viewPeriodManagement: true,
+                viewReviewerInterface: true,
+                viewApplicantDashboard: true,
+                viewAppRequestList: true
+            }
+        });
+        return response.access;
+    }
+    async getApplicantRequests() {
+        const response = await this.client.query({
+            __name: 'GetApplicantRequests',
+            appRequests: {
+                __args: { filter: { own: true } },
+                id: true,
+                status: true,
+                period: {
+                    name: true,
+                    openDate: true,
+                    closeDate: true
+                }
+            }
+        });
+        return response.appRequests;
+    }
+    async getNextPrompt(appRequestId, currentPromptKey) {
+        const response = await this.client.query({
+            __name: 'GetNextPrompt',
+            appRequests: {
+                __args: { filter: { ids: [appRequestId] } },
+                applications: {
+                    requirements: {
+                        prompts: {
+                            id: true,
+                            key: true,
+                            answered: true,
+                            visibility: true
+                        }
+                    }
+                }
+            }
+        });
+        let currentKeyFound = false;
+        for (const applications of response.appRequests[0]?.applications ?? []) {
+            for (const requirement of applications.requirements) {
+                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;
+                }
+            }
+        }
+    }
+    async getApplyNavigation(appRequestId) {
+        const response = await this.client.query({
+            __name: 'GetApplyNavigation',
+            appRequests: {
+                __args: { filter: { ids: [appRequestId] } },
+                id: true,
+                status: 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
+                        }
+                    }
+                }
+            }
+        });
+        if (response.appRequests.length === 0)
+            return { prequalPrompts: [], appRequest: undefined };
+        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) {
+        const response = await this.client.query({
+            __name: 'GetPromptData',
+            appRequests: {
+                __args: { filter: { ids: [appRequestId] } },
+                data: true,
+                applications: {
+                    id: true,
+                    requirements: {
+                        type: true,
+                        status: true,
+                        statusReason: true,
+                        prompts: {
+                            id: true,
+                            key: true,
+                            visibility: true,
+                            fetchedData: true,
+                            configurationRelatedData: 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 };
+                }
+            }
+        }
+        return { appRequestData: appRequest.data };
+    }
+    async updatePrompt(promptId, data, validateOnly) {
+        const response = await this.client.mutation({
+            __name: 'UpdatePrompt',
+            updatePrompt: {
+                __args: { promptId, data, validateOnly },
+                success: true,
+                messages: {
+                    message: true,
+                    type: true,
+                    arg: true
+                }
+            }
+        });
+        return this.mutationForDialog(response.updatePrompt);
+    }
+    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: 'GetAppRequestData',
+            appRequests: {
+                __args: { filter: { ids: [appRequestId] } },
+                id: true,
+                data: true
+            }
+        });
+        if (response.appRequests.length === 0)
+            return {};
+        const appRequest = response.appRequests[0];
+        return appRequest.data;
+    }
+    async submitAppRequest(appRequestId) {
+        const response = await this.client.mutation({
+            __name: 'SubmitAppRequest',
+            submitAppRequest: {
+                __args: { appRequestId },
+                success: true,
+                messages: {
+                    message: true,
+                    type: true,
+                    arg: true
+                }
+            }
+        });
+        return this.mutationForDialog(response.submitAppRequest);
+    }
+    async getAppRequests(filter, dest = enumAppRequestIndexDestination.APP_REQUEST_LIST) {
+        const response = await this.client.query({
+            __name: 'GetAppRequests',
+            appRequests: {
+                __args: { filter },
+                id: true,
+                applicant: {
+                    login: true,
+                    fullname: true
+                },
+                status: true,
+                statusReason: true,
+                period: {
+                    id: true,
+                    name: true
+                },
+                indexCategories: {
+                    __args: { for: dest },
+                    category: true,
+                    categoryLabel: true,
+                    values: {
+                        value: true,
+                        label: true
+                    }
+                },
+                actions: {
+                    cancel: true,
+                    close: true,
+                    reopen: true,
+                    return: true,
+                    review: true,
+                    offer: true,
+                    submit: true
+                }
+            },
+            appRequestIndexes: {
+                category: true,
+                categoryLabel: true,
+                appRequestListPriority: true,
+                listFiltersPriority: true,
+                listable: true,
+                values: {
+                    __args: { inUse: true },
+                    value: true,
+                    label: true
+                }
+            }
+        });
+        return response;
+    }
+    async searchIndexItems(category, search) {
+        const response = await this.client.query({
+            __name: 'SearchIndexItems',
+            appRequestIndexes: {
+                __args: { categories: [category] },
+                values: {
+                    __args: { search },
+                    value: true,
+                    label: true
+                }
+            }
+        });
+        return response.appRequestIndexes[0]?.values ?? [];
+    }
+    async getBasicRequestData(appRequestId) {
+        const response = await this.client.query({
+            __name: 'GetBasicRequestData',
+            appRequests: {
+                __args: { filter: { ids: [appRequestId] } },
+                applicant: {
+                    login: true,
+                    fullname: true,
+                    otherIdentifiers: {
+                        id: true,
+                        label: true
+                    },
+                    otherInfo: true
+                },
+                period: {
+                    id: true,
+                    name: true
+                }
+            }
+        });
+        if (response.appRequests.length === 0)
+            return undefined;
+        return response.appRequests[0];
+    }
+    async getReviewData(appRequestId) {
+        const response = await this.client.query({
+            __name: 'GetReviewData',
+            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,
+                        title: true,
+                        status: true,
+                        statusReason: true,
+                        reachable: true,
+                        prompts: {
+                            id: true,
+                            key: true,
+                            title: true,
+                            navTitle: true,
+                            answered: true,
+                            visibility: true,
+                            actions: {
+                                update: 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) })) })) };
+    }
+    async getRequestActivity(appRequestId, filters) {
+        const response = await this.client.query({
+            __name: 'GetRequestActivity',
+            appRequests: {
+                __args: { filter: { ids: [appRequestId] } },
+                activity: {
+                    __args: { filters },
+                    id: true,
+                    user: {
+                        login: true,
+                        fullname: true
+                    },
+                    impersonatedBy: {
+                        login: true,
+                        fullname: true
+                    },
+                    action: true,
+                    description: true,
+                    data: true,
+                    createdAt: true
+                }
+            }
+        });
+        if (response.appRequests.length === 0)
+            return undefined;
+        return response.appRequests[0].activity.map(activity => ({
+            ...activity,
+            createdAt: DateTime.fromISO(activity.createdAt)
+        }));
+    }
+    async getPromptData(appRequestId, promptId) {
+        const response = await this.client.query({
+            __name: 'GetPromptData',
+            appRequests: {
+                __args: { filter: { ids: [appRequestId] } },
+                prompt: {
+                    __args: { promptId },
+                    data: true,
+                    preloadData: true,
+                    configurationRelatedData: true,
+                    fetchedData: true
+                }
+            }
+        });
+        const appRequest = response.appRequests[0];
+        return appRequest.prompt;
+    }
+    async getPeriodList() {
+        const response = await this.client.query({
+            __name: 'GetPeriodList',
+            periods: {
+                id: true,
+                name: true,
+                openDate: true,
+                closeDate: true,
+                archiveDate: true
+            }
+        });
+        return response.periods;
+    }
+    async getPeriodConfigurations(periodId) {
+        const response = await this.client.query({
+            __name: 'GetPeriodConfigurations',
+            periods: {
+                __args: { filter: { ids: [periodId] } },
+                id: true,
+                name: true,
+                code: true,
+                openDate: true,
+                closeDate: true,
+                archiveDate: true,
+                programs: {
+                    key: true,
+                    title: true,
+                    enabled: true,
+                    requirements: {
+                        key: true,
+                        title: true,
+                        description: true,
+                        enabled: true,
+                        configuration: {
+                            data: true,
+                            actions: {
+                                update: true
+                            }
+                        },
+                        prompts: {
+                            key: true,
+                            title: true,
+                            description: true,
+                            configuration: {
+                                data: true,
+                                actions: {
+                                    update: true
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        if (!response.periods.length)
+            return { period: undefined, programs: [] };
+        const period = response.periods[0];
+        return { programs: period.programs, period };
+    }
+    async getRoleList() {
+        const response = await this.client.query({
+            __name: 'GetRoleList',
+            roles: {
+                id: true,
+                name: true,
+                description: true,
+                groups: true,
+                actions: {
+                    update: true,
+                    delete: true
+                }
+            }
+        });
+        return response.roles;
+    }
+    async getRoleDetails(roleId) {
+        const response = await this.client.query({
+            __name: 'GetRoleDetails',
+            roles: {
+                __args: { filter: { ids: [roleId] } },
+                id: true,
+                name: true,
+                description: true,
+                groups: true,
+                grants: {
+                    id: true,
+                    subjectType: {
+                        name: true,
+                        title: true,
+                        description: true
+                    },
+                    allow: true,
+                    controls: true,
+                    tags: {
+                        category: true,
+                        categoryLabel: true,
+                        tag: true,
+                        label: true
+                    },
+                    actions: {
+                        update: true,
+                        delete: true
+                    }
+                },
+                actions: {
+                    update: true,
+                    delete: true
+                }
+            }
+        });
+        if (!response.roles.length)
+            return undefined;
+        const role = response.roles[0];
+        return role;
+    }
+    async getAuthorizationInfo() {
+        const response = await this.client.query({
+            __name: 'GetAuthorizationInfo',
+            subjectTypes: {
+                name: true,
+                title: true,
+                description: true,
+                tags: {
+                    category: true,
+                    label: true,
+                    description: true,
+                    listable: true,
+                    tags: {
+                        value: true,
+                        label: true
+                    }
+                },
+                controls: {
+                    name: true,
+                    description: true
+                }
+            }
+        });
+        return response.subjectTypes;
+    }
+    async upsertRole(roleId, role, validateOnly) {
+        if (roleId != null) {
+            const response = await this.client.mutation({
+                __name: 'UpdateRole',
+                roleUpdate: {
+                    __args: { roleId, role, validateOnly },
+                    success: true,
+                    messages: {
+                        message: true,
+                        type: true,
+                        arg: true
+                    }
+                }
+            });
+            return this.mutationForDialog(response.roleUpdate);
+        }
+        else {
+            const response = await this.client.mutation({
+                __name: 'CreateRole',
+                roleCreate: {
+                    __args: { role, validateOnly },
+                    success: true,
+                    messages: {
+                        message: true,
+                        type: true,
+                        arg: true
+                    }
+                }
+            });
+            return this.mutationForDialog(response.roleCreate);
+        }
+    }
+    async deleteRole(roleId) {
+        const response = await this.client.mutation({
+            __name: 'DeleteRole',
+            roleDelete: {
+                __args: { roleId },
+                success: true
+            }
+        });
+        return response.roleDelete.success;
+    }
+    async updateGrant(grantId, grant, validateOnly) {
+        const response = await this.client.mutation({
+            __name: 'UpdateGrant',
+            roleUpdateGrant: {
+                __args: { grantId, grant, validateOnly },
+                success: true,
+                messages: {
+                    message: true,
+                    type: true,
+                    arg: true
+                }
+            }
+        });
+        return this.mutationForDialog(response.roleUpdateGrant);
+    }
+    async createGrant(roleId, grant, validateOnly) {
+        const response = await this.client.mutation({
+            __name: 'CreateGrant',
+            roleAddGrant: {
+                __args: { roleId, grant, validateOnly },
+                success: true,
+                messages: {
+                    message: true,
+                    type: true,
+                    arg: true
+                }
+            }
+        });
+        return this.mutationForDialog(response.roleAddGrant);
+    }
+    async deleteGrant(grantId) {
+        const response = await this.client.mutation({
+            __name: 'DeleteGrant',
+            roleDeleteGrant: {
+                __args: { grantId },
+                success: true,
+                messages: {
+                    message: true,
+                    type: true,
+                    arg: true
+                }
+            }
+        });
+        return this.mutationForDialog(response.roleDeleteGrant);
+    }
+}
+export const api = new API(PUBLIC_API_BASE, PUBLIC_AUTH_REDIRECT);

package/dist/components/ButtonLoadingIcon.svelte

@@ -0,0 +1,27 @@
+<script>import { ScreenReaderOnly } from "@txstate-mws/svelte-components";
+</script>
+
+<svg style:display="none"></svg>
+<span {...$$restProps} class="{$$restProps.class} loader" aria-hidden="false"><ScreenReaderOnly>loading</ScreenReaderOnly></span>
+
+<style>
+  .loader {
+    width: 16px;
+    height: 16px;
+    border: 3px solid #FFF;
+    border-bottom-color: transparent;
+    border-radius: 50%;
+    display: inline-block;
+    box-sizing: border-box;
+    animation: rotation 1s linear infinite;
+  }
+
+  @keyframes rotation {
+    0% {
+      transform: rotate(0deg);
+    }
+    100% {
+      transform: rotate(360deg);
+    }
+  }
+</style>

package/dist/components/ButtonLoadingIcon.svelte.d.ts

@@ -0,0 +1,18 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        [x: string]: any;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+    exports?: undefined;
+    bindings?: undefined;
+};
+export type ButtonLoadingIconProps = typeof __propDef.props;
+export type ButtonLoadingIconEvents = typeof __propDef.events;
+export type ButtonLoadingIconSlots = typeof __propDef.slots;
+export default class ButtonLoadingIcon extends SvelteComponent<ButtonLoadingIconProps, ButtonLoadingIconEvents, ButtonLoadingIconSlots> {
+}
+export {};

package/dist/components/index.d.ts

@@ -0,0 +1 @@
+export { default as ButtonLoadingIcon } from './ButtonLoadingIcon.svelte';

package/dist/components/index.js

@@ -0,0 +1 @@
+export { default as ButtonLoadingIcon } from './ButtonLoadingIcon.svelte';

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './api.js';
+export * from './components/index.js';
+export * from './typed-client/index.js';
+export * from './util.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './api.js';
+export * from './components/index.js';
+export * from './typed-client/index.js';
+export * from './util.js';