diff --git a/src/i18n/en.json b/src/i18n/en.json index 734a74f19..c477ad01d 100644 --- a/src/i18n/en.json +++ b/src/i18n/en.json @@ -128,6 +128,7 @@ "form": { "add": { "errors": { + "koboForm": "An error occurred when trying to create a new form from a Kobo form", "resourceDuplicated": "An existing resource with that name already exists." } }, diff --git a/src/i18n/test.json b/src/i18n/test.json index bfa77f925..5ed0a9c18 100644 --- a/src/i18n/test.json +++ b/src/i18n/test.json @@ -128,6 +128,7 @@ "form": { "add": { "errors": { + "koboForm": "******", "resourceDuplicated": "******" } }, diff --git a/src/models/form.model.ts b/src/models/form.model.ts index 6105faa10..39d628a95 100644 --- a/src/models/form.model.ts +++ b/src/models/form.model.ts @@ -10,6 +10,7 @@ import { getGraphQLTypeName } from '@utils/validators'; import { deleteFolder } from '@utils/files/deleteFolder'; import { logger } from '@services/logger.service'; import { DEFAULT_IMPORT_FIELD } from './resource.model'; +import { ApiConfiguration } from './apiConfiguration.model'; /** Form documents interface declaration */ interface FormDocument extends Document { @@ -38,6 +39,12 @@ interface FormDocument extends Document { versions?: any[]; channel?: any; layouts?: any; + kobo?: { + id: string; + deployedVersionId: string; + dataFromDeployedVersion: boolean; + apiConfiguration: ApiConfiguration; + }; } /** Interface of form */ @@ -68,6 +75,15 @@ const schema = new Schema
( type: String, enum: Object.values(status), }, + kobo: { + id: String, + deployedVersionId: String, + dataFromDeployedVersion: { type: Boolean, default: false }, + apiConfiguration: { + type: mongoose.Schema.Types.ObjectId, + ref: 'ApiConfiguration', + }, + }, permissions: { canSee: [ { diff --git a/src/models/record.model.ts b/src/models/record.model.ts index bd80c0e88..27abc0cae 100644 --- a/src/models/record.model.ts +++ b/src/models/record.model.ts @@ -26,6 +26,7 @@ export interface Record extends AccessibleFieldsDocument { modifiedAt: Date; archived: boolean; data: any; + koboId?: string; versions: any; permissions: { canSee?: any[]; @@ -59,6 +60,7 @@ const recordSchema = new Schema( type: mongoose.Schema.Types.Mixed, required: true, }, + koboId: String, lastUpdateForm: { type: mongoose.Schema.Types.ObjectId, ref: 'Form', diff --git a/src/routes/proxy/index.ts b/src/routes/proxy/index.ts index 89c9dca3b..a44cf554d 100644 --- a/src/routes/proxy/index.ts +++ b/src/routes/proxy/index.ts @@ -66,7 +66,9 @@ const proxyAPIRequest = async ( url, method: req.method, headers: { - Authorization: `Bearer ${token}`, + // if user-to-service token may contain prefix so it's get directly in getToken + Authorization: + api.authType == 'user-to-service' ? token : `Bearer ${token}`, 'Content-Type': 'application/json', }, maxRedirects: 35, diff --git a/src/schema/mutation/addForm.mutation.ts b/src/schema/mutation/addForm.mutation.ts index ca4769ed6..3c29eface 100644 --- a/src/schema/mutation/addForm.mutation.ts +++ b/src/schema/mutation/addForm.mutation.ts @@ -5,7 +5,19 @@ import { GraphQLError, } from 'graphql'; import { validateGraphQLTypeName } from '@utils/validators'; -import { Resource, Form, Role, ReferenceData } from '@models'; +import { + extractFields, + extractKoboFields, + findDuplicateFields, +} from '@utils/form'; +import { + Resource, + Form, + Role, + ReferenceData, + ApiConfiguration, + Version, +} from '@models'; import { FormType } from '../types'; import { AppAbility } from '@security/defineUserAbility'; import { status } from '@const/enumTypes'; @@ -13,12 +25,18 @@ import { logger } from '@services/logger.service'; import { graphQLAuthCheck } from '@schema/shared'; import { Types } from 'mongoose'; import { Context } from '@server/apollo/context'; +import axios from 'axios'; +import config from 'config'; +import * as CryptoJS from 'crypto-js'; +import checkDefaultFields from '@utils/form/checkDefaultFields'; /** Arguments for the addForm mutation */ type AddFormArgs = { name: string; resource?: string | Types.ObjectId; template?: string | Types.ObjectId; + apiConfiguration?: string | Types.ObjectId; + kobo?: string; }; /** @@ -31,6 +49,8 @@ export default { name: { type: new GraphQLNonNull(GraphQLString) }, resource: { type: GraphQLID }, template: { type: GraphQLID }, + apiConfiguration: { type: GraphQLID }, + kobo: { type: GraphQLString }, }, async resolve(parent, args: AddFormArgs, context: Context) { graphQLAuthCheck(context); @@ -72,6 +92,83 @@ export default { canUpdateRecords: [], canDeleteRecords: [], }; + try { + if (args.apiConfiguration) { + const apiConfiguration = await ApiConfiguration.findById( + args.apiConfiguration + ); + const url = + apiConfiguration.endpoint + `assets/${args.kobo}?format=json`; + const settings = JSON.parse( + CryptoJS.AES.decrypt( + apiConfiguration.settings, + config.get('encryption.key') + ).toString(CryptoJS.enc.Utf8) + ); + // get kobo form data + const response = await axios.get(url, { + headers: { + Authorization: `${settings.tokenPrefix} ${settings.token}`, + }, + }); + const survey = response.data.content.survey; + const choices = response.data.content.choices; + const title = response.data.name; + const deployedVersionId = response.data.deployed_version_id; + + // Get structure from the kobo form + const structure = JSON.stringify( + extractKoboFields(survey, title, choices) + ); + + // Extract fields + const fields = []; + const structureObj = JSON.parse(structure); + for (const page of structureObj.pages) { + await extractFields(page, fields, true); + findDuplicateFields(fields); + } + // Check if default fields are used + checkDefaultFields(fields); + + // Create version with structure + const version = new Version({ + data: structure, + }); + await version.save(); + + // create resource and form + const resource = new Resource({ + name: args.name, + permissions: defaultResourcePermissions, + fields, + }); + await resource.save(); + const form = new Form({ + name: args.name, + graphQLTypeName, + status: status.pending, + resource, + core: true, + permissions: defaultFormPermissions, + structure, + fields, + versions: [version._id], + kobo: { + id: args.kobo, + deployedVersionId, + apiConfiguration: args.apiConfiguration, + }, + }); + await form.save(); + return form; + } + } catch (err) { + logger.error(err.message, { stack: err.stack }); + throw new GraphQLError( + context.i18next.t('mutations.form.add.errors.koboForm:') + ); + } try { if (!args.resource) { // Check permission to create resource diff --git a/src/schema/mutation/addRecordsFromKobo.mutation.ts b/src/schema/mutation/addRecordsFromKobo.mutation.ts new file mode 100644 index 000000000..4e19fe9b8 --- /dev/null +++ b/src/schema/mutation/addRecordsFromKobo.mutation.ts @@ -0,0 +1,238 @@ +import { + ApiConfiguration, + Channel, + Notification, + Form, + Record, + Version, +} from '@models'; +import { + GraphQLBoolean, + GraphQLError, + GraphQLID, + GraphQLNonNull, +} from 'graphql'; +import mongoose from 'mongoose'; +import { Context } from '@server/apollo/context'; +import { graphQLAuthCheck } from '@schema/shared'; +import extendAbilityForRecords from '@security/extendAbilityForRecords'; +import { logger } from '@services/logger.service'; +import config from 'config'; +import * as CryptoJS from 'crypto-js'; +import axios from 'axios'; +import { getNextId, transformRecord } from '@utils/form'; +import { cloneDeep, isEqual } from 'lodash'; +import pubsub from '../../server/pubsub'; + +/** Arguments for the addRecordsFromKobo mutation */ +type AddRecordsFromKoboArgs = { + form: string | mongoose.Types.ObjectId; +}; + +/** + * From the kobo data submission, extract the form data. + * + * @param submission kobo data submission + * @param fields Oort form fields + * @param fieldsNames Array with the fields names + * @returns data object for the record + */ +const getData = (submission: any, fields: any, fieldsNames: string[]) => { + // Filter submission object, keeping only questions data + for (const key in submission) { + if (!fieldsNames.includes(key)) { + delete submission[key]; + } + } + return transformRecord(submission, fields); +}; + +/** + * For a form created from a Kobotoolbox form, import data submissions to create records. + * Throw an error if not logged or authorized, or if arguments are invalid. + */ +export default { + type: GraphQLBoolean, + args: { + form: { type: new GraphQLNonNull(GraphQLID) }, + }, + async resolve(parent, args: AddRecordsFromKoboArgs, context: Context) { + graphQLAuthCheck(context); + try { + const user = context.user; + // Get the form + const form = await Form.findById(args.form); + if (!form || !form.kobo.id) { + throw new GraphQLError(context.i18next.t('common.errors.dataNotFound')); + } + // Check the ability with permissions for this form + const ability = await extendAbilityForRecords(user, form); + if (ability.cannot('create', 'Record')) { + throw new GraphQLError( + context.i18next.t('common.errors.permissionNotGranted') + ); + } + // Get Kobo data submissions + const apiConfiguration = await ApiConfiguration.findById( + form.kobo.apiConfiguration + ); + if (!apiConfiguration) { + throw new GraphQLError(context.i18next.t('common.errors.dataNotFound')); + } + const url = `https://kf.kobotoolbox.org/api/v2/assets/${form.kobo.id}/data.json`; + const settings = JSON.parse( + CryptoJS.AES.decrypt( + apiConfiguration.settings, + config.get('encryption.key') + ).toString(CryptoJS.enc.Utf8) + ); + const response = await axios.get(url, { + headers: { + // settings.tokenPrefix MUST be 'Token' + Authorization: `Token ${settings.token}`, + }, + }); + let submissions = response.data.results; + // Only data submissions sent when the form was in the same version as when it was imported will be used to create records + if (form.kobo.dataFromDeployedVersion) { + submissions = submissions.filter( + (submission: any) => + submission.__version__ === form.kobo.deployedVersionId + ); + } + if (!submissions.length) { + // Nothing to synchronize + return false; + } else { + // Get existing records already rested from data synchronization with kobo + const oldRecords = await Record.find({ + form: args.form, + koboId: { $ne: null }, + }); + + const versionsToCreate: Version[] = []; + const recordsToCreate: Record[] = []; + const recordsToUpdate: Record[] = []; + const fieldsNames = form.fields.map((field: any) => field.name); + + for (const submission of submissions) { + const oldRecord = oldRecords.find((rec: Record) => { + const submissionId = Object.prototype.hasOwnProperty.call( + submission, + 'meta/rootUuid' + ) + ? submission['meta/rootUuid'] + : submission._uuid; + return rec.koboId === submissionId; + }); + if (oldRecord) { + const recordToUpdate = cloneDeep(oldRecord); + const data = getData(submission, form.fields, fieldsNames); + recordToUpdate.data = { ...recordToUpdate.data, ...data }; + if (!isEqual(oldRecord.data, recordToUpdate.data)) { + const version = new Version({ + createdAt: oldRecord.modifiedAt + ? oldRecord.modifiedAt + : oldRecord.createdAt, + data: oldRecord.data, + createdBy: context.user.id, + }); + recordToUpdate.versions.push(version); + recordToUpdate.markModified('versions'); + recordToUpdate.modifiedAt = new Date(); + versionsToCreate.push(version); + recordsToUpdate.push(recordToUpdate); + } + // Records already exists, check if data changed on Kobo and we need to updated it here + } else { + // Create record from submission data + const koboId = Object.prototype.hasOwnProperty.call( + submission, + 'meta/rootUuid' + ) + ? submission['meta/rootUuid'] + : submission._uuid; + const { incrementalId, incID } = await getNextId( + String(form.resource ? form.resource : args.form) + ); + const data = getData(submission, form.fields, fieldsNames); + const record = new Record({ + incrementalId, + incID, + form: args.form, + data, + resource: form.resource ? form.resource : null, + koboId, + createdBy: { + user: user._id, + roles: user.roles.map((x) => x._id), + positionAttributes: user.positionAttributes.map((x) => { + return { + value: x.value, + category: x.category._id, + }; + }), + }, + lastUpdateForm: form.id, + _createdBy: { + user: { + _id: context.user._id, + name: context.user.name, + username: context.user.username, + }, + }, + _form: { + _id: form._id, + name: form.name, + }, + _lastUpdateForm: { + _id: form._id, + name: form.name, + }, + }); + recordsToCreate.push(record); + } + } + + const recordsToSave = [...recordsToCreate, ...recordsToUpdate]; + // If no new data, return + if (!recordsToSave.length) { + return false; + } else { + // Save all changes + try { + await Version.bulkSave(versionsToCreate); + await Record.bulkSave(recordsToSave); + // Send notifications to channel + const channel = await Channel.findOne({ form: form._id }); + if (channel) { + const notification = new Notification({ + action: `Records created from Kobo synchronized data submissions - ${form.name}`, + content: '', + channel: channel.id, + seenBy: [], + }); + await notification.save(); + const publisher = await pubsub(); + publisher.publish(channel.id, { notification }); + } + return true; + } catch (err2) { + logger.error(err2.message, { stack: err2.stack }); + throw new GraphQLError( + context.i18next.t('common.errors.internalServerError') + ); + } + } + } + } catch (err) { + logger.error(err.message, { stack: err.stack }); + if (err instanceof GraphQLError) { + throw new GraphQLError(err.message); + } + throw new GraphQLError( + context.i18next.t('common.errors.internalServerError') + ); + } + }, +}; diff --git a/src/schema/mutation/editForm.mutation.ts b/src/schema/mutation/editForm.mutation.ts index 48cb9aaf5..e8fd5489f 100644 --- a/src/schema/mutation/editForm.mutation.ts +++ b/src/schema/mutation/editForm.mutation.ts @@ -3,6 +3,7 @@ import { GraphQLID, GraphQLString, GraphQLError, + GraphQLBoolean, } from 'graphql'; import GraphQLJSON from 'graphql-type-json'; import { Form, Resource, Version, Channel, ReferenceData } from '@models'; @@ -22,7 +23,7 @@ import isEqual from 'lodash/isEqual'; import differenceWith from 'lodash/differenceWith'; import unionWith from 'lodash/unionWith'; import i18next from 'i18next'; -import { get, isArray } from 'lodash'; +import { get, isArray, isNil } from 'lodash'; import { logger } from '@services/logger.service'; import checkDefaultFields from '@utils/form/checkDefaultFields'; import { graphQLAuthCheck } from '@schema/shared'; @@ -74,6 +75,7 @@ type EditFormArgs = { status?: StatusType; name?: string; permissions?: any; + dataFromDeployedVersion?: boolean; }; /** @@ -88,6 +90,7 @@ export default { status: { type: StatusEnumType }, name: { type: GraphQLString }, permissions: { type: GraphQLJSON }, + dataFromDeployedVersion: { type: GraphQLBoolean }, }, async resolve(parent, args: EditFormArgs, context: Context) { graphQLAuthCheck(context); @@ -208,6 +211,14 @@ export default { } } + // Update kobo dataFromDeployedVersion + if (!isNil(args.dataFromDeployedVersion)) { + update.kobo = { + ...form.kobo, + dataFromDeployedVersion: args.dataFromDeployedVersion, + }; + } + // Update fields and structure, check that structure is different if (args.structure && !isEqual(form.structure, args.structure)) { update.structure = args.structure; diff --git a/src/schema/mutation/index.ts b/src/schema/mutation/index.ts index 992e550e2..7f8820a37 100644 --- a/src/schema/mutation/index.ts +++ b/src/schema/mutation/index.ts @@ -89,6 +89,7 @@ import restorePage from './restorePage.mutation'; import addDraftRecord from './addDraftRecord.mutation'; import deleteDraftRecord from './deleteDraftRecord.mutation'; import editDraftRecord from './editDraftRecord.mutation'; +import addRecordsFromKobo from './addRecordsFromKobo.mutation'; /** GraphQL mutation definition */ const Mutation = new GraphQLObjectType({ @@ -184,6 +185,7 @@ const Mutation = new GraphQLObjectType({ addDraftRecord, deleteDraftRecord, editDraftRecord, + addRecordsFromKobo, }, }); diff --git a/src/schema/types/form.type.ts b/src/schema/types/form.type.ts index 844aeb9b4..0fd9bc541 100644 --- a/src/schema/types/form.type.ts +++ b/src/schema/types/form.type.ts @@ -28,6 +28,7 @@ import extendAbilityForContent from '@security/extendAbilityForContent'; import { getMetaData } from '@utils/form/metadata.helper'; import { getAccessibleFields } from '@utils/form'; import { accessibleBy } from '@casl/mongoose'; +import { KoboFormType } from './koboForm.type'; /** Default page size */ const DEFAULT_FIRST = 10; @@ -49,6 +50,7 @@ export const FormType = new GraphQLObjectType({ structure: { type: GraphQLJSON }, status: { type: StatusEnumType }, allowUploadRecords: { type: GraphQLBoolean }, + kobo: { type: KoboFormType }, permissions: { type: AccessType, async resolve(parent, args, context) { diff --git a/src/schema/types/koboForm.type.ts b/src/schema/types/koboForm.type.ts new file mode 100644 index 000000000..6c67d7317 --- /dev/null +++ b/src/schema/types/koboForm.type.ts @@ -0,0 +1,26 @@ +import { GraphQLBoolean, GraphQLObjectType, GraphQLString } from 'graphql'; +import { ApiConfigurationType } from './apiConfiguration.type'; +import { AppAbility } from '@security/defineUserAbility'; +import { ApiConfiguration } from '@models'; +import { accessibleBy } from '@casl/mongoose'; + +/** GraphQL Kobo form type definition */ +export const KoboFormType = new GraphQLObjectType({ + name: 'KoboForm', + fields: () => ({ + id: { type: GraphQLString }, + deployedVersionId: { type: GraphQLString }, + dataFromDeployedVersion: { type: GraphQLBoolean }, + apiConfiguration: { + type: ApiConfigurationType, + async resolve(parent, args, context) { + const ability: AppAbility = context.user.ability; + const apiConfig = await ApiConfiguration.findOne({ + _id: parent.apiConfiguration, + ...accessibleBy(ability, 'read').ApiConfiguration, + }); + return apiConfig; + }, + }, + }), +}); diff --git a/src/schema/types/record.type.ts b/src/schema/types/record.type.ts index 9aaa7fe8a..f8a25f82b 100644 --- a/src/schema/types/record.type.ts +++ b/src/schema/types/record.type.ts @@ -23,6 +23,7 @@ export const RecordType = new GraphQLObjectType({ createdAt: { type: GraphQLString }, modifiedAt: { type: GraphQLString }, archived: { type: GraphQLBoolean }, + koboId: { type: GraphQLString }, form: { type: FormType, async resolve(parent, args, context) { diff --git a/src/utils/form/extractKoboFields.ts b/src/utils/form/extractKoboFields.ts new file mode 100644 index 000000000..72751d452 --- /dev/null +++ b/src/utils/form/extractKoboFields.ts @@ -0,0 +1,379 @@ +import { mapKoboExpression } from './kobo/mapKoboExpression'; +import { commonProperties } from './kobo/commonProperties'; + +/** + * Saves all groupElement questions equivalent to the panel question. + * Groups and panels can be nested. + */ +const groupElements = []; +/** + * Saves the repeatGroupElement question equivalent to the dynamic panel question. + * Groups and panels can be nested. + */ +const repeatGroupElements = []; + +/** + * SurveyJS survey structure + */ +const survey = { + title: '', + pages: [ + { + name: 'page1', + elements: [], + }, + ], + showQuestionNumbers: 'off', +}; + +/** + * available fields types in kobo that are compatible with oort + */ +const AVAILABLE_TYPES = [ + 'decimal', + 'geopoint', + 'select_multiple', + 'select_one', + 'date', + 'note', + 'begin_score', + 'score__row', + 'text', + 'time', + 'file', + 'integer', + 'datetime', + 'acknowledge', + 'begin_rank', + 'rank__level', + 'range', + 'image', + 'audio', + 'video', + 'geoshape', + 'calculate', + 'begin_group', + 'end_group', + 'begin_repeat', + 'end_repeat', +]; + +/** + * Get all the groups names that are related to a kobo element. + * + * @param groupPath string with the group path of the kobo element (e.g. 'group_au9sz58/group_hl8uz79/ig1') + * @returns array with all the groups in the groupPath of the element. + */ +const getElementsGroups = (groupPath: string) => { + // Split all the paths in the group path + const allPaths = groupPath.split('/'); + // Remove the last element (is the name of the current question) + allPaths.pop(); + return allPaths; + + // NO LONGER USED BECAUSE IN THE INTEGRATION TESTS ALL THE GROUPS ARE RE-NAMED AND THE ID IS NOT THE SAME + // const groupDelimiter = 'group_'; + // Filter parts that start with the groupDelimiter (that are group names) + // return allPaths.filter((part: string) => part.startsWith(groupDelimiter)); +}; + +/** + * Adds a new question/element to the page elements, panel elements or to the dynamic panel template elements + * + * @param newElement element to add + * @param elementPath string with the element path of the kobo element (e.g. 'group_au9sz58/group_hl8uz79/ig1') + * @param parentGroup if element is a group and have a parent group, we already know it's parent group + */ +const addToElements = ( + newElement: any, + elementPath: string | null, + parentGroup?: string +) => { + const groups = elementPath ? getElementsGroups(elementPath) : []; + // If element is not part of a group + if (!groups.length && !parentGroup) { + survey.pages[0].elements.push(newElement); + } else { + // If element is part of a group, find out which one to add it to + const groupElement = groupElements.find( + (element: any) => + element.name === (parentGroup ?? groups[groups.length - 1]) + ); + if (groupElement) { + groupElement.elements.push(newElement); + } else { + const repeatGroupElement = repeatGroupElements.find( + (element: any) => + element.name === (parentGroup ?? groups[groups.length - 1]) + ); + if (repeatGroupElement) { + repeatGroupElement.templateElements.push(newElement); + } + } + } +}; + +/** + * Extract kobo form fields and convert to oort fields + * + * @param koboSurvey Kobo survey structure + * @param title Kobo survey title + * @param choices Kobo choices data for the questions + * @returns oort survey + */ +export const extractKoboFields = ( + koboSurvey: any, + title: string, + choices: any +) => { + survey.title = title; + survey.pages[0].elements = []; + let scoreChoiceId = ''; + let rankChoiceId = ''; + + koboSurvey.map((question: any, index: number) => { + if (AVAILABLE_TYPES.includes(question.type)) { + switch (question.type) { + case 'decimal': { + const newQuestion = { + ...commonProperties(index, question, 'text'), + inputType: 'number', + }; + addToElements(newQuestion, question.$xpath); + break; + } + case 'geoshape': + case 'geopoint': { + const newQuestion = { + ...commonProperties(index, question, 'geospatial'), + }; + addToElements(newQuestion, question.$xpath); + break; + } + case 'select_one': + case 'select_multiple': { + const newQuestion = { + ...commonProperties( + index, + question, + question.type === 'select_multiple' ? 'checkbox' : 'radiogroup' + ), + ...(question.type === 'select_multiple' && { + showSelectAllItem: true, + }), + choices: choices + .filter( + (choice) => question.select_from_list_name === choice.list_name + ) + .map((choice) => ({ + value: choice.$autovalue, + text: choice.label[0], + ...(question.choice_filter && + // If in the Kobo form the choice has the 'other' property, we will not add the visibleIf because of the 'or other=0' in the expression + !Object.prototype.hasOwnProperty.call(choice, 'other') && { + visibleIf: mapKoboExpression( + question.choice_filter, + null, + choice.$autovalue + ), + }), + })), + ...(question.parameters && + question.parameters.split('randomize=')[1]?.includes('true') && { + choicesOrder: 'random', + }), + }; + addToElements(newQuestion, question.$xpath); + break; + } + case 'date': { + const newQuestion = { + ...commonProperties(index, question, 'text'), + inputType: 'date', + }; + addToElements(newQuestion, question.$xpath); + break; + } + case 'note': { + const newQuestion = { + ...commonProperties(index, question, 'expression'), + }; + addToElements(newQuestion, question.$xpath); + break; + } + case 'begin_score': { + scoreChoiceId = question['kobo--score-choices']; + break; + } + case 'score__row': { + const newQuestion = { + ...commonProperties(index, question, 'radiogroup'), + choices: choices + .filter((choice) => scoreChoiceId === choice.list_name) + .map((choice) => ({ + value: choice.$autovalue, + text: choice.label[0], + })), + // This question does not have Validation Criteria settings (validators property) + }; + addToElements(newQuestion, question.$xpath); + break; + } + case 'begin_rank': { + rankChoiceId = question['kobo--rank-items']; + break; + } + case 'rank__level': { + const newQuestion = { + ...commonProperties(index, question, 'dropdown'), + choices: choices + .filter((choice) => rankChoiceId === choice.list_name) + .map((choice) => ({ + value: choice.$autovalue, + text: choice.label[0], + })), + // This question does not have Validation Criteria settings + }; + addToElements(newQuestion, question.$xpath); + break; + } + case 'text': { + const newQuestion = { + ...commonProperties(index, question, 'text'), + }; + addToElements(newQuestion, question.$xpath); + break; + } + case 'time': { + const newQuestion = { + ...commonProperties(index, question, 'text'), + inputType: 'time', + }; + addToElements(newQuestion, question.$xpath); + break; + } + case 'audio': + case 'video': + case 'image': + case 'file': { + const newQuestion = { + ...commonProperties(index, question, 'file'), + storeDataAsText: false, + maxSize: 7340032, + }; + addToElements(newQuestion, question.$xpath); + break; + } + case 'integer': { + const newQuestion = { + ...commonProperties(index, question, 'text'), + inputType: 'number', + }; + addToElements(newQuestion, question.$xpath); + break; + } + case 'datetime': { + const newQuestion = { + ...commonProperties(index, question, 'text'), + inputType: 'datetime-local', + }; + addToElements(newQuestion, question.$xpath); + break; + } + case 'acknowledge': { + const newQuestion = { + ...commonProperties(index, question, 'boolean'), + }; + addToElements(newQuestion, question.$xpath); + break; + } + case 'range': { + const newQuestion = { + ...commonProperties(index, question, 'text'), + inputType: 'range', + step: question.parameters.split('step=')[1], + }; + addToElements(newQuestion, question.$xpath); + break; + } + case 'calculate': { + const newQuestion = { + ...commonProperties( + index, + question, + 'expression', + question.calculation + ), + visible: false, // They are not displayed in the Kobo form, so make it invisible by default for the SurveyJS + expression: mapKoboExpression(question.calculation), + // This question does not have hint (description) + }; + addToElements(newQuestion, question.$xpath); + break; + } + case 'begin_group': { + // Get all the groups names that are related to this group + const groups = getElementsGroups(question.$xpath); + const newGroupElement = { + ...commonProperties(index, question, 'panel'), + state: 'expanded', + elements: [], + groupId: question.$kuid, + // If groups still has names, the last one is the directly parent group (i.e. this group is within another group) + parentGroup: groups.length ? groups[groups.length - 1] : null, + }; + groupElements.push(newGroupElement); + break; + } + case 'end_group': { + const groupIndex = groupElements.findIndex( + (element: any) => + element.groupId === question.$kuid.substring(1) || + question.name === element.valueName + ); + const groupElement = groupElements.splice(groupIndex, 1)[0]; + addToElements(groupElement, null, groupElement.parentGroup); + break; + } + case 'begin_repeat': { + // Get all the groups names that are related to this group + const groups = getElementsGroups(question.$xpath); + const newRepeatGroupElement = { + ...commonProperties(index, question, 'paneldynamic'), + state: 'expanded', + confirmDelete: true, + panelCount: 1, + templateElements: [], + groupId: question.$kuid, + // If groups still has group names, the last one is the directly parent group (i.e. this group is within another group) + parentGroup: groups.length ? groups[groups.length - 1] : null, + }; + repeatGroupElements.push(newRepeatGroupElement); + break; + } + case 'end_repeat': { + const groupIndex = repeatGroupElements.findIndex( + (element: any) => + element.groupId === question.$kuid.substring(1) || + question.name === element.valueName + ); + const repeatGroupElement = repeatGroupElements.splice( + groupIndex, + 1 + )[0]; + addToElements( + repeatGroupElement, + null, + repeatGroupElement.parentGroup + ); + break; + } + } + } + }); + // Order elements (is necessary because of groups being added to the survey elements only after closed) + survey.pages[0].elements = survey.pages[0].elements.sort((a, b) => + a.index > b.index ? 1 : -1 + ); + return survey; +}; diff --git a/src/utils/form/index.ts b/src/utils/form/index.ts index 5365f87e2..eeab45c23 100644 --- a/src/utils/form/index.ts +++ b/src/utils/form/index.ts @@ -4,6 +4,7 @@ export * from './addField'; export * from './replaceField'; export * from './findDuplicateFields'; export * from './extractFields'; +export * from './extractKoboFields'; export * from './getFieldType'; // === RECORDS === diff --git a/src/utils/form/kobo/commonProperties.ts b/src/utils/form/kobo/commonProperties.ts new file mode 100644 index 000000000..db2fc1004 --- /dev/null +++ b/src/utils/form/kobo/commonProperties.ts @@ -0,0 +1,57 @@ +import { mapKoboExpression } from './mapKoboExpression'; + +/** + * Extract from a Kobo question the constraint properties and return the validators property for an SurveyJS question + * + * @param question Kobo question object + * @returns validators property for an SurveyJS question + */ +const validators = (question: any) => { + return { + validators: [ + { + type: 'expression', + text: question.constraint_message + ? typeof question.constraint_message === 'string' + ? question.constraint_message + : question.constraint_message[0] + : '', + expression: mapKoboExpression(question.constraint, question.$autoname), + }, + ], + validateOnValueChange: true, + }; +}; + +/** + * Extract from a Kobo question the common properties in a object for a SurveyJS question + * + * @param index index/order of the element inside the Kobo structure + * @param question Kobo question object + * @param type type of the questions + * @param title optional title + * @returns the common properties in a object for a SurveyJS question extracted from the Kobo question + */ +export const commonProperties = ( + index: number, + question: any, + type: string, + title?: string +) => { + return { + index, + type, + name: question.$autoname, + title: title ?? (question.label ? question.label[0] : question.$autoname), + valueName: question.$autoname, + isRequired: question.required, + ...(question.hint && { description: question.hint[0] }), + ...(question.default && { + defaultValue: mapKoboExpression(question.default), + }), + ...(question.relevant && { + visibleIf: mapKoboExpression(question.relevant), + }), + ...(question.constraint && validators(question)), + }; +}; diff --git a/src/utils/form/kobo/mapKoboExpression.ts b/src/utils/form/kobo/mapKoboExpression.ts new file mode 100644 index 000000000..9fc06acfb --- /dev/null +++ b/src/utils/form/kobo/mapKoboExpression.ts @@ -0,0 +1,131 @@ +/** + * Maps expressions from kobo questions to a expression format that will work on the SurveyJS. + * + * The numeric operators (Greater than >, Less than <, Greater than or equal to >=, Less than or equal to <=) are used the in same way in Kobo and SurveyJS. + * + * @param koboExpression the initial kobo logic expression + * @param questionName name of the question to replace in the expression + * @param choiceValue value of the choice to replace in the expression + * @returns the mapped logic expression that will work on the SurveyJS form + */ +export const mapKoboExpression = ( + koboExpression: string, + questionName?: string, + choiceValue?: string +) => { + // Replace 'name' with choiceValue in selected expressions (for choice_filter on select questions) + if (choiceValue) { + koboExpression = koboExpression.replace( + /selected\(\$\{(\w+)\}, name\)/g, + `selected(\$\{$1\}, ${choiceValue})` + ); + // If in the Kobo form the choice has a other property, we will remove the 'or other=0' from the choice visibleIf + koboExpression = koboExpression.replace(/or other=0/g, ''); + } + // Replace . with {questionName} + if (questionName) { + // Expressions in Kobo can have ' . ' to indicate that the expression is about the question in which it is defined. + // Example: a Validation Criteria can be ". > 5 ": the value of the question itself must be greater than 5 + koboExpression = koboExpression.replace(/\./g, `{${questionName}}`); + } + // Not contains + koboExpression = koboExpression.replace( + /not\(selected\(\$\{(\w+)\}, '(.*?)'\)\)/g, + "{$1} notcontains '$2'" + ); + // Replace not(...) with !(...) + koboExpression = koboExpression.replace(/not\(/g, '!('); + // Replace mod with % + koboExpression = koboExpression.replace( + /([^\/]*)\s+mod\s+([^\/]*)/g, + (match, before, after) => { + const transformedBefore = before.replace(/\$\{(\w+)\}/g, '{$1}'); + const transformedAfter = after.replace(/\$\{(\w+)\}/g, '{$1}'); + return `${transformedBefore} % ${transformedAfter}`; + } + ); + // Replace div with / + koboExpression = koboExpression.replace( + /([^\/]*)\s+div\s+([^\/]*)/g, + (match, before, after) => { + const transformedBefore = before.replace(/\$\{(\w+)\}/g, '{$1}'); + const transformedAfter = after.replace(/\$\{(\w+)\}/g, '{$1}'); + return `${transformedBefore} / ${transformedAfter}`; + } + ); + // Empty + koboExpression = koboExpression.replace(/\$\{(\w+)\} = ''/g, '{$1} empty'); + // Equal to + koboExpression = koboExpression.replace( + /\$\{(\w+)\} = '(.*?)'/g, + "({$1} = '$2')" + ); + // No empty + koboExpression = koboExpression.replace( + /\$\{(\w+)\} != ''/g, + '{$1} notempty' + ); + // Not equal to + koboExpression = koboExpression.replace( + /\$\{(\w+)\} != '(.*?)'/g, + "{$1} <> '$2'" + ); + // Replace ends-with with endsWith + koboExpression = koboExpression.replace(/ends-with\(/g, 'endsWith('); + // Replace indexed-repeat(...) with indexedRepeat(...) and handle the first parameter to be the question/field name and not the question value + koboExpression = koboExpression.replace( + /indexed-repeat\(\$\{(\w+)\},\s*\$\{(\w+)\},\s*(.*?)\)/g, + 'indexedRepeat($1, {$2}, $3)' + ); + // Replace sum(...) with sumElements(...) and handle the parameter (from question reference to question name only) + koboExpression = koboExpression.replace( + /sum\(\$\{(\w+)\}\)/g, + 'sumElements($1)' + ); + // Replace max(...) with maxElements(...) and handle the parameter (from question reference to question name only) + koboExpression = koboExpression.replace( + /max\(\$\{(\w+)\}\)/g, + 'maxElements($1)' + ); + // Replace min(...) with minElements(...) and handle the parameter (from question reference to question name only) + koboExpression = koboExpression.replace( + /min\(\$\{(\w+)\}\)/g, + 'minElements($1)' + ); + // Replace join(' ', ${...}) with join(' ', ...) (handle the parameter, replacing the question reference for a question name only) + koboExpression = koboExpression.replace( + /join\(\s*'([^']*)'\s*,\s*\$\{(\w+)\}\s*\)/g, + "join('$1', $2)" + ); + // Replace position(..) with {panelIndex} + koboExpression = koboExpression.replace(/position\(\.\.\)/g, '{panelIndex}'); + // Replace count-selected with length + koboExpression = koboExpression.replace(/count-selected\(/g, 'length('); + // Replace of format-date-time with formatDateTime + koboExpression = koboExpression.replace( + /format-date-time\(/g, + 'formatDateTime(' + ); + // Replace if with iif + koboExpression = koboExpression.replace(/if\(/g, 'iif('); + // TODO: FIX not working with expressions like if(${number1} + ${number2} > 10,45,30) + today() + // For calculations with today() + or - days, add addDays() custom function to work on oort + koboExpression = koboExpression.replace( + /today\(\)\s*([\+\-])\s*(\w+)/g, + (match, operator, term) => { + const transformedTerm = term.replace(/\$\{(\w+)\}/g, '{$1}'); + if (operator === '+') { + return `addDays(today(), ${transformedTerm})`; + } else { + return `addDays(today(), -${transformedTerm})`; + } + } + ); + // Replace now() with currentDate() + koboExpression = koboExpression.replace(/now\(\)/g, 'currentDate()'); + // Date values + koboExpression = koboExpression.replace(/date\('(.*?)'\)/g, "'$1'"); + // Replace any remaining ${variable} to {variable} + koboExpression = koboExpression.replace(/\$\{(\w+)\}/g, '{$1}'); + return koboExpression; +}; diff --git a/src/utils/proxy/authManagement.ts b/src/utils/proxy/authManagement.ts index 386935ff6..432507985 100644 --- a/src/utils/proxy/authManagement.ts +++ b/src/utils/proxy/authManagement.ts @@ -99,7 +99,7 @@ export const getToken = async ( } if (apiConfiguration.authType === authType.userToService) { // Retrieve access token from settings, store it and return it - const settings: { token: string } = ping + const settings: { token: string; tokenPrefix: string } = ping ? apiConfiguration.settings : JSON.parse( CryptoJS.AES.decrypt( @@ -107,8 +107,12 @@ export const getToken = async ( config.get('encryption.key') ).toString(CryptoJS.enc.Utf8) ); - cache.set(tokenID, settings.token, 3570); - return settings.token; + const token = + (settings.tokenPrefix ? settings.tokenPrefix : 'Bearer') + + ' ' + + settings.token; + cache.set(tokenID, token, 3570); + return token; } if (apiConfiguration.authType === authType.authorizationCode) { // Making sure to return only string, as access token is typed string | string[]