feat/HIT-43_integrate_kobo_in_oort

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."
 				}
 			},

src/i18n/test.json

@@ -128,6 +128,7 @@
 		"form": {
 			"add": {
 				"errors": {
+					"koboForm": "******",
 					"resourceDuplicated": "******"
 				}
 			},

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,

src/schema/mutation/addForm.mutation.ts

@@ -5,20 +5,38 @@ 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';
 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,77 @@ 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;
+
+          // 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],
+          });
+          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