viam-projectv-scan/src/js/checks/checkRules.js

ViaCheck deposit application

const Utilities = require('./utilities');
const MircLineRules = require('./mircLineRules');
const CheckCommonRules = require('./checkCommonRules');

const MAKER_TREASURY = 'UNITED STATES TREASURY';
const ROUTING_TREASURY = '000000518';

const createScoreFields = () => {
  const score = {
    amount: 0,
    checkNumber: 0,
    checkType: 0,
    checkDate: 0,
    mircLine: 0,
    payee: 0,
    lar: 0,
    signature: 0,
    payerFullName: 0,
    payerAddressName: 0,
    payerAddressDestination: 0,
    payerAddressZipCode: 0
  };
  return score;
};

export const getCheckScanOrder = checksArray => {
  const lengthArray = checksArray.length;
  if (lengthArray === 0) return lengthArray;

  return checksArray[lengthArray - 1].scanOrder;
};

export const createCheckImages = (order, front, back) => ({
  scanOrder: order,
  frontImage: front,
  backImage: back
});
// Create new element in checks array when a check is scanned.
export const createCheck = (order, mirc, agency, cashier) => {
  const routingFromScanner = MircLineRules.getRoutingFromScanner(mirc);
  const accountFromScanner = MircLineRules.getAcountFromScanner(mirc);
  const check = {
    scanOrder: order,
    userName: cashier,
    agencyName: agency,
    cashier: '',
    routing: routingFromScanner,
    account: accountFromScanner,
    bank: '',
    limitRoutingScore: 0,
    limitCheckNumberScore: 0,
    limitAmountScore: 0,
    limitDateScore: 0,
    accountScore: 0,
    returnedChecksMaker: 0,
    issuedChecksMaker: 0,
    checkStatus: '',
    checkNumber: '',
    checkDate: '',
    serial: '',
    tc: '',
    epc: '',
    cc: '',
    ct: '',
    returnChecks: 0,
    issueChecks: 0,
    endorsement: 'NO',
    payee: '',
    lar: '',
    amount: 0,
    signature: '',
    writeType: '',
    checkType: '',
    checkTypeDescription: '',
    payerFullName: '',
    mircLine: mirc,
    payerAddressName: '',
    payerAddressDestination: '',
    payerAddressZipCode: '',
    originalAmount: '',
    originalRouting: '',
    originalAccount: '',
    originalCheckNumber: '',
    modified: false,
    scoreFields: createScoreFields(),
    isEditing: false,
    maximumAmountPerCheck: 0,
    isOcr: false,
    isDeposited: false,
    isSentDeposit: false,
    isSentHold: false,
    isVisible: true,
    disableCell: true,
    mva: '',
    stateCode: '',
    ownLicense: '',
    selected: false,
    isVerify: false,
    colorVerify: '',
    isMakerCorrected:false,
    reprocess: false,
    isChangeValues: {
      checkDate: false,
      checkNumber: false,
      routing: false,
      account: false,
      amount: false
    },
    isModifiedFields: {
      checkDate: false,
      checkNumber: false,
      routing: false,
      account: false,
      amount: false,
      payee: false,
      maker: false
    },
    retry: 0,
    validFields: {
      account: Utilities.validateRequieredField(accountFromScanner),
      routing:
        Utilities.validateRequieredField(routingFromScanner) &&
        routingFromScanner.length === 9,
      checkNumber: false,
      amount: false,
      checkType: false,
      blockList: false,
      signature: false,
      date: false,
      isNetworkError: false,
      duplicated: false
    }
  };
  return check;
};

// const getCheckFromArray = (checksArray, scanOrder) =>
//   checksArray.filter(function getElement(check) {
//     return check.scanOrder === scanOrder;
//   });

