openchs-models 1.31.38 → 1.31.40

package/dist/Schema.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.createTransactionDataMapForEmbeddedFields = createTransactionDataMapForEmbeddedFields;
 exports.default = void 0;
 
 var _Settings = _interopRequireDefault(require("./Settings"));
@@ -189,6 +190,8 @@ var _MigrationsHelper = _interopRequireDefault(require("./MigrationsHelper"));
 
 var _MetaDataService = _interopRequireDefault(require("./service/MetaDataService"));
 
+var _moment = _interopRequireDefault(require("moment"));
+
 function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
 
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
@@ -285,67 +288,95 @@ function shouldFlush(numberOfRecords) {
   return numberOfRecords % batchSize === batchSize - 1;
 }
 
-function migrateGeoLocation(oldDB, newDB) {
-  flush(newDB);
-  let recordCounter = 0;
-
-  _MetaDataService.default.forEachPointField((field, schemaName) => {
-    console.log(`schema: ${schemaName}, field: ${field}`);
-    newDB.objects(schemaName).forEach(newDbParentEntity => {
-      if (shouldFlush(recordCounter)) {
-        flush(newDB);
-      }
-
-      const oldFieldValue = oldDB.objects(schemaName).filtered(`uuid = "${newDbParentEntity.uuid}"`)[0][field];
+function createTransactionDataMapForEmbeddedFields() {
+  const map = new Map();
 
-      if (!_lodash.default.isNil(oldFieldValue)) {
-        newDbParentEntity[field] = {
-          x: oldFieldValue.x,
-          y: oldFieldValue.y
-        };
-      }
+  _MetaDataService.default.forEachPointField((fieldName, schemaName) => {
+    if (map.has(schemaName)) {
+      map.get(schemaName).push({
+        fieldName,
+        fieldType: "Point"
+      });
+    } else {
+      map.set(schemaName, [{
+        fieldName,
+        fieldType: "Point"
+      }]);
+    }
+  });
 
-      recordCounter++;
-    });
+  _MetaDataService.default.forEachObservationField((fieldName, schemaName) => {
+    if (map.has(schemaName)) {
+      map.get(schemaName).push({
+        fieldName,
+        fieldType: "Obs"
+      });
+    } else {
+      map.set(schemaName, [{
+        fieldName,
+        fieldType: "Obs"
+      }]);
+    }
   });
 
-  flush(newDB);
-  newDB.deleteModel("Point");
+  return map;
 }
 
-function migrateObservationsToEmbedded(oldDB, newDB) {
+function migrateAllEmbeddedForTxnData(oldDB, newDB) {
+  const startTime = new Date();
   flush(newDB);
+  const map = createTransactionDataMapForEmbeddedFields();
   let recordCounter = 0;
-
-  _MetaDataService.default.forEachObservationField((observationField, schemaName) => {
-    console.log(`schema: ${schemaName}, field: ${observationField}`);
+  const conceptMap = new Map();
+  map.forEach((fields, schemaName) => {
+    console.log(`schema: ${schemaName}, fields: ${fields.length}`);
     newDB.objects(schemaName).forEach(newDbParentEntity => {
       if (shouldFlush(recordCounter)) {
         flush(newDB);
       }
 
-      const newList = [];
-      const oldFieldValues = oldDB.objects(schemaName).filtered(`uuid = "${newDbParentEntity.uuid}"`)[0][observationField];
-      oldFieldValues.forEach(oldFieldValue => {
-        const newConcept = newDB.objects("Concept").filtered(`uuid = "${oldFieldValue.concept.uuid}"`)[0];
-        newList.push({
-          concept: newConcept,
-          valueJSON: oldFieldValue.valueJSON
-        });
+      fields.forEach(field => {
+        const oldEntity = oldDB.objects(schemaName).filtered(`uuid = "${newDbParentEntity.uuid}"`)[0];
+        const oldValue = oldEntity[field.fieldName];
+
+        if (!_lodash.default.isNil(oldValue)) {
+          if (field.fieldType === "Point") newDbParentEntity[field.fieldName] = {
+            x: oldValue.x,
+            y: oldValue.y
+          };else {
+            const newObsList = [];
+            oldValue.forEach(oldItemValue => {
+              let newConcept = conceptMap.get(oldItemValue.concept.uuid);
+
+              if (_lodash.default.isNil(newConcept)) {
+                newConcept = newDB.objects("Concept").filtered(`uuid = "${oldItemValue.concept.uuid}"`)[0];
+                conceptMap.set(oldItemValue.concept.uuid, newConcept);
+              }
+
+              newObsList.push({
+                concept: newConcept,
+                valueJSON: oldItemValue.valueJSON
+              });
+            });
+            newDbParentEntity[field.fieldName] = newObsList;
+          }
+        }
       });
-      newDbParentEntity[observationField] = newList;
       recordCounter++;
     });
   });
-
   flush(newDB);
+  newDB.deleteModel("Point");
   newDB.deleteModel("Observation");
+  const endTime = new Date();
+  const diff = (0, _moment.default)(endTime).diff(startTime, "seconds", true);
+  console.log("Total Time Taken", diff, "seconds");
 }
 
 function createRealmConfig() {
   return {
     //order is important, should be arranged according to the dependency
-    schemaVersion: 186,
+    schemaVersion: 185,
     onMigration: function (oldDB, newDB) {
       console.log("[AvniModels.Schema]", `Running migration with old schema version: ${oldDB.schemaVersion} and new schema version: ${newDB.schemaVersion}`);
 
@@ -959,11 +990,7 @@ function createRealmConfig() {
       }
 
       if (oldDB.schemaVersion < 185) {
-        migrateGeoLocation(oldDB, newDB);
-      }
-
-      if (oldDB.schemaVersion < 186) {
-        migrateObservationsToEmbedded(oldDB, newDB);
+        migrateAllEmbeddedForTxnData(oldDB, newDB);
       }
     }
   };

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "openchs-models",
     "description": "OpenCHS data model to be used by front end clients",
-    "version": "1.31.38",
+    "version": "1.31.40",
     "private": false,
     "repository": {
         "type": "git",