openchs-models 1.29.3 → 1.29.5

package/Makefile

@@ -27,7 +27,11 @@ copy-dist-to-avni-client:
 deploy-to-avni-client-only:
 	$(call _deploy,../avni-client/packages/openchs-android/node_modules/openchs-models)
 
+deploy-to-avni-web-only:
+	$(call _deploy,../avni-webapp/node_modules/openchs-models)
+
 deploy-to-avni-client: build deploy-to-avni-client-only
+deploy-to-avni-web: build deploy-to-avni-web-only
 
 deploy-to-avni-project: build
 	$(if $(local),$(call _deploy,$(local)/node_modules/openchs-models))

package/dist/CustomFilter.js

@@ -5,9 +5,30 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-class CustomFilter {}
+class CustomFilter {
+  static getDashboardFilterTypes() {
+    const clonedTypes = _objectSpread({}, CustomFilter.type);
+
+    delete clonedTypes.Name;
+    delete clonedTypes.Age;
+    delete clonedTypes.SearchAll;
+    return clonedTypes;
+  }
+
+  static getDashboardFilterWidgets() {
+    const cloned = _objectSpread({}, CustomFilter.widget);
+
+    delete cloned.Relative;
+    return cloned;
+  }
+
+}
 
 _defineProperty(CustomFilter, "type", {
   Name: "Name",

package/dist/application/FormMapping.js

@@ -191,6 +191,31 @@ class FormMapping extends _BaseEntity.default {
     }
   }
 
+  get programUUID() {
+    return this.entityUUID;
+  }
+
+  set programUUID(x) {
+    this.entityUUID = x;
+  }
+
+  get encounterTypeUUID() {
+    return this.observationsTypeEntityUUID;
+  }
+
+  set encounterTypeUUID(x) {
+    this.observationsTypeEntityUUID = x;
+  } // created for legacy reasons because the web app doesn't construct the domain model in the same way
+
+
+  get subjectTypeUUID() {
+    return this.subjectType.uuid;
+  }
+
+  get formType() {
+    return this.form.formType;
+  }
+
 }
 
 _defineProperty(FormMapping, "schema", {

package/dist/index.js

@@ -753,6 +753,30 @@ Object.defineProperty(exports, "getUnderlyingRealmObject", {
     return _RealmCollectionHelper.getUnderlyingRealmObject;
   }
 });
+Object.defineProperty(exports, "DashboardFilterConfig", {
+  enumerable: true,
+  get: function () {
+    return _DashboardFilterConfig.default;
+  }
+});
+Object.defineProperty(exports, "GroupSubjectTypeFilter", {
+  enumerable: true,
+  get: function () {
+    return _DashboardFilterConfig.GroupSubjectTypeFilter;
+  }
+});
+Object.defineProperty(exports, "ObservationBasedFilter", {
+  enumerable: true,
+  get: function () {
+    return _DashboardFilterConfig.ObservationBasedFilter;
+  }
+});
+Object.defineProperty(exports, "MetaDataService", {
+  enumerable: true,
+  get: function () {
+    return _MetaDataService.default;
+  }
+});
 
 var _AbstractEncounter = _interopRequireDefault(require("./AbstractEncounter"));
 
@@ -1002,4 +1026,12 @@ var _ArrayHelper = _interopRequireDefault(require("./framework/ArrayHelper"));
 
 var _RealmCollectionHelper = require("./framework/RealmCollectionHelper");
 
+var _DashboardFilterConfig = _interopRequireWildcard(require("./reports/DashboardFilterConfig"));
+
+var _MetaDataService = _interopRequireDefault(require("./service/MetaDataService"));
+
+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; }
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/dist/reports/DashboardFilter.js