export const updateNewChecksArray = (checksArray, receipt) => {
  const newcheckarray = [];
  let i = 1;

  checksArray.forEach(check => {
    const elementDeposited = receipt.filter(function getCheckReceipt(
      elementReceipt
    ) {
      return elementReceipt.scanOrder === check.scanOrder;
    });

    if (elementDeposited.length === 0) {
      const newCheck = check;
      newCheck.scanOrder = i;
      newCheck.isSentDeposit = false;
      newCheck.isDeposited = false;
      newcheckarray.push(newCheck);
      i += 1;
    }
  });
  return newcheckarray;
};

export const validateAmount = field => {
  let isValidValue = true;
  if (parseInt(field, 10) === 0 || field === '') {
    isValidValue = false;
  }

  return isValidValue;
};

export const validateChecks = checksArray => {
  let isValidCheck = true;

  checksArray.forEach(check => {
    const newCheck = check;
    if (
      !newCheck.validFields.account ||
      !newCheck.validFields.routing ||
      !newCheck.validFields.checkNumber ||
      !newCheck.validFields.amount ||     
      newCheck.validFields.duplicated
    ) {
      isValidCheck = false;
    }
  });

  return isValidCheck;
};

const getIsValidField = field => {
  let isValidField = false;
  if (field !== null && field !== undefined) {
    if (field.value !== null && field.value !== undefined) {
      if (
        field.value !== '' &&
        field.value !== null &&
        field.value !== undefined
      ) {
        isValidField = true;
      }
    }
  }

  return isValidField;
};

const getPayerAddressName = (ocrResponse, newElement, validateModified) => {
  let payerAddressName = '';
  if (newElement.routing === ROUTING_TREASURY) {
    payerAddressName = MAKER_TREASURY;
  } else if (
    ocrResponse.payerAddress !== null &&
    ocrResponse.payerAddress !== undefined
  ) {
    if (getIsValidField(ocrResponse.payerAddress.name)) {
      if (validateModified) {
        payerAddressName = newElement.isModifiedFields.maker
          ? newElement.payerAddressName
          : ocrResponse.payerAddress.name.value;
      } else {
        payerAddressName = ocrResponse.payerAddress.name.value;
      }
    }
  } else {
    payerAddressName = '';
  }
  return payerAddressName;
};
const getCheckType = (routing, value) => {
  return routing === ROUTING_TREASURY ? 'IRS' : value;
};

