@quesmed/types-rn 2.6.267 → 2.6.269

package/models/OsceMarksheet.d.ts

@@ -26,6 +26,8 @@ export interface IOsceMarksheetMark {
     osceMarksheet?: IOsceMarksheet;
     osceStationMarkId: Id;
     osceStationMark?: IOsceStationMark;
+    secondaryMark: number | null;
+    score: number | null;
 }
 export declare enum EOsceRoles {
     ALL = 0,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quesmed/types-rn",
-  "version": "2.6.267",
+  "version": "2.6.269",
   "description": "Typescript types for Quesmed",
   "keywords": [
     "quesmed",

package/resolvers/fragments/osce.js

@@ -100,6 +100,8 @@ exports.OSCE_MARKSHEET_MARK_FIELDS = (0, client_1.gql) `
     id
     index
     mark
+    score
+    secondaryMark
     selectedChoice
     osceMarksheetId
     osceStationMarkId

package/resolvers/mutation/restricted/asset.d.ts

@@ -0,0 +1,20 @@
+import { FileData, IPicture, Id } from '../../../models';
+import { AdminData, graphqlNormalize } from '../../types';
+export interface IAssetInput {
+    file: File | FileData;
+    caption?: string | null;
+    name: string;
+    topicId?: Id;
+    sensitive: boolean;
+    overlay?: boolean;
+}
+export declare const CREATE_ASSETS: import("@apollo/client").DocumentNode;
+export type ICreateAssetsVar = {
+    inputs: IAssetInput[];
+};
+export type ICreateAssetsData = AdminData<(IPicture & graphqlNormalize)[], 'createAssets'>;
+export declare const REMOVE_ASSETS: import("@apollo/client").DocumentNode;
+export type IRemoveAssetsVar = {
+    ids: Id[];
+};
+export type IRemoveAssetsData = AdminData<boolean, 'removeAssets'>;

package/resolvers/mutation/restricted/asset.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REMOVE_ASSETS = exports.CREATE_ASSETS = void 0;
+const client_1 = require("@apollo/client");
+const fragments_1 = require("../../fragments");
+exports.CREATE_ASSETS = (0, client_1.gql) `
+  ${fragments_1.PICTURE_FIELDS}
+  mutation CreateAssets($inputs: [CreateAssetsInput!]!) {
+    restricted {
+      createAssets(inputs: $inputs) {
+        ...PictureFields
+      }
+    }
+  }
+`;
+exports.REMOVE_ASSETS = (0, client_1.gql) `
+  mutation RemoveAssets($ids: [ID!]!) {
+    restricted {
+      removeAssets(ids: $ids)
+    }
+  }
+`;

package/resolvers/mutation/restricted/index.d.ts

@@ -1,4 +1,5 @@
 export * from './agora';
+export * from './asset';
 export * from './circuit';
 export * from './book';
 export * from './chapter';
@@ -9,6 +10,7 @@ export * from './notification';
 export * from './osce';
 export * from './preset';
 export * from './questionDiscussion';
+export * from './station';
 export * from './stripe';
 export * from './todo';
 export * from './token';

package/resolvers/mutation/restricted/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./agora"), exports);
+__exportStar(require("./asset"), exports);
 __exportStar(require("./circuit"), exports);
 __exportStar(require("./book"), exports);
 __exportStar(require("./chapter"), exports);
@@ -25,6 +26,7 @@ __exportStar(require("./notification"), exports);
 __exportStar(require("./osce"), exports);
 __exportStar(require("./preset"), exports);
 __exportStar(require("./questionDiscussion"), exports);
+__exportStar(require("./station"), exports);
 __exportStar(require("./stripe"), exports);
 __exportStar(require("./todo"), exports);
 __exportStar(require("./token"), exports);

package/resolvers/mutation/restricted/osce.d.ts

@@ -45,6 +45,7 @@ export declare const MARK_OSCE_MARKSHEET_MARK: import("@apollo/client").Document
 export interface IMarkOsceMarksheetMarkVar {
     osceMarksheetMarkId: Id;
     mark: number | EPaceMarkType;
+    secondaryMark?: number;
     corrected?: Boolean;
 }
 export type IMarkOsceMarksheetMarkData = RestrictedData<graphqlNormalize & Partial<IOsceMarksheetMark>, 'markOsceMarksheetMark'>;

package/resolvers/mutation/restricted/osce.js

@@ -84,16 +84,19 @@ exports.CHANGE_OSCE_ROLE = (0, client_1.gql) `
   }
 `;
 exports.MARK_OSCE_MARKSHEET_MARK = (0, client_1.gql) `
-  mutation MarkOsceMarksheetMark($osceMarksheetMarkId: Int!, $mark: Int!, $corrected: Boolean) {
+  mutation MarkOsceMarksheetMark($osceMarksheetMarkId: Int!, $mark: Int!, $secondaryMark: Int, $corrected: Boolean) {
     restricted {
       markOsceMarksheetMark(
         osceMarksheetMarkId: $osceMarksheetMarkId
         mark: $mark
+        secondaryMark: $secondaryMark
         corrected: $corrected
       ) {
         id
         selectedChoice
         mark
+        score
+        secondaryMark
       }
     }
   }
@@ -103,10 +106,13 @@ const optimisticMarkOsceMarksheetMark = (variables, productType) => {
     if (productType === models_1.EProductType.PACES) {
         data.selectedChoice = variables.mark;
         data.mark = null;
+        data.secondaryMark = variables.secondaryMark;
+        data.score = null;
     }
     else {
         data.mark = variables.mark;
         data.selectedChoice = null;
+        data.score = variables.mark;
     }
     return {
         restricted: {
@@ -133,6 +139,8 @@ const updateCacheOnMarkOsceMarksheetMark = (cache, result, options) => {
         fields: {
             selectedChoice: () => markOsceMarksheetMark.selectedChoice,
             mark: () => markOsceMarksheetMark.mark,
+            secondaryMark: () => markOsceMarksheetMark.secondaryMark,
+            score: () => markOsceMarksheetMark.score,
         },
     });
     if (!variables.corrected) {
@@ -159,6 +167,8 @@ const updateCacheOnMarkOsceMarksheetMark = (cache, result, options) => {
       fragment OsceMarksheetMarksForScore on OsceMarksheet {
         marks {
           mark
+          score
+          secondaryMark
         }
       }
     `,
@@ -166,12 +176,14 @@ const updateCacheOnMarkOsceMarksheetMark = (cache, result, options) => {
     if (!marksheet?.marks?.length) {
         return;
     }
-    const total = marksheet.marks.length;
-    const scored = marksheet.marks.filter(({ mark }) => Boolean(mark)).length;
+    const hasSecondaryMarks = marksheet.marks.some((m) => m.secondaryMark);
+    const total = hasSecondaryMarks ? 2 * marksheet.marks.length : marksheet.marks.length;
+    // const scored = marksheet.marks.filter(({ mark }) => Boolean(mark)).length;
+    const userScore = marksheet.marks.reduce((sum, m) => sum + Number(m.score), 0);
     cache.modify({
         id: cache.identify({ id: marksheetId, __typename: 'OsceMarksheet' }),
         fields: {
-            score: () => scored / total,
+            score: () => userScore / total,
         },
     });
 };

package/resolvers/mutation/restricted/station.d.ts

@@ -0,0 +1,81 @@
+import { ApolloCache } from '@apollo/client';
+import { ApolloUpdateOptions, ApolloUpdateResultRestricted } from '../..';
+import { IClinicalDataModule, Id, IOsceStation, IOsceStationPhaseTimer, IStationExaminerQuestion } from '../../../models';
+import { IAssetBinding } from '../../../models/Picture';
+import { graphqlNormalize, RestrictedData } from '../../types';
+import { EOsceType } from '../../../models';
+export interface IJobStationMarkInput {
+    header?: string;
+    name?: string;
+    index?: number;
+    excludeFromAi?: boolean;
+    weight?: number;
+}
+export declare const CREATE_STATION: import("@apollo/client").DocumentNode;
+export type ICreateStationData = RestrictedData<graphqlNormalize & IOsceStation, 'createStation'>;
+export interface ICreateStationVar {
+    input: {
+        name: string;
+        hiddenName?: string;
+        osceTypeId?: number;
+        enabled?: number;
+        visibility?: number;
+        entitlementIds?: number[];
+        difficulty?: number;
+        pictureId?: number;
+        candidateBrief?: string;
+        examinerBrief?: string;
+        actorBrief?: string;
+        llmActorBrief?: string;
+        explanation?: string;
+        aiEnabled?: boolean;
+        aiConfig?: Record<string, unknown>;
+        phaseTimers?: IOsceStationPhaseTimer;
+        clinicalData?: IClinicalDataModule[];
+        topicIds?: number[];
+        marks?: IJobStationMarkInput[];
+        examinerQuestions?: IStationExaminerQuestion[];
+        assets?: IAssetBinding[];
+    };
+}
+export declare const updateCacheOnCreateStation: (cache: ApolloCache<any>, result: ApolloUpdateResultRestricted<ICreateStationData>, options: ApolloUpdateOptions<ICreateStationVar>) => void;
+export declare const UPDATE_STATION: import("@apollo/client").DocumentNode;
+export type IUpdateStationData = RestrictedData<graphqlNormalize & IOsceStation, 'updateStation'>;
+export interface IUpdateStationVar {
+    input: {
+        id: Id;
+        name?: string;
+        enabled?: number;
+        visibility?: number;
+        osceTypeId?: number;
+        hiddenName?: string;
+        entitlementIds?: number[];
+        difficulty?: number;
+        pictureId?: number;
+        candidateBrief?: string;
+        examinerBrief?: string;
+        actorBrief?: string;
+        llmActorBrief?: string;
+        explanation?: string;
+        aiEnabled?: boolean;
+        aiConfig?: Record<string, unknown>;
+        phaseTimers?: IOsceStationPhaseTimer;
+        clinicalData?: IClinicalDataModule[];
+        topicIds?: number[];
+        marks?: IJobStationMarkInput[];
+        assets?: IAssetBinding[];
+        examinerQuestions?: IStationExaminerQuestion[];
+    };
+}
+export declare const updateCacheOnUpdateStation: (cache: ApolloCache<any>, result: ApolloUpdateResultRestricted<IUpdateStationData>, options: ApolloUpdateOptions<IUpdateStationVar>) => void;
+export interface IGenerateStationSession {
+    sessionId: string;
+}
+export type IGenerateStationData = RestrictedData<graphqlNormalize & IGenerateStationSession, 'generateStation'>;
+export interface IGenerateStationVar {
+    input: {
+        prompt: string;
+        osceTypeId: EOsceType;
+    };
+}
+export declare const GENERATE_STATION: import("@apollo/client").DocumentNode;

package/resolvers/mutation/restricted/station.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GENERATE_STATION = exports.updateCacheOnUpdateStation = exports.UPDATE_STATION = exports.updateCacheOnCreateStation = exports.CREATE_STATION = void 0;
+const client_1 = require("@apollo/client");
+const osce_1 = require("../../fragments/osce");
+const restricted_1 = require("../../query/restricted");
+exports.CREATE_STATION = (0, client_1.gql) `
+  ${osce_1.OSCE_STATION_FIELDS}
+  mutation CreateStation($input: CreateStationInput!) {
+    restricted {
+      createStation(input: $input) {
+        ...OsceStationFields
+      }
+    }
+  }
+`;
+const updateCacheOnCreateStation = (cache, result, options) => {
+    const { createStation } = result?.data?.restricted || {};
+    const { variables } = options || {};
+    if (!createStation || !variables) {
+        return;
+    }
+    const prevData = cache.readQuery({
+        variables: { solo: false },
+        query: restricted_1.OSCE_STATIONS,
+    });
+    if (prevData) {
+        const { osceStations } = prevData.restricted || {};
+        cache.writeQuery({
+            query: restricted_1.OSCE_STATIONS,
+            variables: { solo: false },
+            data: {
+                ...prevData,
+                restricted: {
+                    ...prevData.restricted,
+                    osceStations: [{ ...createStation }, ...osceStations],
+                },
+            },
+        });
+    }
+    else {
+        cache.writeQuery({
+            query: restricted_1.OSCE_STATIONS,
+            variables: { solo: false },
+            data: {
+                restricted: {
+                    __typename: 'RestrictedQuery',
+                    osceStations: [{ ...createStation }],
+                },
+            },
+        });
+    }
+};
+exports.updateCacheOnCreateStation = updateCacheOnCreateStation;
+exports.UPDATE_STATION = (0, client_1.gql) `
+  ${osce_1.OSCE_STATION_FIELDS}
+  mutation UpdateStation($input: UpdateStationInput!) {
+    restricted {
+      updateStation(input: $input) {
+        ...OsceStationFields
+      }
+    }
+  }
+`;
+const updateCacheOnUpdateStation = (cache, result, options) => {
+    const { updateStation } = result?.data?.restricted || {};
+    const { variables } = options || {};
+    if (!updateStation || !variables) {
+        return;
+    }
+    cache.writeFragment({
+        id: cache.identify({
+            id: variables.input.id,
+            __typename: 'OsceStation',
+        }),
+        data: { ...updateStation },
+        fragment: osce_1.OSCE_STATION_FIELDS,
+        fragmentName: 'OsceStationFields',
+    });
+};
+exports.updateCacheOnUpdateStation = updateCacheOnUpdateStation;
+exports.GENERATE_STATION = (0, client_1.gql) `
+  mutation GenerateStation($input: GenerateStationInput!) {
+    restricted {
+      generateStation(input: $input) {
+        sessionId
+      }
+    }
+  }
+`;

package/resolvers/query/restricted/index.d.ts

@@ -15,6 +15,7 @@ export * from './qBank';
 export * from './quesBook';
 export * from './question';
 export * from './replication';
+export * from './station';
 export * from './todos';
 export * from './topics';
 export * from './ukmlaTopics';

package/resolvers/query/restricted/index.js

@@ -31,6 +31,7 @@ __exportStar(require("./qBank"), exports);
 __exportStar(require("./quesBook"), exports);
 __exportStar(require("./question"), exports);
 __exportStar(require("./replication"), exports);
+__exportStar(require("./station"), exports);
 __exportStar(require("./todos"), exports);
 __exportStar(require("./topics"), exports);
 __exportStar(require("./ukmlaTopics"), exports);

package/resolvers/query/restricted/station.d.ts

@@ -0,0 +1,35 @@
+import { EOsceType, IStationExaminerQuestion } from '../../../models';
+import { graphqlNormalize, RestrictedData } from '../../types';
+export declare enum EGenerateStationStatus {
+    PENDING = "PENDING",
+    READY = "READY",
+    FAILED = "FAILED"
+}
+export interface IGeneratedStationMark {
+    header?: string;
+    name?: string;
+    index?: number;
+    weight?: number;
+    excludeFromAi?: boolean;
+}
+export interface IGeneratedStation {
+    name?: string;
+    osceTypeId?: EOsceType;
+    difficulty?: number;
+    candidateBrief?: string;
+    examinerBrief?: string;
+    actorBrief?: string;
+    explanation?: string;
+    examinerQuestions?: IStationExaminerQuestion[];
+    marks?: IGeneratedStationMark[];
+}
+export interface IGenerateStationResult {
+    status: EGenerateStationStatus;
+    station?: IGeneratedStation;
+    error?: string;
+}
+export type IGenerateStationStatusData = RestrictedData<graphqlNormalize & IGenerateStationResult, 'generateStationStatus'>;
+export interface IGenerateStationStatusVar {
+    sessionId: string;
+}
+export declare const GENERATE_STATION_STATUS: import("@apollo/client").DocumentNode;

package/resolvers/query/restricted/station.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GENERATE_STATION_STATUS = exports.EGenerateStationStatus = void 0;
+const client_1 = require("@apollo/client");
+var EGenerateStationStatus;
+(function (EGenerateStationStatus) {
+    EGenerateStationStatus["PENDING"] = "PENDING";
+    EGenerateStationStatus["READY"] = "READY";
+    EGenerateStationStatus["FAILED"] = "FAILED";
+})(EGenerateStationStatus = exports.EGenerateStationStatus || (exports.EGenerateStationStatus = {}));
+exports.GENERATE_STATION_STATUS = (0, client_1.gql) `
+  query GenerateStationStatus($sessionId: String!) {
+    restricted {
+      generateStationStatus(sessionId: $sessionId) {
+        status
+        error
+        station {
+          name
+          osceTypeId
+          difficulty
+          candidateBrief
+          examinerBrief
+          actorBrief
+          explanation
+          examinerQuestions {
+            index
+            question
+          }
+          marks {
+            header
+            name
+            index
+            weight
+            excludeFromAi
+          }
+        }
+      }
+    }
+  }
+`;