case-editor-tools 1.0.0-beta.9 → 1.0.2

package/constants/key-definitions.d.ts

@@ -10,4 +10,7 @@ export declare const sliderCategoricalKey = "scc";
 export declare const inputKey = "ic";
 export declare const numericInputKey = "num";
 export declare const datePickerKey = "date";
+export declare const timeInputKey = "time";
 export declare const matrixKey = "mat";
+export declare const clozeKey = "cloze";
+export declare const consentKey = "con";

package/constants/key-definitions.js

@@ -14,8 +14,13 @@ const sliderCategoricalKey = "scc";
 const inputKey = "ic";
 const numericInputKey = "num";
 const datePickerKey = "date";
-const matrixKey = "mat";
+const timeInputKey = "time";
+const matrixKey = "mat";
+const clozeKey = "cloze";
+const consentKey = "con";
 
+exports.clozeKey = clozeKey;
+exports.consentKey = consentKey;
 exports.datePickerKey = datePickerKey;
 exports.dropDownKey = dropDownKey;
 exports.inputKey = inputKey;
@@ -29,4 +34,5 @@ exports.responsiveBipolarLikertArrayKey = responsiveBipolarLikertArrayKey;
 exports.responsiveSingleChoiceArrayKey = responsiveSingleChoiceArrayKey;
 exports.singleChoiceKey = singleChoiceKey;
 exports.sliderCategoricalKey = sliderCategoricalKey;
+exports.timeInputKey = timeInputKey;
 //# sourceMappingURL=key-definitions.js.map

package/constants/key-definitions.js.map

