thenable.js

'use strict';
var models = require('../models');
const WorkOrder = models.fm_work_order;
const WorkOrderDetail = models.fm_work_order_detail;
const Sequence = models.md_sequence;
var Vehicle = models.fm_vehicle;
var Company = models.md_company;
var Branch = models.fn_branch;
const WorkOrderType = models.fm_workordertype;
var Schedule = models.fm_vehicle_schedule;
const VehicleHistory = models.fm_vehicle_history;
var Request = models.fm_request;
var sequelize = models.sequelize;
var Vendor = models.customer;
var logger = require('../services/logger');
var errorCode = require('../common/errorCode');
var response = require('../common/respone');
var message = require('../common/message');
var utils = require('../common/utils');
const fs = require('fs');
const _ = require('lodash');
const validator = require('validator');
const patternDate = /^([0-9]{1,2})\/([0-9]{1,2})\/([0-9]{4})$/;
const patternTime = /^([0-1]?[0-9]|2[0-4]):([0-5][0-9])(:[0-5][0-9])$/;
const Customer = models.customer;
const Tax = models.tax;
const ServiceItem = models.fm_service_item;
const Op = sequelize.Op;
const moment = require('moment');
var obj = {};
var path = require('path');
const TYPE = {
  DETAIL: 1,
  RECEIVED: 2
};
module.exports = {
  importWOInsurance: (req, res) => {
    logger.info('Work Order controller add(confirm import work order)');
    if (!req.body) {
      const obj = response(
        errorCode.BAD_REQUEST,
        message.BAD_REQUEST,
        null,
        null
      );
      return res.send(obj);
    }
    let data = req.body;
    _.each(data, item => {
      if (item.err) {
        return res.send(
          response(errorCode.BAD_REQUEST, message.BAD_REQUEST, null, null)
        );
      }
    });
    // if item already exist remove it
    let keyImportsToDeletes = new Array();
    _.each(data, item => {
      item.keyImport = `${item.workOrderDate}${item.plateNo}1${
        item.vendorCode
        } `;
      keyImportsToDeletes.push(item.keyImport);
    });

    sequelize.transaction().then(t => {
      let nextValue, currentValue;
      //1
      WorkOrder.update(
        {
          isDeleted: 1
        },
        {
          where: {
            keyImport: {
              [Op.in]: keyImportsToDeletes
            }
          },
          transaction: t
        }
      )
        .then(updatedCandidate => {
          if (updatedCandidate) {
            return Sequence.findOne({
              where: {
                code: 'WO'
              },
              transaction: t
            });
          }
        })
        .then(result => {
          if (result) {
            currentValue = result.currentValue;
            nextValue = parseInt(currentValue) + data.length;
            return Sequence.update(
              {
                currentValue: nextValue
              },
              {
                where: {
                  code: 'WO'
                },
                transaction: t
              }
            );
          }
        })
        .then(updateSuccess => {
          if (updateSuccess) {
            return Vehicle.findAll({
              where: {
                isDeleted: 0
              },
              attributes: ['id', 'plateNo'],
              transaction: t
            });
          }
        })
        .then(resVehicles => {
          if (resVehicles) {
            let runner = 1,
              workOrderIndex;
            _.each(data, item => {
              workOrderIndex = currentValue + runner;
              item.keyImport = `${item.workOrderDate}${item.plateNo}1${
                item.vendorCode
                } `;
              let branchCodeInsertToWONo = '';
              if (item.branchCode.length > 2) {
                branchCodeInsertToWONo = item.branchCode.substring(0, 2);
              } else {
                branchCodeInsertToWONo = item.branchCode;
              }
              let numberPart = _.repeat("0", 6 - workOrderIndex.toString().length);
              item.workOrderNo = `WO` + branchCodeInsertToWONo + numberPart + workOrderIndex;
              item.workOrderDate = reformatDate(item.workOrderDate);
              item.workOrderTime = moment().format('HH:mm');
              item.completionDate = reformatDate(item.workOrderDate);
              item.completionTime = moment().format('HH:mm');
              item.invoiceDate = reformatDate(item.invoiceDate);
              item.startDate = reformatDate(item.startDate);
              item.endDate = reformatDate(item.endDate);
              item.createdDate = new Date().toISOString();
              item.date = new Date().toISOString();
              item.cost = item.subTotalAmount;
              item.modifiedDate = new Date().toISOString();
              item.type = 1; //insert into wo_detail table, we will insert 2 record with types are : 1 and 2
              item.status = 3; //means complated
              let relatedVehicle = _.find(resVehicles, vehicle => {
                return vehicle.plateNo === item.plateNo;
              });
              if (relatedVehicle) {
                item.vehicleId = relatedVehicle.id;
              }

              runner++;
            });
            let hihi = data;
            return WorkOrder.bulkCreate(data, {
              transaction: t
            });
          }
        })
        .then(createdWOs => {
          if (createdWOs) {
            let runnerWO = 0;
            _.each(data, item => {
              item.workOrderId = createdWOs[runnerWO].id;
              item.remark = item.remarkDetail;
              runnerWO++;
            });
            let createWODetailType1Promise = WorkOrderDetail.bulkCreate(data, {
              transaction: t
            });
            let dataCreateWoType2 = _.cloneDeep(data);
            _.each(dataCreateWoType2, item => {
              item.type = 2;
              item.remark = item.remarkDetail;
            });
            let createWODetailType2Promise = WorkOrderDetail.bulkCreate(
              dataCreateWoType2,
              {
                transaction: t
              }
            );
            let createVHDPromise = VehicleHistory.bulkCreate(data, {
              transaction: t
            });
            return Promise.all([
              createWODetailType1Promise,
              createWODetailType2Promise,
              createVHDPromise
            ]);
          }
        })
        .then(creatatedWODetail => {
          if (creatatedWODetail) {
            t.commit();
            return res.send(
              response(errorCode.SUCCESS, message.SUCCESS, null, null)
            );
          }
        })
        .catch(err => {
          t.rollback();
        });
    });
  },

  download_template: (req, res) => {
    var filePath = path.resolve(__dirname, '../../file/import-Insurances-template.xlsx');
    if (fs.existsSync(filePath)) {
      res.setHeader(
        "Content-disposition",
        "attachment; filename=import-Insurances-template.xlsx"
      );
      res.setHeader("Content-type", "application/vnd.ms-excel");
      var filestream = fs.createReadStream(filePath);
      filestream.pipe(res);
    } else {
      logger.error("file template doesn't existed");
      return res.send(
        respone(errorCode.SERVER_ERROR, message.SERVER_ERROR, null, 'File template doesn\'t existed')
      );
    }
  },
  view: (req, res) => {
    logger.info('import Work Order controller view');
    if (!req.body) {
      const obj = respone(
        errorCode.BAD_REQUEST,
        message.BAD_REQUEST,
        null,
        null
      );
      return res.send(obj);
    }
    const data = req.body;
    _.each(data, (item, index) => {
      let err = '';
      if (
        !item.workOrderDate ||
        !moment(item.workOrderDate, 'DD/MM/YYYY', true).isValid()
      ) {
        err += ', Work Order Date is in wrong format';
      }
      if (!item.plateNo || item.plateNo.length > 30) {
        err += ', Plate No is invalid';
      }
      if (
        !item.invoiceDate ||
        !moment(item.invoiceDate, 'DD/MM/YYYY', true).isValid()
      ) {
        err += ', Invoice Date is in wrong format';
      }
      if (!item.invoiceNo || item.invoiceNo.length > 10) {
        err += ', Invoice No is invalid';
      }
      if (
        !item.startDate ||
        !moment(item.startDate, 'DD/MM/YYYY', true).isValid()
      ) {
        err += ', Effective Date is in wrong format';
      }
      if (
        !item.endDate ||
        !moment(item.endDate, 'DD/MM/YYYY', true).isValid()
      ) {
        err += ', Expired Date is in wrong format';
      } else {
        if (
          moment(item.startDate, 'DD/MM/YYYY').isAfter(moment(item.endDate, 'DD/MM/YYYY'))
        ) {
          err += ', Effective date was greater Expired date';
        }
      }

      if (!item.vendorCode || item.vendorCode.length > 10) {
        err += ', Vendor Code is invalid';
      }
      if (!item.serviceItemName || item.serviceItemName.length > 50) {
        err += ', Service Item Name is invalid';
      }
      if (
        !item.amount ||
        !validator.isDecimal(item.amount) ||
        item.amount.length > 18
      ) {
        err += ', Amount is invalid';
      }
      item.err = err;
      item.quantity = 1;
      item.discount = 0;
      item.workOrderType = 'WT04 - Insurance';

      getTaxCodeByServiceName(item.serviceItemName)
        .then(result => {
          if (result != null) {
            const taxRate = result.rate,
              taxCode = result.code;
            if (item.amount) {
              let unit_price = item.amount / (1 + taxRate / 100);
              unit_price = unit_price.toFixed(2);
              let subTotalAmount = item.quantity * unit_price - item.discount;
              let gstAmount = (item.amount - subTotalAmount).toFixed(2);
              item.gstAmount = gstAmount;
              item.subTotalAmount = subTotalAmount;
              item.totalAmount = item.amount;
              item.unitPrice = unit_price;
              item.taxRate = taxRate;
              item.taxCode = taxCode;
            }
          } else {
            item.err += ``;
          }
          return Vehicle.findOne({
            attributes: ['branchId', 'plateNo'],
            where: {
              isDeleted: 0,
              plateNo: {
                [Op.eq]: item.plateNo
              },
              branchId: {
                [Op.eq]: item.branchId
              }
            }
          });
        })
        .then(foundVehicle => {
          //Plate No
          if (foundVehicle === null) {
            item.err += `, Plate No does not belong to current branch: ${
              item.branchCode
              }`;
          }
          return isInvoiceNoExisted(item.invoiceNo);
        })
        .then(count => {
          if (count > 0) {
            item.err += ', Invoice No existed';
          }
          return Customer.findOne({
            where: {
              is_active: 1,
              code: {
                [Op.eq]: item.vendorCode
              }
            },
            attributes: ['id', 'code', 'name']
          });
        })
        .then(result => {
          //Vendor
          if (result) {
            item.vendorCode = result.code;
            item.vendorId = result.id;
            item.vendorName = result.name;
          } else {
            item.err += `, Vendor code does not exist in system`;
          }
          return ServiceItem.findOne({
            where: {
              isDeleted: false,
              name: {
                [Op.eq]: item.serviceItemName
              }
            },
            attributes: ['id', 'code', 'name']
          });
        })
        .then(result => {
          if (result) {
            item.serviceItemId = result.id;
            item.serviceItemCode = result.code;
            item.serviceItemName = result.name;
          } else {
            item.err += `, Service name does not exist in system`;
          }
          return WorkOrderType.findOne({
            where: {
              isDeleted: 0,
              description: {
                [Op.like]: '%Insurance%'
              }
            },
            attributes: ['id']
          });
        })
        .then(result => {
          if (result) {
            item.workOrderTypeId = result.id;
          } else {
            item.err += `, Work Order Type doesn't exist`;
          }
          if (item.err.length > 2) {
            item.err = item.err.substring(2);
          }
          if (data.length - 1 === index) {
            return res.send(
              response(errorCode.SUCCESS, message.SUCCESS, data, null)
            );
          }
        })
        .catch(error => {
          logger.error('import work-order view error' + error);
          return res.send(
            response(errorCode.SERVER_ERROR, message.SERVER_ERROR, null, error)
          );
        });
    });
  }
};

function getTaxCodeByServiceName(serviceName) {
  return Tax.findOne({
    attributes: ['rate', 'code'],
    include: [
      {
        model: models.fm_service_item,
        where: {
          isDeleted: false,
          name: {
            [Op.like]: `%${serviceName}%`
          }
        },
        attributes: [],
        as: 'serviceItem'
      }
    ]
  });
}

function isInvoiceNoExisted(invoiceNo) {
  return WorkOrder.count({
    where: {
      isDeleted: 0,
      invoiceNo: {
        [Op.eq]: invoiceNo
      }
    }
  });
}

function reformatDate(dateStr) {
  let dArr;
  dArr = dateStr.split('/');
  return (dateStr = dArr[2] + '-' + dArr[1] + '-' + dArr[0]);
}