case-editor-tools 1.0.0-beta.4 → 1.0.0-beta.43

package/{build/constants → 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/{build/constants → 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/{build/constants → 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,99 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fs = require('fs');
+var logger_logger = require('../logger/logger.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);
+};
+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`);
+    });
+};
+
+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/{build/expression-utils → 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

@@ -0,0 +1,193 @@
+import { Expression } from "survey-engine/data_types";
+import { Duration } from "../types/duration";
+export declare const NativeStudyEngineExpressions: {
+    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;
+    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: {
+        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;
+        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;
+    lte: (val1: Expression | string | number, val2: Expression | string | number) => Expression;
+    gt: (val1: Expression | string | number, val2: Expression | string | number) => Expression;
+    gte: (val1: Expression | string | number, val2: Expression | string | number) => Expression;
+    or: (...args: Expression[]) => Expression;
+    and: (...args: Expression[]) => Expression;
+    not: (arg: Expression) => Expression;
+    timestampWithOffset: (delta: Duration, reference?: number | Expression | undefined) => Expression;
+};
+export declare const StudyEngineActions: {
+    if: (condition: Expression, actionIfTrue: Expression, actionIfFalse?: Expression | undefined) => Expression;
+    do: (...args: Expression[]) => Expression;
+    ifThen: (condition: Expression, ...args: Expression[]) => Expression;
+    participantActions: {
+        updateStudyStatus: (status: string) => Expression;
+        startNewStudySession: () => Expression;
+        updateFlag: (key: string, newValue: string | number | Expression) => Expression;
+        removeFlag: (key: string) => Expression;
+        assignedSurveys: {
+            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: {
+            init: (reportKey: string) => Expression;
+            cancel: (reportKey: string) => Expression;
+            updateData: (reportKey: string, attributeKey: string, value: number | string | Expression, dtype?: "string" | "date" | "float" | "int" | "rawMessage" | 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;
+        };
+        stopParticipation: () => Expression;
+        finishParticipation: () => Expression;
+    };
+};
+export declare const StudyEngine: {
+    singleChoice: {
+        any: (itemKey: string, ...optionKeys: string[]) => Expression;
+        none: (itemKey: string, ...optionKeys: string[]) => Expression;
+    };
+    multipleChoice: {
+        any: (itemKey: string, ...optionKeys: string[]) => Expression;
+        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;
+        startNewStudySession: () => Expression;
+        updateFlag: (key: string, newValue: string | number | Expression) => Expression;
+        removeFlag: (key: string) => Expression;
+        assignedSurveys: {
+            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: {
+            init: (reportKey: string) => Expression;
+            cancel: (reportKey: string) => Expression;
+            updateData: (reportKey: string, attributeKey: string, value: number | string | Expression, dtype?: "string" | "date" | "float" | "int" | "rawMessage" | 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;
+        };
+        stopParticipation: () => Expression;
+        finishParticipation: () => 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;
+    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: {
+        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;
+        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;
+    lte: (val1: Expression | string | number, val2: Expression | string | number) => Expression;
+    gt: (val1: Expression | string | number, val2: Expression | string | number) => Expression;
+    gte: (val1: Expression | string | number, val2: Expression | string | number) => Expression;
+    or: (...args: Expression[]) => Expression;
+    and: (...args: Expression[]) => Expression;
+    not: (arg: Expression) => Expression;
+    timestampWithOffset: (delta: Duration, reference?: number | Expression | undefined) => Expression;
+};