const returnChecksArrayModified = (ocrResponse, check) => {
  const newCheck = check;

  const account = getIsValidField(ocrResponse.mircLine)
    ? Utilities.replaceSpecialCharacter(
        MircLineRules.getAccountFromOcr(ocrResponse.mircLine.value)
      )
    : check.account;

  const routing = getIsValidField(ocrResponse.mircLine)
    ? Utilities.replaceSpecialCharacter(
        MircLineRules.getRoutingFromOcr(ocrResponse.mircLine.value)
      )
    : check.routing;

  let amount = 0;

  if (getIsValidField(ocrResponse.amount)) {
    amount = parseFloat(ocrResponse.amount.value.replace(',', '.')) / 100;
  }

  const checkNumber = getIsValidField(ocrResponse.checkNumber)
    ? Utilities.replaceSpecialCharacter(ocrResponse.checkNumber.value)
    : '';
  const checkDate = getIsValidField(ocrResponse.checkDate)
    ? ocrResponse.checkDate.value
    : '';

  newCheck.routing = newCheck.routing !== '' ? newCheck.routing : routing;
  newCheck.account = newCheck.account !== '' ? newCheck.account : account;

  newCheck.checkStatus = 0;
  newCheck.checkNumber =
    newCheck.checkNumber !== '' ? newCheck.checkNumber : checkNumber;
  newCheck.amount = newCheck.amount !== 0 ? newCheck.amount : amount;
  newCheck.checkDate =
    newCheck.checkDate !== '' ? newCheck.checkDate : checkDate;

  if (!newCheck.isModifiedFields.payee) {
    newCheck.payee = getIsValidField(ocrResponse.payee)
      ? ocrResponse.payee.value.replace(/ I»¿/g, '')
      : '';
  }

  newCheck.lar = getIsValidField(ocrResponse.lar) ? ocrResponse.lar.value : '';
  newCheck.signature = getIsValidField(ocrResponse.hasSignature)
    ? ocrResponse.hasSignature.value
    : '';
  newCheck.checkType = getIsValidField(ocrResponse.checkType)
    ? getCheckType(newCheck.routing, ocrResponse.checkType.value)
    : '';
  newCheck.checkTypeDescription =
    newCheck.routing === ROUTING_TREASURY ? 'IRS' : check.checkTypeDescription;
  newCheck.payerAddressName = getPayerAddressName(ocrResponse, newCheck, true);
  newCheck.writeType = getIsValidField(ocrResponse.writeType)
    ? ocrResponse.writeType.value
    : '';

  if (
    ocrResponse.payerAddress !== null &&
    ocrResponse.payerAddress !== undefined
  ) {
    newCheck.payerAddressDestination = getIsValidField(
      ocrResponse.payerAddress.destination
    )
      ? ocrResponse.payerAddress.destination.value
      : '';
    newCheck.payerAddressZipCode = getIsValidField(
      ocrResponse.payerAddress.cityZip
    )
      ? ocrResponse.payerAddress.cityZip.value
      : '';
  }
  newCheck.originalAmount = amount;
  newCheck.originalRouting = routing;
  newCheck.originalAccount = account;
  newCheck.originalCheckNumber = checkNumber;
  newCheck.modified = false;
  newCheck.isDeposited = false;
  newCheck.isSentDeposit = false;
  newCheck.validFields.signature = getIsValidField(ocrResponse.hasSignature)
    ? ocrResponse.hasSignature.value === 'true'
    : 'false';
  newCheck.selected = check.selected;

  return newCheck;
};

const getAmountField = field => {
  let amount = 0;
  if (field.value !== '') {
    amount = parseFloat(field.value.replace(',', '.')) / 100;
  } else {
    amount = parseFloat(0);
  }
  return amount;
};

const returnChecksArray = (ocrResponse, element) => {
  const newCheck = element;

  newCheck.routing = getIsValidField(ocrResponse.mircLine)
    ? Utilities.replaceSpecialCharacter(
        MircLineRules.getRoutingFromOcr(ocrResponse.mircLine.value)
      )
    : element.routing;

  newCheck.account = getIsValidField(ocrResponse.mircLine)
    ? Utilities.replaceSpecialCharacter(
        MircLineRules.getAccountFromOcr(ocrResponse.mircLine.value)
      )
    : element.account;

  newCheck.checkStatus = 0;
  newCheck.checkNumber = getIsValidField(ocrResponse.checkNumber)
    ? Utilities.replaceSpecialCharacter(ocrResponse.checkNumber.value)
    : '';

  newCheck.amount = getIsValidField(ocrResponse.amount)
    ? getAmountField(ocrResponse.amount)
    : parseFloat(0, 100);

  newCheck.checkDate = getIsValidField(ocrResponse.checkDate)
    ? ocrResponse.checkDate.value
    : '';
  newCheck.payee = getIsValidField(ocrResponse.payee)
    ? ocrResponse.payee.value.replace(/I»¿/g, '')
    : '';
  newCheck.lar = getIsValidField(ocrResponse.lar) ? ocrResponse.lar.value : '';
  newCheck.signature = getIsValidField(ocrResponse.hasSignature)
    ? ocrResponse.hasSignature.value
    : '';
  newCheck.checkType = getIsValidField(ocrResponse.checkType)
    ? getCheckType(newCheck.routing, ocrResponse.checkType.value)
    : '';
  newCheck.payerFullName = '';
  newCheck.mircLine = getIsValidField(ocrResponse.mircLine)
    ? ocrResponse.mircLine.value
    : '';
  newCheck.payerAddressName = getPayerAddressName(ocrResponse, newCheck, false);

  if (
    ocrResponse.payerAddress !== null &&
    ocrResponse.payerAddress !== undefined
  ) {
    newCheck.payerAddressDestination = getIsValidField(
      ocrResponse.payerAddress.destination
    )
      ? ocrResponse.payerAddress.destination.value
      : '';
    newCheck.payerAddressZipCode = getIsValidField(
      ocrResponse.payerAddress.cityZip
    )
      ? ocrResponse.payerAddress.cityZip.value
      : '';
  }

  newCheck.writeType = getIsValidField(ocrResponse.writeType)
    ? ocrResponse.writeType.value
    : '';
  newCheck.modified = false;
  newCheck.isDeposited = false;
  newCheck.isSentDeposit = false;
  newCheck.validFields.signature = getIsValidField(ocrResponse.hasSignature)
    ? ocrResponse.hasSignature.value === 'true'
    : 'false';
  return newCheck;
};