@@ -54,7 +54,8 @@ _defineProperty(DashboardFilter, "schema", {
   properties: {
     uuid: "string",
     dashboard: "Dashboard",
-    filter: "string",
+    name: "string",
+    filterConfig: "string",
     voided: {
       type: "bool",
       default: false

package/dist/reports/DashboardFilterConfig.js

@@ -0,0 +1,200 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.GroupSubjectTypeFilter = exports.ObservationBasedFilter = void 0;
+
+var _CustomFilter = _interopRequireDefault(require("../CustomFilter"));
+
+var _Concept = _interopRequireDefault(require("../Concept"));
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const widgetConceptDataTypes = [_Concept.default.dataType.Date, _Concept.default.dataType.DateTime, _Concept.default.dataType.Time, _Concept.default.dataType.Numeric];
+
+class ObservationBasedFilter {
+  constructor() {
+    _defineProperty(this, "scope", void 0);
+
+    _defineProperty(this, "concept", void 0);
+
+    _defineProperty(this, "programs", void 0);
+
+    _defineProperty(this, "encounterTypes", void 0);
+
+    this.programs = [];
+    this.encounterTypes = [];
+  }
+
+  isValid() {
+    const {
+      concept,
+      programs,
+      encounterTypes
+    } = this;
+    return !_lodash.default.isNil(concept) && (!_lodash.default.isEmpty(programs) || !_lodash.default.isEmpty(encounterTypes) || this.scope === _CustomFilter.default.scope.Registration);
+  }
+
+  toServerRequest() {
+    return {
+      scope: this.scope,
+      conceptUUID: this.concept.uuid,
+      programUUIDs: this.programs.map(x => x.uuid),
+      encounterTypeUUIDs: this.encounterTypes.map(x => x.uuid)
+    };
+  }
+
+  isWidgetRequired() {
+    return widgetConceptDataTypes.includes(_lodash.default.get(this.concept, "dataType"));
+  }
+
+  setPrograms(programs) {
+    this.programs = programs;
+  }
+
+  setEncounterTypes(encounterTypes) {
+    this.encounterTypes = encounterTypes;
+  }
+
+  setScope(scope) {
+    if (this.scope !== scope) {
+      this.scope = scope;
+
+      if (!this.willObservationBeInScopeOfEncounter()) {
+        this.encounterTypes = [];
+      }
+
+      if (!this.willObservationBeInScopeOfProgramEnrolment()) {
+        this.programs = [];
+      }
+    }
+  }
+
+  willObservationBeInScopeOfProgramEnrolment() {
+    return [_CustomFilter.default.scope.ProgramEnrolment, _CustomFilter.default.scope.ProgramEncounter].includes(this.scope);
+  }
+
+  willObservationBeInScopeOfEncounter() {
+    return [_CustomFilter.default.scope.ProgramEncounter, _CustomFilter.default.scope.Encounter].includes(this.scope);
+  }
+
+}
+
+exports.ObservationBasedFilter = ObservationBasedFilter;
+
+class GroupSubjectTypeFilter {
+  constructor() {
+    _defineProperty(this, "subjectType", void 0);
+  }
+
+  isValid() {
+    return !_lodash.default.isNil(this.subjectType);
+  }
+
+  toServerRequest() {
+    return {
+      subjectTypeUUID: this.subjectType.uuid
+    };
+  }
+
+}
+
+exports.GroupSubjectTypeFilter = GroupSubjectTypeFilter;
+
+class DashboardFilterConfig {
+  constructor() {
+    _defineProperty(this, "subjectType", void 0);
+
+    _defineProperty(this, "type", void 0);
+
+    _defineProperty(this, "widget", void 0);
+
+    _defineProperty(this, "groupSubjectTypeFilter", void 0);
+
+    _defineProperty(this, "observationBasedFilter", void 0);
+  }
+
+  isConceptTypeFilter() {
+    return this.type === _CustomFilter.default.type.Concept;
+  }
+
+  isGroupSubjectTypeFilter() {
+    return this.type === _CustomFilter.default.type.GroupSubject;
+  }
+
+  isValid() {
+    const valid = !(_lodash.default.isNil(this.type) || _lodash.default.isNil(this.subjectType));
+    if (!valid) return valid;
+    if (this.isConceptTypeFilter()) return this.observationBasedFilter.isValid();else if (this.isGroupSubjectTypeFilter()) return this.groupSubjectTypeFilter.isValid();else if (this.isWidgetRequired()) return !_lodash.default.isNil(this.widget);else return true;
+  }
+
+  toServerRequest() {
+    const request = {
+      subjectTypeUUID: this.subjectType.uuid,
+      type: this.type,
+      widget: this.widget
+    };
+    if (this.isConceptTypeFilter()) request.observationBasedFilter = this.observationBasedFilter.toServerRequest();else if (this.isGroupSubjectTypeFilter()) request.groupSubjectTypeFilter = this.groupSubjectTypeFilter.toServerRequest();
+    return request;
+  }
+
+  setType(type) {
+    if (type !== this.type) {
+      this.type = type;
+      this.widget = null;
+      this.groupSubjectTypeFilter = type === _CustomFilter.default.type.GroupSubject ? new GroupSubjectTypeFilter() : null;
+      this.observationBasedFilter = type === _CustomFilter.default.type.Concept ? new ObservationBasedFilter() : null;
+    }
+  }
+
+  isWidgetRequired() {
+    const {
+      RegistrationDate,
+      EnrolmentDate,
+      ProgramEncounterDate,
+      EncounterDate
+    } = _CustomFilter.default.getDashboardFilterTypes();
+
+    return [RegistrationDate, EnrolmentDate, ProgramEncounterDate, EncounterDate].includes(this.type) || this.isConceptTypeFilter() && this.observationBasedFilter.isWidgetRequired();
+  }
+
+  setSubjectType(subjectType) {
+    if (_lodash.default.get(subjectType, "uuid") !== _lodash.default.get(this.subjectType, "uuid")) {
+      this.subjectType = subjectType;
+
+      if (!_lodash.default.isNil(this.observationBasedFilter)) {
+        this.observationBasedFilter.programs = [];
+        this.observationBasedFilter.encounterTypes = [];
+      } else if (!_lodash.default.isNil(this.groupSubjectTypeFilter)) {
+        this.groupSubjectTypeFilter.subjectType = null;
+      }
+    }
+  }
+
+  willObservationBeInScopeOfProgramEnrolment() {
+    return this.isConceptTypeFilter() && this.observationBasedFilter.willObservationBeInScopeOfProgramEnrolment();
+  }
+
+  willObservationBeInScopeOfEncounter() {
+    return this.isConceptTypeFilter() && this.observationBasedFilter.willObservationBeInScopeOfEncounter();
+  }
+
+  clone() {
+    const clone = new DashboardFilterConfig();
+    clone.type = this.type;
+    clone.subjectType = this.subjectType;
+    clone.widget = this.widget;
+    clone.groupSubjectTypeFilter = this.groupSubjectTypeFilter;
+    clone.observationBasedFilter = this.observationBasedFilter;
+    return clone;
+  }
+
+}
+
+var _default = DashboardFilterConfig;
+exports.default = _default;

package/dist/service/MetaDataService.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _openchsModels = require("openchs-models");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class MetaDataService {
+  static getProgramFormMappings(formMappings) {
+    return _lodash.default.filter(formMappings, formMapping => formMapping.formType === _openchsModels.Form.formTypes.ProgramEnrolment);
+  }
+
+  static getGeneralEncounterFormMappings(formMappings) {
+    return _lodash.default.filter(formMappings, formMapping => formMapping.formType === _openchsModels.Form.formTypes.Encounter || formMapping.formType === _openchsModels.Form.formTypes.IndividualEncounterCancellation);
+  }
+
+  static getProgramEncounterFormMappings(formMappings) {
+    return _lodash.default.filter(formMappings, formMapping => formMapping.formType === _openchsModels.Form.formTypes.ProgramEncounter || formMapping.formType === _openchsModels.Form.formTypes.ProgramEncounterCancellation);
+  }
+
+  static getProgramsForSubjectType(allPrograms, subjectType, formMappings) {
+    if (_lodash.default.isNil(subjectType)) return allPrograms;
+
+    const programFormMappingsForSubjectType = _lodash.default.filter(formMappings, formMapping => formMapping.subjectTypeUUID === subjectType.uuid && formMapping.formType === _openchsModels.Form.formTypes.ProgramEnrolment);
+
+    return _lodash.default.intersectionWith(allPrograms, programFormMappingsForSubjectType, (p, fm) => p.uuid === fm.programUUID);
+  }
+
+  static getEncounterTypesForSubjectType(allEncounterTypes, subjectType, formMappings) {
+    if (_lodash.default.isNil(subjectType)) return allEncounterTypes;
+
+    const generalEncounterFormMappingsForSubjectType = _lodash.default.filter(this.getGeneralEncounterFormMappings(formMappings), formMapping => formMapping.subjectTypeUUID === subjectType.uuid);
+
+    return generalEncounterFormMappingsForSubjectType.map(x => _lodash.default.some(allEncounterTypes, et => et.uuid === x.encounterTypeUUID));
+  }
+
+  static getEncounterTypesForPrograms(allEncounterTypes, programs, formMappings) {
+    const programEncounterTypeMappings = MetaDataService.getProgramEncounterFormMappings(formMappings);
+
+    const encounterTypeMappingsForPrograms = _lodash.default.intersectionWith(programEncounterTypeMappings, programs, (etMapping, program) => etMapping.programUUID === program.uuid);
+
+    return encounterTypeMappingsForPrograms.map(x => _lodash.default.find(allEncounterTypes, et => et.uuid === x.encounterTypeUUID));
+  }
+
+  static getEncounterTypes_For_SubjectTypeAndPrograms(allEncounterTypes, subjectType, programs, formMappings) {
+    if (_lodash.default.isEmpty(programs)) return MetaDataService.getEncounterTypesForSubjectType(allEncounterTypes, subjectType, formMappings);
+    return MetaDataService.getEncounterTypesForPrograms(allEncounterTypes, programs, formMappings);
+  }
+
+  static getPossibleGroupSubjectTypesFor(subjectTypes, subjectType) {
+    return _lodash.default.isNil(subjectType) ? _lodash.default.filter(subjectTypes, x => x.group) : _lodash.default.filter(subjectTypes, x => x.uuid !== subjectType.uuid && x.group);
+  }
+
+}
+
+var _default = MetaDataService;
+exports.default = _default;

package/package.json

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