Merge pull request #29 from UN-OCHA/HPC-8205-models-2

czmj · web-flow · commit 620331c4aefe · 2021-11-02T15:24:01.000Z
🎨 Migrate tables needed for HPC-8205
diff --git a/src/db/index.ts b/src/db/index.ts
@@ -1,40 +1,60 @@
 import Knex = require('knex');
 import attachment from './models/attachment';
+import attachmentPrototype from './models/attachmentPrototype';
 import attachmentVersion from './models/attachmentVersion';
 import authGrant from './models/authGrant';
 import authGrantee from './models/authGrantee';
 import authGrantLog from './models/authGrantLog';
 import authInvite from './models/authInvite';
 import authTarget from './models/authTarget';
 import authToken from './models/authToken';
+import entitiesAssociation from './models/entitiesAssociation';
+import entityPrototype from './models/entityPrototype';
 import expiredData from './models/expiredData';
 import form from './models/form';
 import governingEntity from './models/governingEntity';
+import governingEntityVersion from './models/governingEntityVersion';
 import operation from './models/operation';
 import operationCluster from './models/operationCluster';
 import participant from './models/participant';
+import project from './models/project';
+import plan from './models/plan';
+import planEntity from './models/planEntity';
+import planEntityVersion from './models/planEntityVersion';
 import projectVersion from './models/projectVersion';
+import projectVersionAttachment from './models/projectVersionAttachment';
 import projectVersionPlan from './models/projectVersionPlan';
 import reportingWindow from './models/reportingWindow';
 import reportingWindowAssignment from './models/reportingWindowAssignment';
+import workflowStatusOption from './models/workflowStatusOption';
 
 export default (conn: Knex) => ({
   attachment: attachment(conn),
+  attachmentPrototype: attachmentPrototype(conn),
   attachmentVersion: attachmentVersion(conn),
   authGrant: authGrant(conn),
   authGrantee: authGrantee(conn),
   authGrantLog: authGrantLog(conn),
   authInvite: authInvite(conn),
   authTarget: authTarget(conn),
   authToken: authToken(conn),
+  entitiesAssociation: entitiesAssociation(conn),
+  entityPrototype: entityPrototype(conn),
   expiredData: expiredData(conn),
   form: form(conn),
   governingEntity: governingEntity(conn),
+  governingEntityVersion: governingEntityVersion(conn),
   operation: operation(conn),
   operationCluster: operationCluster(conn),
   participant: participant(conn),
+  plan: plan(conn),
+  planEntity: planEntity(conn),
+  planEntityVersion: planEntityVersion(conn),
+  project: project(conn),
   projectVersion: projectVersion(conn),
+  projectVersionAttachment: projectVersionAttachment(conn),
   projectVersionPlan: projectVersionPlan(conn),
   reportingWindow: reportingWindow(conn),
   reportingWindowAssignment: reportingWindowAssignment(conn),
+  workflowStatusOption: workflowStatusOption(conn),
 });
diff --git a/src/db/models/attachmentPrototype.ts b/src/db/models/attachmentPrototype.ts
@@ -2,6 +2,8 @@ import * as t from 'io-ts';
 
 import { brandedType } from '../../util/io-ts';
 import type { Brand } from '../../util/types';
+import { defineIDModel } from '../util/id-model';
+import { PLAN_ID } from './plan';
 
 export type AttachmentPrototypeId = Brand<
   number,
@@ -13,3 +15,59 @@ export const ATTACHMENT_PROTOTYPE_ID = brandedType<
   number,
   AttachmentPrototypeId
 >(t.number);