const returnScoreFields = ocrResponse => {
  const scoreFields = {
    amount: 0,
    checkNumber: 0,
    checkType: 0,
    checkDate: 0,
    mircLine: 0,
    payee: 0,
    lar: 0,
    signature: 0,
    payerFullName: 0,
    payerAddressName: 0,
    payerAddressDestination: 0,
    payerAddressZipCode: 0
  };

  scoreFields.mircLine = getIsValidField(ocrResponse.mircLine)
    ? Number(ocrResponse.mircLine.score)
    : 0;
  scoreFields.amount = getIsValidField(ocrResponse.amount)
    ? Number(ocrResponse.amount.score)
    : 0;
  scoreFields.checkDate = getIsValidField(ocrResponse.checkDate)
    ? Number(ocrResponse.checkDate.score)
    : 0;
  scoreFields.payee = getIsValidField(ocrResponse.payee)
    ? Number(ocrResponse.payee.score)
    : 0;
  scoreFields.checkNumber = getIsValidField(ocrResponse.checkNumber)
    ? Number(ocrResponse.checkNumber.score)
    : 0;
  scoreFields.lar = getIsValidField(ocrResponse.lar)
    ? Number(ocrResponse.lar.score)
    : 0;
  scoreFields.signature = getIsValidField(ocrResponse.hasSignature)
    ? Number(ocrResponse.hasSignature.score)
    : 0;
  scoreFields.checkType = getIsValidField(ocrResponse.checkType)
    ? Number(ocrResponse.checkType.score)
    : 0;
  scoreFields.payerFullName =
    ocrResponse.payerAddress !== null && ocrResponse.payerAddress !== ''
      ? Number(ocrResponse.payerAddress.overallScore)
      : 0;
  if (
    ocrResponse.payerAddress !== null &&
    ocrResponse.payerAddress !== undefined
  ) {
    scoreFields.payerAddressName = getIsValidField(
      ocrResponse.payerAddress.name
    )
      ? Number(ocrResponse.payerAddress.name.score)
      : 0;

    scoreFields.payerAddressDestination = getIsValidField(
      ocrResponse.payerAddress.destination
    )
      ? Number(ocrResponse.payerAddress.destination.score)
      : 0;

    scoreFields.payerAddressZipCode = getIsValidField(
      ocrResponse.payerAddress.cityZip
    )
      ? Number(ocrResponse.payerAddress.cityZip.score)
      : 0;
  }

  return scoreFields;
};

export const isItemDuplicated = (checksArray, checkValidated) => {
  let isDuplicated = false;

  for (let i = 0; i < checksArray.length; i += 1) {
    if (
      checksArray[i].scanOrder !== checkValidated.scanOrder &&
      (checksArray[i].routing === checkValidated.routing &&
        checksArray[i].account === checkValidated.account &&
        checksArray[i].checkNumber === checkValidated.checkNumber &&
        checksArray[i].amount === checkValidated.amount)
    )
      isDuplicated = true;
  }

  return isDuplicated;
};