@@ -1 +1 @@
-{"version":3,"file":"key-definitions.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"key-definitions.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/exporter/index.d.ts

@@ -0,0 +1,2 @@
+import { Study } from "../types/study";
+export declare const generateFilesForStudy: (study: Study, pretty?: boolean | undefined) => void;

package/exporter/index.js

@@ -0,0 +1,128 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fs = require('fs');
+var logger_logger = require('../logger/logger.js');
+var types_messageConfig = require('../types/messageConfig.js');
+require('../types/duration.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+
+const generateFilesForStudy = (study, pretty) => {
+    const outputName = study.outputFolderName ? study.outputFolderName : study.studyKey;
+    const outputRoot = `./output/${outputName}`;
+    logger_logger.Logger.log(`Start generating files for study ${outputName}.`);
+    if (!fs__default["default"].existsSync(outputRoot)) {
+        fs__default["default"].mkdirSync(outputRoot, { recursive: true });
+    }
+    // Surveys:
+    generateSurveyFiles(study, outputRoot, pretty);
+    // Study rules:
+    generateStudyRuleFile(study, outputRoot, pretty);
+    // Custom Study rules: (manually triggered rules)
+    generateCustomStudyRules(study, outputRoot, pretty);
+    // Message configs:
+    generateMessageConfigs(study, outputRoot, pretty);
+};
+const generateSurveyFiles = (study, outputPath, pretty) => {
+    if (study.surveys.length > 0) {
+        logger_logger.Logger.log(`\tSurveys:`);
+    }
+    else {
+        logger_logger.Logger.log(`\tNo surveys in the study.`);
+    }
+    const surveyOutPath = `${outputPath}/surveys`;
+    if (!fs__default["default"].existsSync(surveyOutPath)) {
+        fs__default["default"].mkdirSync(surveyOutPath, { recursive: true });
+    }
+    study.surveys.forEach(survey => {
+        const fileName = `${surveyOutPath}/${survey.key}.json`;
+        const outputObject = {
+            studyKey: study.studyKey,
+            survey: survey.getSurvey()
+        };
+        try {
+            fs__default["default"].writeFileSync(fileName, JSON.stringify(outputObject, undefined, pretty ? 2 : undefined));
+        }
+        catch (err) {
+            logger_logger.Logger.error(err);
+            return;
+        }
+        logger_logger.Logger.success(`\t\t${survey.key} saved`);
+    });
+};
+const generateStudyRuleFile = (study, outputPath, pretty) => {
+    if (!study.studyRules) {
+        logger_logger.Logger.log(`\tNo study rules in the study.`);
+        return;
+    }
+    else {
+        logger_logger.Logger.log(`\tStudy rule:`);
+    }
+    const fileName = `${outputPath}/studyRules.json`;
+    const outputObject = study.studyRules.get();
+    try {
+        fs__default["default"].writeFileSync(fileName, JSON.stringify(outputObject, undefined, pretty ? 2 : undefined));
+    }
+    catch (err) {
+        logger_logger.Logger.error(err);
+        return;
+    }
+    logger_logger.Logger.success(`\t\tStudy rules saved`);
+};
+const generateCustomStudyRules = (study, outputPath, pretty) => {
+    if (!study.customStudyRules || study.customStudyRules.length < 0) {
+        logger_logger.Logger.log(`\tNo custom study rules in the study.`);
+        return;
+    }
+    else {
+        logger_logger.Logger.log(`\tCustom study rules:`);
+    }
+    const customRulePath = `${outputPath}/customRules`;
+    if (!fs__default["default"].existsSync(customRulePath)) {
+        fs__default["default"].mkdirSync(customRulePath, { recursive: true });
+    }
+    study.customStudyRules.forEach(studyRule => {
+        const fileName = `${customRulePath}/${studyRule.name}.json`;
+        const outputObject = studyRule.rules;
+        try {
+            fs__default["default"].writeFileSync(fileName, JSON.stringify(outputObject, undefined, pretty ? 2 : undefined));
+        }
+        catch (err) {
+            logger_logger.Logger.error(err);
+            return;
+        }
+        logger_logger.Logger.success(`\t\tRule ${studyRule.name} saved`);
+    });
+};
+const generateMessageConfigs = (study, outputPath, pretty) => {
+    if (!study.messageConfigs || study.messageConfigs.length < 1) {
+        logger_logger.Logger.log(`\tNo message configs in the study.`);
+        return;
+    }
+    else {
+        logger_logger.Logger.log(`\tMessage configs:`);
+    }
+    const messageConfigPath = `${outputPath}/messageConfigs`;
+    if (!fs__default["default"].existsSync(messageConfigPath)) {
+        fs__default["default"].mkdirSync(messageConfigPath, { recursive: true });
+    }
+    study.messageConfigs.forEach(conf => {
+        const fileName = `${messageConfigPath}/${conf.label.replace(/ /g, '_').toLocaleLowerCase()}.json`;
+        const outputObject = types_messageConfig.buildMessageConfig(conf, study.studyKey);
+        try {
+            fs__default["default"].writeFileSync(fileName, JSON.stringify(outputObject, undefined, pretty ? 2 : undefined));
+        }
+        catch (err) {
+            logger_logger.Logger.error(err);
+            return;
+        }
+        logger_logger.Logger.success(`\t\tConfig for "${conf.label}" saved`);
+    });
+};
+
+exports.generateFilesForStudy = generateFilesForStudy;
+//# sourceMappingURL=index.js.map

package/exporter/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/expression-utils/expressionGen.d.ts

@@ -1,2 +1,2 @@
-import { Expression, ExpressionName } from "survey-engine/lib/data_types";
+import { Expression, ExpressionName } from "survey-engine/data_types";
 export declare const generateExpression: (name: ExpressionName, returnType?: "string" | "float" | undefined, ...args: any[]) => Expression;

package/expression-utils/studyEngineExpressions.d.ts

@@ -1,12 +1,15 @@
-import { Expression } from "survey-engine/lib/data_types";
+import { Expression } from "survey-engine/data_types";
 import { Duration } from "../types/duration";
 export declare const NativeStudyEngineExpressions: {
-    checkEventType: (equalsType: 'ENTER' | 'SUBMIT' | 'TIMER') => Expression;
+    checkEventType: (equalsType: 'ENTER' | 'SUBMIT' | 'TIMER' | 'MERGE') => Expression;
     checkSurveyResponseKey: (surveyKey: string) => Expression;
     responseHasKeysAny: (itemKey: string, responseSlotKey: string, ...optionKeys: string[]) => Expression;
     responseHasOnlyKeysOtherThan: (itemKey: string, responseSlotKey: string, ...optionKeys: string[]) => Expression;
     getResponseValueAsNum: (itemKey: string, responseKey: string) => Expression;
     getResponseValueAsStr: (itemKey: string, responseKey: string) => Expression;
+    getSelectedKeys: (itemKey: string, responseKey: string) => Expression;
+    hasResponseKey: (itemKey: string, responseKey: string) => Expression;
+    hasResponseKeyWithValue: (itemKey: string, responseKey: string, value: string) => Expression;
     countResponseItems: (itemKey: string, responseKey: string) => Expression;
     checkConditionForOldResponses: (condition: Expression, checkType?: number | "all" | "any" | undefined, surveyKey?: string | undefined, querySince?: number | Expression | undefined, queryUntil?: number | Expression | undefined) => Expression;
     participantState: {
@@ -15,8 +18,25 @@ export declare const NativeStudyEngineExpressions: {
         getSurveyKeyAssignedFrom: (surveyKey: string) => Expression;
         getSurveyKeyAssignedUntil: (surveyKey: string) => Expression;
         hasStudyStatus: (status: string) => Expression;
-        hasParticipantFlag: (key: string, value: string) => Expression;
+        hasParticipantFlagKeyAndValue: (key: string, value: string) => Expression;
+        hasParticipantFlagKey: (key: string) => Expression;
+        getParticipantFlagValue: (key: string) => Expression;
         lastSubmissionDateOlderThan: (reference: number | Expression, surveyKey?: string | undefined) => Expression;
+        hasMessageTypeAssigned: (messageType: string) => Expression;
+        getMessageNextTime: (messageType: string) => Expression;
+        incomingParticipantState: {
+            getStudyEntryTime: () => Expression;
+            hasSurveyKeyAssigned: (surveyKey: string) => Expression;
+            getSurveyKeyAssignedFrom: (surveyKey: string) => Expression;
+            getSurveyKeyAssignedUntil: (surveyKey: string) => Expression;
+            hasStudyStatus: (status: string) => Expression;
+            hasParticipantFlagKeyAndValue: (key: string, value: string) => Expression;
+            hasParticipantFlagKey: (key: string) => Expression;
+            getParticipantFlagValue: (key: string) => Expression;
+            lastSubmissionDateOlderThan: (reference: number | Expression, surveyKey?: string | undefined) => Expression;
+            hasMessageTypeAssigned: (messageType: string) => Expression;
+            getMessageNextTime: (messageType: string) => Expression;
+        };
     };
     eq: (val1: Expression | string | number, val2: Expression | string | number) => Expression;
     lt: (val1: Expression | string | number, val2: Expression | string | number) => Expression;
@@ -34,17 +54,31 @@ export declare const StudyEngineActions: {
     ifThen: (condition: Expression, ...args: Expression[]) => Expression;
     participantActions: {
         updateStudyStatus: (status: string) => Expression;
-        updateFlag: (key: string, newValue: string) => Expression;
+        startNewStudySession: () => Expression;
+        updateFlag: (key: string, newValue: string | number | Expression) => Expression;
         removeFlag: (key: string) => Expression;
         assignedSurveys: {
-            add: (surveyKey: string, category: 'prio' | 'normal' | 'optional', activeFrom?: number | Expression | undefined, activeUntil?: number | Expression | undefined) => Expression;
+            add: (surveyKey: string, category: 'immediate' | 'prio' | 'normal' | 'optional', activeFrom?: number | Expression | undefined, activeUntil?: number | Expression | undefined) => Expression;
             removeAll: () => Expression;
             remove: (surveyKey: string, selector: 'first' | 'last' | 'all') => Expression;
         };
         reports: {
-            add: (itemKey: string) => Expression;
+            init: (reportKey: string) => Expression;
+            cancel: (reportKey: string) => Expression;
+            updateData: (reportKey: string, attributeKey: string, value: number | string | Expression, dtype?: "string" | "date" | "float" | "int" | "rawMessage" | "keyList" | undefined) => Expression;
+            removeData: (reportKey: string, attributeKey: string) => Expression;
+            setReportIcon: (reportKey: string, icon: string) => Expression;
+            setReportMessage: (reportKey: string, content: string, asTranslationKey?: boolean | undefined) => Expression;
+            setReportSummary: (reportKey: string, content: string, asTranslationKey?: boolean | undefined) => Expression;
+        };
+        messages: {
+            add: (messageType: string, scheduledFor: number | Expression) => Expression;
+            removeAll: () => Expression;
+            remove: (messageType: string) => Expression;
+        };
+        confidentialResponses: {
+            removeByKey: (key: string) => Expression;
             removeAll: () => Expression;
-            remove: (surveyKey: string, selector: 'first' | 'last' | 'all') => Expression;
         };
         stopParticipation: () => Expression;
         finishParticipation: () => Expression;
@@ -60,37 +94,67 @@ export declare const StudyEngine: {
         none: (itemKey: string, ...optionKeys: string[]) => Expression;
         all: (itemKey: string, ...optionKeys: string[]) => Expression;
     };
+    consent: {
+        accepted: (itemKey: string) => Expression;
+    };
     survey: {
         isActive: (surveyKey: string) => Expression;
         validFromOlderThan: (surveyKey: string, delta: Duration, reference?: number | Expression | undefined) => Expression;
         validUntilSoonerThan: (surveyKey: string, delta: Duration, reference?: number | Expression | undefined) => Expression;
     };
+    prefillRules: {
+        GET_LAST_SURVEY_ITEM: (surveyKey: string, itemKey: string, submittedLaterThan?: Duration | undefined) => Expression;
+    };
+    contextRules: {
+        previousResponses: {
+            LAST_RESPONSES_BY_KEY: (surveyKey: string, limit: number) => Expression;
+            ALL_RESPONSES_SINCE: (sinceTimestamp: number) => Expression;
+            RESPONSES_SINCE_BY_KEY: (sinceTimestamp: number, surveyKey: string) => Expression;
+        };
+    };
     if: (condition: Expression, actionIfTrue: Expression, actionIfFalse?: Expression | undefined) => Expression;
     do: (...args: Expression[]) => Expression;
     ifThen: (condition: Expression, ...args: Expression[]) => Expression;
     participantActions: {
         updateStudyStatus: (status: string) => Expression;
-        updateFlag: (key: string, newValue: string) => Expression;
+        startNewStudySession: () => Expression;
+        updateFlag: (key: string, newValue: string | number | Expression) => Expression;
         removeFlag: (key: string) => Expression;
         assignedSurveys: {
-            add: (surveyKey: string, category: 'prio' | 'normal' | 'optional', activeFrom?: number | Expression | undefined, activeUntil?: number | Expression | undefined) => Expression;
+            add: (surveyKey: string, category: 'immediate' | 'prio' | 'normal' | 'optional', activeFrom?: number | Expression | undefined, activeUntil?: number | Expression | undefined) => Expression;
             removeAll: () => Expression;
             remove: (surveyKey: string, selector: 'first' | 'last' | 'all') => Expression;
         };
         reports: {
-            add: (itemKey: string) => Expression;
+            init: (reportKey: string) => Expression;
+            cancel: (reportKey: string) => Expression;
+            updateData: (reportKey: string, attributeKey: string, value: number | string | Expression, dtype?: "string" | "date" | "float" | "int" | "rawMessage" | "keyList" | undefined) => Expression;
+            removeData: (reportKey: string, attributeKey: string) => Expression;
+            setReportIcon: (reportKey: string, icon: string) => Expression;
+            setReportMessage: (reportKey: string, content: string, asTranslationKey?: boolean | undefined) => Expression;
+            setReportSummary: (reportKey: string, content: string, asTranslationKey?: boolean | undefined) => Expression;
+        };
+        messages: {
+            add: (messageType: string, scheduledFor: number | Expression) => Expression;
+            removeAll: () => Expression;
+            remove: (messageType: string) => Expression;
+        };
+        confidentialResponses: {
+            removeByKey: (key: string) => Expression;
             removeAll: () => Expression;
-            remove: (surveyKey: string, selector: 'first' | 'last' | 'all') => Expression;
         };
         stopParticipation: () => Expression;
         finishParticipation: () => Expression;
     };
-    checkEventType: (equalsType: 'ENTER' | 'SUBMIT' | 'TIMER') => Expression;
+    checkEventType: (equalsType: 'ENTER' | 'SUBMIT' | 'TIMER' | 'MERGE') => Expression;
     checkSurveyResponseKey: (surveyKey: string) => Expression;
     responseHasKeysAny: (itemKey: string, responseSlotKey: string, ...optionKeys: string[]) => Expression;
     responseHasOnlyKeysOtherThan: (itemKey: string, responseSlotKey: string, ...optionKeys: string[]) => Expression;
     getResponseValueAsNum: (itemKey: string, responseKey: string) => Expression;
     getResponseValueAsStr: (itemKey: string, responseKey: string) => Expression;
+    getSelectedKeys: (itemKey: string, responseKey: string) => Expression;
+    hasResponseKey: (itemKey: string, responseKey: string) => Expression;
+    hasResponseKeyWithValue: (itemKey: string, responseKey: string, value: string) => Expression;
     countResponseItems: (itemKey: string, responseKey: string) => Expression;
     checkConditionForOldResponses: (condition: Expression, checkType?: number | "all" | "any" | undefined, surveyKey?: string | undefined, querySince?: number | Expression | undefined, queryUntil?: number | Expression | undefined) => Expression;
     participantState: {
@@ -99,8 +163,25 @@ export declare const StudyEngine: {
         getSurveyKeyAssignedFrom: (surveyKey: string) => Expression;
         getSurveyKeyAssignedUntil: (surveyKey: string) => Expression;
         hasStudyStatus: (status: string) => Expression;
-        hasParticipantFlag: (key: string, value: string) => Expression;
+        hasParticipantFlagKeyAndValue: (key: string, value: string) => Expression;
+        hasParticipantFlagKey: (key: string) => Expression;
+        getParticipantFlagValue: (key: string) => Expression;
         lastSubmissionDateOlderThan: (reference: number | Expression, surveyKey?: string | undefined) => Expression;
+        hasMessageTypeAssigned: (messageType: string) => Expression;
+        getMessageNextTime: (messageType: string) => Expression;
+        incomingParticipantState: {
+            getStudyEntryTime: () => Expression;
+            hasSurveyKeyAssigned: (surveyKey: string) => Expression;
+            getSurveyKeyAssignedFrom: (surveyKey: string) => Expression;
+            getSurveyKeyAssignedUntil: (surveyKey: string) => Expression;
+            hasStudyStatus: (status: string) => Expression;
+            hasParticipantFlagKeyAndValue: (key: string, value: string) => Expression;
+            hasParticipantFlagKey: (key: string) => Expression;
+            getParticipantFlagValue: (key: string) => Expression;
+            lastSubmissionDateOlderThan: (reference: number | Expression, surveyKey?: string | undefined) => Expression;
+            hasMessageTypeAssigned: (messageType: string) => Expression;
+            getMessageNextTime: (messageType: string) => Expression;
+        };
     };
     eq: (val1: Expression | string | number, val2: Expression | string | number) => Expression;
     lt: (val1: Expression | string | number, val2: Expression | string | number) => Expression;