+
+export const ATTACHMENT_TYPE = t.keyof({
+  caseLoad: null,
+  contact: null,
+  cost: null,
+  fileWebContent: null,
+  indicator: null,
+  textWebContent: null,
+});
+export type AttachmentType = t.TypeOf<typeof ATTACHMENT_TYPE>;
+
+const LOCALIZED_STRING = t.type({
+  en: t.string,
+});
+
+const FIELDS = t.array(
+  t.type({
+    name: LOCALIZED_STRING,
+    type: t.string,
+  })
+);
+
+export const ATTACHMENT_PROTOTYPE_VALUE = t.intersection([
+  // Required Fields
+  t.type({
+    hasMeasures: t.number,
+    name: LOCALIZED_STRING,
+    entities: t.array(t.string),
+  }),
+  // Optional Fields
+  t.partial({
+    measureFields: FIELDS,
+    min: t.number,
+    max: t.number,
+    metrics: FIELDS,
+  }),
+]);
+
+export default defineIDModel({
+  tableName: 'attachmentPrototype',
+  fields: {
+    generated: {
+      id: { kind: 'branded-integer', brand: ATTACHMENT_PROTOTYPE_ID },
+    },
+    optional: {
+      planId: { kind: 'branded-integer', brand: PLAN_ID },
+    },
+    accidentallyOptional: {
+      refCode: { kind: 'checked', type: t.string },
+      type: { kind: 'checked', type: ATTACHMENT_TYPE },
+      value: { kind: 'checked', type: ATTACHMENT_PROTOTYPE_VALUE },
+    },
+  },
+  idField: 'id',
+  softDeletionEnabled: false,
+});
diff --git a/src/db/models/entitiesAssociation.ts b/src/db/models/entitiesAssociation.ts
@@ -0,0 +1,17 @@
+import * as t from 'io-ts';
+import { defineSequelizeModel } from '../util/sequelize-model';
+import { GOVERNING_ENTITY_ID } from './governingEntity';
+import { PLAN_ENTITY_ID } from './planEntity';
+
+export default defineSequelizeModel({
+  tableName: 'entitiesAssociation',
+  fields: {
+    required: {
+      parentId: { kind: 'branded-integer', brand: GOVERNING_ENTITY_ID },
+      parentType: { kind: 'checked', type: t.literal('governingEntity') },
+      childId: { kind: 'branded-integer', brand: PLAN_ENTITY_ID },
+      childType: { kind: 'checked', type: t.literal('planEntity') },
+    },
+  },
+  softDeletionEnabled: false,
+});
diff --git a/src/db/models/entityPrototype.ts b/src/db/models/entityPrototype.ts
@@ -2,6 +2,9 @@ import * as t from 'io-ts';
 
 import { brandedType } from '../../util/io-ts';
 import { Brand } from '../../util/types';
+import { defineIDModel } from '../util/id-model';
+
+import { PLAN_ID } from './plan';
 
 export type EntityPrototypeId = Brand<
   number,
@@ -12,3 +15,43 @@ export type EntityPrototypeId = Brand<
 export const ENTITY_PROTOTYPE_ID = brandedType<number, EntityPrototypeId>(
   t.number
 );
+
+export const ENTITY_PROTOTYPE_REF_CODE = t.keyof({
+  CA: null,
+  CL: null,
+  CO: null,
+  CQ: null,
+  CSO: null,
+  IO: null,
+  OC: null,
+  OP: null,
+  OUT: null,
+  SO: null,
+  SP: null,
+  SSO: null,
+});
+
+export type EntityPrototypeRefCode = t.TypeOf<typeof ENTITY_PROTOTYPE_REF_CODE>;
+
+export const ENTITY_PROTOTYPE_TYPE = t.keyof({
+  GVE: null,
+  PE: null,
+});
+
+export default defineIDModel({
+  tableName: 'entityPrototype',
+  fields: {
+    generated: {
+      id: { kind: 'branded-integer', brand: ENTITY_PROTOTYPE_ID },
+    },
+    accidentallyOptional: {
+      refCode: { kind: 'checked', type: ENTITY_PROTOTYPE_REF_CODE },
+      type: { kind: 'checked', type: ENTITY_PROTOTYPE_TYPE },
+      planId: { kind: 'checked', type: PLAN_ID },
+      orderNumber: { kind: 'checked', type: t.number },
+      value: { kind: 'checked', type: t.unknown },
+    },
+  },
+  idField: 'id',
+  softDeletionEnabled: false,
+});
diff --git a/src/db/models/governingEntityVersion.ts b/src/db/models/governingEntityVersion.ts
@@ -2,6 +2,8 @@ import * as t from 'io-ts';
 
 import { brandedType } from '../../util/io-ts';
 import type { Brand } from '../../util/types';
+import { defineLegacyVersionedModel } from '../util/legacy-versioned-model';
+import { GOVERNING_ENTITY_ID } from './governingEntity';
 
 export type GoverningEntityVersionId = Brand<
   number,
@@ -13,3 +15,33 @@ export const GOVERNING_ENTITY_VERSION_ID = brandedType<
   number,
   GoverningEntityVersionId
 >(t.number);
+
+export default defineLegacyVersionedModel({
+  tableName: 'governingEntityVersion',
+  fields: {
+    generated: {
+      id: {
+        kind: 'branded-integer',
+        brand: GOVERNING_ENTITY_VERSION_ID,
+      },
+    },
+    accidentallyOptional: {
+      governingEntityId: {
+        kind: 'branded-integer',
+        brand: GOVERNING_ENTITY_ID,
+      },
+      name: { kind: 'checked', type: t.string },
+      customReference: { kind: 'checked', type: t.string },
+      value: { kind: 'checked', type: t.unknown },
+      tags: { kind: 'checked', type: t.array(t.string) },
+    },
+    required: {
+      overriding: {
+        kind: 'checked',
+        type: t.boolean,
+      },
+    },
+  },
+  idField: 'id',
+  softDeletionEnabled: false,
+});
diff --git a/src/db/models/plan.ts b/src/db/models/plan.ts
@@ -2,7 +2,32 @@ import * as t from 'io-ts';
 
 import { brandedType } from '../../util/io-ts';
 import { Brand } from '../../util/types';