const getCheckValidations = (checksArray, check) => {
  const validFields = {
    account: Utilities.validateRequieredField(check.account),
    routing:
      Utilities.validateRequieredField(check.routing) &&
      check.routing.length === 9,
    checkNumber: Utilities.validateRequieredField(check.checkNumber),
    blockList: check.validFields.blockList,
    checkType: check.validFields.checkType,
    amount: check.validFields.amount,
    signature: check.validFields.signature,
    date: true,
    isNetworkError: false,
    duplicated: isItemDuplicated(checksArray, check)
  };

  return validFields;
};

export const updateNetworkStatus = checksArray => {
  checksArray.forEach(check => {
    const newCheck = check;
    newCheck.retry = 3;
    newCheck.status = false;
    newCheck.isOcr = true;
    newCheck.disableCell = false;
  });

  return checksArray;
};

export const validateShowNetowrokError = checksArray => {
  let i = 0;
  let sw = true;
  while (i < checksArray.length && !sw) {
    if (checksArray[i].isNetworkError && checksArray[i].retry >= 3) sw = false;
    i += 1;
  }
  return sw;
};

export const validateRetry = checksArray => {
  let isRetry = false;
  const retryArray = checksArray.filter(function getCheck(check) {
    return check.retry < 3 && check.validFields.isNetworkError && !check.isOcr;
  });

  if (retryArray.length > 0) isRetry = true;
  else isRetry = false;

  return isRetry;
};

const validateIsCheckModify = check => {
  let isModifiedCheck = false;
  if (
    check.modified ||
    check.isModifiedFields.payee ||
    check.isModifiedFields.maker
  )
    isModifiedCheck = true;
  else isModifiedCheck = false;

  return isModifiedCheck;
};

// Create check with the information read from OCR.
export const createCheckOcr = (
  ocrResponse,
  check,
  checksArray,
  agencySettingsData
) => {
  let newCheck = check;
  newCheck.maximumAmountPerCheck = agencySettingsData.maxAmountPerCheck;
  if (ocrResponse !== null && ocrResponse !== undefined) {
    newCheck = validateIsCheckModify(newCheck)
      ? returnChecksArrayModified(ocrResponse, newCheck)
      : returnChecksArray(ocrResponse, newCheck);
    if (newCheck !== null) {
      newCheck.scoreFields = returnScoreFields(ocrResponse);
      newCheck.validFields = getCheckValidations(checksArray, newCheck);
    }
  }

  return newCheck;
};

export const createImagesOcr = (ocrResponse, images) => {
  const newImages = images;

  if (ocrResponse !== null && ocrResponse !== undefined) {
    newImages.frontImage = ocrResponse.frontImage;
  }
  return newImages;
};

export const removeCheckFromCheckArray = (checksArray, checkSelected) => {
  const newcheckarray = [];

  checksArray.forEach(check => {
    if (check.scanOrder !== checkSelected.scanOrder) newcheckarray.push(check);
  });

  return newcheckarray;
};

export const removeCheckFromImageArray = (imagesArray, checkSelected) => {
  const newImageArray = [];

  imagesArray.forEach(check => {
    if (check.scanOrder !== checkSelected.scanOrder) newImageArray.push(check);
  });

  return newImageArray;
};

export const getTotalArray = checksArray => {
  return checksArray.reduce(function getTotalBatch(acc, currValue) {
    if (
      currValue === null ||
      currValue === undefined ||
      checksArray.length === 0 ||
      currValue.amount === '' ||
      currValue.amount === '0'
    )
      return 0;

    return Utilities.roundDecimal(acc + parseFloat(currValue.amount), 2);
  }, 0);
};

