iworks-core-api/src/material/materialRepository.ts

iwroks server api module

import * as uuid from 'node-uuid';
import { transaction, Transaction } from 'objection';

import { Material, MaterialType } from 'iworks-db-model';
import {
  IMaterial,
  IMaterialDb,
  ISelectMaterial,
  ISelectMaterialType,
} from '../model/material';

import {
  getIdFromSelector,
} from '../materialType/materialTypeRepository';

async function convertTypeToId(materialType: ISelectMaterialType) : Promise<string> {
  return await getIdFromSelector(materialType)
                .then((id : string | null) => {
                  if (id) return id;
                  const errMes =
                    `No material type: {id: ${materialType.id}, code: ${materialType.code}}`;
                  throw Error(errMes);
                });
}

async function convertToMaterialDb(material : Partial<IMaterial>,
                                   materialType: ISelectMaterialType | undefined)
                                      : Promise<IMaterialDb> {
  const materialDb = Object.assign<any, IMaterialDb>({}, <IMaterialDb>material);

  if (materialType) {
    materialDb.materialTypeId = await convertTypeToId(materialType);
  }

  return materialDb;
}

async function newMaterialDb(material : Partial<IMaterial>,
                             materialType: ISelectMaterialType) : Promise<IMaterialDb> {
  return convertToMaterialDb(material, materialType)
    .then((materialDb: IMaterialDb) => {
      materialDb.id = uuid.v4();
      const date = (new Date()).toISOString();
      materialDb.created = date;
      materialDb.updated = date;
      materialDb.status = 'active';

      return materialDb;
    });
}

function updateMaterialDb(material : Partial<IMaterial>,
                          materialType: ISelectMaterialType | undefined) : Promise<IMaterialDb> {
  return convertToMaterialDb(material, materialType)
          .then((materialDb : IMaterialDb) => {
            const date = (new Date()).toISOString();
            materialDb.updated = date;

            return materialDb;
          });
}

export async function createMaterial(material: Partial<IMaterial>,
                                     materialType: ISelectMaterialType) {
  return newMaterialDb(material, materialType)
                .then((materialDb : IMaterialDb) => {
                  return Material
                          .query()
                          .eager('materialType')
                          .insertAndFetch(materialDb);
                });
}

export async function updateMaterial(selector: ISelectMaterial,
                                     material: Partial<IMaterial>,
                                     materialType: ISelectMaterialType | undefined) {
  const materialDb = await updateMaterialDb(material, materialType);

  const knex = Material.knex();

  await transaction(knex, async (trx: Transaction) => {
    const query = Material.query(trx);
    const querySelected = buildSelectMaterial(query, selector);
    await querySelected.patch(materialDb);
  });

  return buildSelectMaterial(Material.query(), selector)
          .eager('materialType')
          .then((materials : any) => {
            return materials.length > 0
                      ? materials[0]
                      : null;
          });
}

function isSelectId(materialSelect: ISelectMaterial) : boolean {
  return materialSelect.id != null &&
         materialSelect.code == null &&
         materialSelect.modificationCode == null;
}

function isSelectCode(materialSelect: ISelectMaterial): boolean {
  return materialSelect.id == null &&
    materialSelect.code != null &&
    materialSelect.modificationCode == null;
}

function isSelectModificationCode(materialSelect: ISelectMaterial): boolean {
  return materialSelect.id == null &&
    materialSelect.code == null &&
    materialSelect.modificationCode != null;
}

function buildSelectMaterial(query: any, materialSelect: ISelectMaterial) {
  if (isSelectId(materialSelect)) {
    return query.where('id', materialSelect.id);
  }
  if (isSelectCode(materialSelect)) {
    return query.where('code', materialSelect.code);
  }

  if (isSelectModificationCode(materialSelect)) {
    return query.where('modification_code', materialSelect.modificationCode);
  }

  throw new Error('Input is not specified for delete material');
}

export async function deleteMaterial(selectMaterial: ISelectMaterial) {
  return buildSelectMaterial(Material.query(), selectMaterial)
              .delete()
              .then(async (numDeleted : any) => {
                return numDeleted > 0 ? true : false;
              })
              .catch((_ : any) => false);
}

export function archivingMaterial(selectMaterial: ISelectMaterial) {
  const change = { status: 'archived' };
  return updateMaterial(selectMaterial, change, undefined);
}

export function restoreMaterial(selectMaterial: ISelectMaterial) {
  const change = { status: 'active' };
  return updateMaterial(selectMaterial, change, undefined);
}

export function getSelectorFromMaterialDTO(material: IMaterial): ISelectMaterial {
  if (material.id != null) {
    return { id: material.id, code: undefined, modificationCode: undefined };
  }

  if (material.code) {
    return { id: undefined, code: material.code, modificationCode: undefined };
  }

  if (material.modificationCode) {
    return { id: undefined, code: undefined, modificationCode: material.modificationCode };
  }

  throw Error('Can not deteriminater material');
}