+import { defineIDModel } from '../util/id-model';
 
 export type PlanId = Brand<number, { readonly s: unique symbol }, 'plan.id'>;
 
 export const PLAN_ID = brandedType<number, PlanId>(t.number);
+
+const PLAN_REVISION_STATE = t.keyof({
+  projectsOnly: null,
+  none: null,
+  planDataAndProjects: null,
+  planDataOnly: null,
+});
+
+export default defineIDModel({
+  tableName: 'plan',
+  fields: {
+    generated: {
+      id: { kind: 'branded-integer', brand: PLAN_ID },
+    },
+    optional: {
+      revisionState: { kind: 'checked', type: PLAN_REVISION_STATE },
+    },
+    accidentallyOptional: {
+      restricted: { kind: 'checked', type: t.boolean },
+    },
+  },
+  idField: 'id',
+  softDeletionEnabled: false,
+});
diff --git a/src/db/models/planEntity.ts b/src/db/models/planEntity.ts
@@ -2,6 +2,9 @@ import * as t from 'io-ts';
 
 import { brandedType } from '../../util/io-ts';
 import type { Brand } from '../../util/types';
+import { defineLegacyVersionedModel } from '../util/legacy-versioned-model';
+import { ENTITY_PROTOTYPE_ID } from './entityPrototype';
+import { PLAN_ID } from './plan';
 
 export type PlanEntityId = Brand<
   number,
@@ -10,3 +13,23 @@ export type PlanEntityId = Brand<
 >;
 
 export const PLAN_ENTITY_ID = brandedType<number, PlanEntityId>(t.number);
+
+export default defineLegacyVersionedModel({
+  tableName: 'planEntity',
+  fields: {
+    generated: {
+      id: { kind: 'branded-integer', brand: PLAN_ENTITY_ID },
+    },
+    accidentallyOptional: {
+      planId: { kind: 'branded-integer', brand: PLAN_ID },
+    },
+    required: {
+      entityPrototypeId: {
+        kind: 'branded-integer',
+        brand: ENTITY_PROTOTYPE_ID,
+      },
+    },
+  },
+  idField: 'id',
+  softDeletionEnabled: true,
+});
diff --git a/src/db/models/planEntityVersion.ts b/src/db/models/planEntityVersion.ts
@@ -2,6 +2,9 @@ import * as t from 'io-ts';
 
 import { brandedType } from '../../util/io-ts';
 import type { Brand } from '../../util/types';
+import { defineLegacyVersionedModel } from '../util/legacy-versioned-model';
+import { ENTITY_PROTOTYPE_ID } from './entityPrototype';
+import { PLAN_ENTITY_ID } from './planEntity';
 
 export type PlanEntityVersionId = Brand<
   number,
@@ -12,3 +15,41 @@ export type PlanEntityVersionId = Brand<
 export const PLAN_ENTITY_VERSION_ID = brandedType<number, PlanEntityVersionId>(
   t.number
 );
+
+export const PLAN_ENTITY_VERSION_VALUE = t.type({
+  categories: t.array(t.unknown),
+  description: t.string,
+  support: t.array(
+    t.intersection([
+      t.type({
+        planEntityIds: t.array(PLAN_ENTITY_ID),
+      }),
+      t.partial({
+        entityPrototypeId: ENTITY_PROTOTYPE_ID,
+      }),
+    ])
+  ),
+  type: t.type({
+    en: t.type({
+      singular: t.string,
+      plural: t.string,
+    }),
+  }),
+});
+export type PlanEntityVersionValue = t.TypeOf<typeof PLAN_ENTITY_VERSION_VALUE>;
+
+export default defineLegacyVersionedModel({
+  tableName: 'planEntityVersion',
+  fields: {
+    generated: {
+      id: { kind: 'branded-integer', brand: PLAN_ENTITY_VERSION_ID },
+    },
+    accidentallyOptional: {
+      planEntityId: { kind: 'branded-integer', brand: PLAN_ENTITY_ID },
+      customReference: { kind: 'checked', type: t.string },
+      value: { kind: 'checked', type: PLAN_ENTITY_VERSION_VALUE },
+    },
+  },
+  idField: 'id',
+  softDeletionEnabled: false,
+});
diff --git a/src/db/models/project.ts b/src/db/models/project.ts
diff --git a/src/db/models/projectVersion.ts b/src/db/models/projectVersion.ts
diff --git a/src/db/models/projectVersionAttachment.ts b/src/db/models/projectVersionAttachment.ts
diff --git a/src/db/models/workflowStatusOption.ts b/src/db/models/workflowStatusOption.ts