export const getParametersCheckValidations = checkElement => {
  const argms = {
    account:
      checkElement.account !== null && checkElement.account !== ''
        ? checkElement.account
        : '0',
    routing:
      checkElement.routing !== null && checkElement.routing !== ''
        ? String(checkElement.routing)
        : '0',
    checkNumber:
      checkElement.checkNumber !== null && checkElement.checkNumber !== ''
        ? String(checkElement.checkNumber)
        : '0',
    checkDate:
      checkElement.checkDate !== null && checkElement.checkDate !== ''
        ? checkElement.checkDate
        : '',
    isCheckVerify: false,
    agencyName: checkElement.agencyName,
    amount:
      checkElement.amount !== null && checkElement.amount !== ''
        ? checkElement.amount.toString()
        : '0',
    checkType: checkElement.checkType,
    payee: checkElement.payee
  };
  return argms;
};

export const getResponseFromServiceCheckValidations = (
  response,
  check,
  isCallingOCR,
  agencySettingsData
) => {
  const newCheck = check;
  if (
    response.validateScannedCheck.status !== null &&
    response.validateScannedCheck.status !== undefined
  ) {
    if (response.validateScannedCheck.status.code === '000') {
      if (
        response.validateScannedCheck.checkInformation !== null &&
        response.validateScannedCheck.checkInformation !== undefined
      ) {
        const validationResponse =
          response.validateScannedCheck.checkInformation;

        if (isCallingOCR) {
          if (!newCheck.validFields.duplicated) {
            newCheck.validFields.duplicated = validationResponse.checkId !== 0;
          }
        } else {
          newCheck.validFields.duplicated = validationResponse.checkId !== 0;
        }

        newCheck.maximumAmountPerCheck = agencySettingsData.maxAmountPerCheck;

        newCheck.validFields.amount = validateAmount(newCheck.amount)
          ? newCheck.amount <= agencySettingsData.maxAmountPerCheck
          : false;
        newCheck.validFields.checkType = validationResponse.isValidCheckType;
        newCheck.validFields.blockList = validationResponse.isBlockList;
        newCheck.mva = validationResponse.mva;
        newCheck.ownLicense = validationResponse.ownLicense;
        newCheck.reprocess = validationResponse.reprocess;
        newCheck.stateCode = validationResponse.stateCode;
        newCheck.bank = validationResponse.bank;
        newCheck.limitRoutingScore = validationResponse.routingScore;
        newCheck.limitCheckNumberScore = validationResponse.checkNumberScore;
        newCheck.limitAmountScore = validationResponse.amountScore;
        newCheck.limitDateScore = validationResponse.dateScore;
        newCheck.limitAccountScore = validationResponse.accountScore;
        newCheck.returnedChecksMaker = validationResponse.returnedChecksMaker;
        newCheck.issuedChecksMaker = validationResponse.issuedChecksMaker;
        newCheck.checkType = validationResponse.checkType;
        newCheck.checkTypeDescription =
          newCheck.routing === ROUTING_TREASURY
            ? 'IRS'
            : validationResponse.checkTypeDescription;
        if(validationResponse.makerName!=='' )
        {
           newCheck.payerAddressName = validationResponse.makerName;
           newCheck.isMakerCorrected = true;
        } 

      }
    }
  }
  return newCheck;
};

export const getImagesFromArray = (imagesArray, scanOrder) => {
  const index = CheckCommonRules.getCheckIndex(imagesArray, scanOrder);
  let images = '';
  if (index !== -1) {
    images = imagesArray[index];
  }
  return images;
};

export const isRuleRequiered = check => {
  let isRequiered = true;
  if (
    check.amount === 0 ||
    check.account === '' ||
    check.routing === '' ||
    check.checkNumber === ''  
  ) {
    isRequiered = false;
    
  }
  return isRequiered;
};

export const restartProperties = checksArray => {
  const newcheckarray = checksArray;
  newcheckarray.forEach(check => {
    const newCheck = check;
    newCheck.disableCell = false;
  });
  return newcheckarray;
};

export default getCheckScanOrder;