case-editor-tools 1.0.0-beta.7 → 1.0.0

package/constants/key-definitions.d.ts

@@ -0,0 +1,16 @@
+export declare const responseGroupKey = "rg";
+export declare const singleChoiceKey = "scg";
+export declare const likertScaleGroupKey = "lg";
+export declare const responsiveSingleChoiceArrayKey = "rsca";
+export declare const responsiveBipolarLikertArrayKey = "rsbla";
+export declare const likertScaleKey = "likert";
+export declare const multipleChoiceKey = "mcg";
+export declare const dropDownKey = "ddg";
+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

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const responseGroupKey = 'rg';
+const singleChoiceKey = 'scg';
+const likertScaleGroupKey = 'lg';
+const responsiveSingleChoiceArrayKey = 'rsca';
+const responsiveBipolarLikertArrayKey = 'rsbla';
+const likertScaleKey = 'likert';
+const multipleChoiceKey = 'mcg';
+const dropDownKey = 'ddg';
+const sliderCategoricalKey = "scc";
+const inputKey = "ic";
+const numericInputKey = "num";
+const datePickerKey = "date";
+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;
+exports.likertScaleGroupKey = likertScaleGroupKey;
+exports.likertScaleKey = likertScaleKey;
+exports.matrixKey = matrixKey;
+exports.multipleChoiceKey = multipleChoiceKey;
+exports.numericInputKey = numericInputKey;
+exports.responseGroupKey = responseGroupKey;
+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

@@ -0,0 +1 @@
+{"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(' ', '_').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

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

package/expression-utils/expressionGen.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const generateExpression = (name, returnType, ...args) => {
+    return {
+        name: name,
+        returnType: returnType,
+        data: args.filter(a => a !== undefined).map(arg => {
+            if (typeof (arg) === 'string') {
+                return {
+                    dtype: 'str',
+                    str: arg
+                };
+            }
+            else if (typeof (arg) === 'number') {
+                return {
+                    dtype: 'num',
+                    num: arg
+                };
+            }
+            return {
+                dtype: 'exp',
+                exp: arg
+            };
+        })
+    };
+};
+
+exports.generateExpression = generateExpression;
+//# sourceMappingURL=expressionGen.js.map

package/expression-utils/expressionGen.js.map

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

package/expression-utils/studyEngineExpressions.d.ts

@@ -0,0 +1,195 @@
+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;
+    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: {
+        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" | "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;
+        };
+        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" | "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;
+        };
+        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;
+    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: {
+        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;
+};