client-ui/source/shared/shared-loan-service.js

Testing implementation of nodeJs Backend, angular frontend, and hopefully in a way that this can be deployed to s3/cloudfront

angular.module(moduleName).service('loan', ['$http', '$q', 'aiStorage', 'rootConstants', 'client', '$state', '$filter',
    function ($http, $q, store, rootConstants, client, $state, $filter) {
    var self = this;

    self.getNextStep = function() {
        var clientData = client.getClientStore();
        var currentLoan = self.getCurrentLoan();
        var nextStep = 'loanDashboard.myDashboard';
        var currentState = $state.$current.self.name;

        if(!currentLoan || !clientData || currentLoan.statusCode >= 500){
            return nextStep;
        }

        var debitAccounts;
        if(currentLoan.bank && currentLoan.bank.accounts){
            debitAccounts = $filter('filter')(currentLoan.bank.accounts, {type:'debit'});
        }

        switch (true) {
            case currentLoan.hasOwnProperty('adverseActionPdf'):
                nextStep = 'loanDashboard.myDashboard';
                break;
            case currentLoan.hasOwnProperty('deniedByAdmin'):
                nextStep = 'sorry';
                break;
            case currentLoan.hasOwnProperty('statusCode')
                    && (currentLoan.statusCode < 300 || (currentLoan.statusCode >= 300 && !currentLoan.selectedOffer))
                    && currentState !== 'loanApplication.loanOptions':
                nextStep = 'loanApplication.loanOptions';
                break;
            case !clientData.emailVerified
                    && currentState !== 'loanApplication.verify.emailAddress':
                nextStep = 'loanApplication.verify.emailAddress';
                break;
            case !clientData.KBAsAccepted
                    && currentState !== 'loanApplication.verify.knowledgeAssessment':
                nextStep = 'loanApplication.verify.knowledgeAssessment';
                break;
            case (!currentLoan.incomeSummary.isVerified && !currentLoan.hasPendingIncomeDocs):
                nextStep = self.getNextIncomeSummaryStep();
                break;
            case ((!currentLoan.payMethod || currentLoan.payMethod.name === 'check') || (currentLoan.bank && currentLoan.bank.trialDeposits))
                    && currentState !== 'loanApplication.verify.bank':
                nextStep = 'loanApplication.verify.bank';
                break;
            case (clientData.requestIdDoc && !clientData.hasPendingIdDocs):
                nextStep = 'loanApplication.verify.identity';
                break;
            case (clientData.hasPendingIdDocs || currentLoan.hasPendingIncomeDocs):
                nextStep = 'loanDashboard.myDashboard';   //loanDashboard.myDashboard here so we can show a pending docs message
                break;
            // case ((!debitAccounts || debitAccounts.length === 0) && currentLoan.selectedOffer.amountFinanced <= config.fastFundMaxAmount):
            //     nextStep = 'loanApplication.verify.debit';
            //     break;
            case !currentLoan.incomeSummary.isVerified
                    && currentState !== 'loanApplication.verify.income':
                // second fall-through for income verification
                // if document uploads are pending approval
                nextStep = 'loanApplication.verify.income';
                break;
            default:
                nextStep = 'loanApplication.loanOverview';
                break;
        }
        return nextStep;
    };

    self.getNextIncomeSummaryStep = function() {
        var currentLoan = self.getCurrentLoan();
        if(!currentLoan){
            return "";
        }
        switch (currentLoan.incomeSummary.status) {
            case 'talxSkip':
                return 'loanApplication.verify.income.choose';
            case 'talxSuccess':
                return 'loanApplication.verify.income.automatic';
            case 'choseYodlee':
                return 'loanApplication.verify.income.decisionLogic';
            case 'yodleeLoginSuccess':
                return 'loanApplication.verify.income.decisionLogic';
            case 'yodleeReportSuccess':
                return 'loanApplication.verify.income.decisionLogic';
            case 'choseManual':
                return 'loanApplication.verify.income.manual';
            //TODO: sorry page?
            case 'failed':
                return 'loanApplication.verify.income.failed';
            default:
                return 'loanApplication.verify.income.automatic';
        }

    };

    self.getCurrentLoan = function() {
        return store.get('currentLoan');
    };

    self.refreshCurrentLoanFromDB = function () {
        var deferred = $q.defer();
        var loanId = store.get('currentLoan').loanId;
        $http.get(rootConstants.server + 'loans/' + loanId)
            .then(function (res) {
                self.setCurrentLoan(res.data);
                deferred.resolve(self.getCurrentLoan());
            }, function (err) {
                console.info('Unable to refresh loan from database');
                console.info(err);
                deferred.resolve(self.getCurrentLoan());
            });
        return deferred.promise;
    };

    self.setCurrentLoan = function(loanData) {
        store.set('currentLoan', loanData);
    };

    self.updateLoan = function(loanData) {
        var deferred = $q.defer();
        var loanId = self.getCurrentLoan().loanId;
        $http.put(rootConstants.server + 'loans/' + loanId, loanData)
            .then(function(loanResponse) {
                self.setCurrentLoan(loanResponse.data);
                deferred.resolve(self.getCurrentLoan());
            }, function(error) {
                deferred.reject(error.data);
            });
        return deferred.promise;
    };

    self.unsetCurrentLoanStore = function() {
        store.remove('currentLoan');
    };

    self.chooseLoanOffer = function(loanOfferId) {
        var deferred = $q.defer();
        var currentLoan = self.getCurrentLoan();
        $http.post(rootConstants.server + 'loans/' + currentLoan.loanId + '/chooseLoan', {loanOfferId: loanOfferId})
            .then(function(loan) {
                self.setCurrentLoan(loan.data);
                deferred.resolve(loan.data);
            }, function(error) {
                deferred.reject(error);
            });
        return deferred.promise;
    };

    self.getLoanOptions = function() {
        var deferred = $q.defer();
        var currentLoan = self.getCurrentLoan();
        $http.post(rootConstants.server + 'loans/' + currentLoan.loanId + '/loanOffers')
            .then(function (res) {
                self.setCurrentLoan(res.data);
                deferred.resolve(res.data);
            }, function (err) {
                deferred.reject(err.data || err);
            });
        return deferred.promise;
    };


    self.updateBankAccount = function(loanId, bankAccountData) {
        var deferred = $q.defer();

        if (bankAccountData && bankAccountData.hasOwnProperty('debit')) {
            $http.put(rootConstants.server + 'loans/' + loanId + '/debitCard',
              { debit: bankAccountData.debit })
                .then(function (res) {
                    self.setCurrentLoan(res.data);
                    deferred.resolve(self.getCurrentLoan());
                }, function (err) {
                    console.info(err);
                    if (err.status && err.status === 400 && err.data) {
                        deferred.reject(err.data.mesg || err.data);
                    } else {
                        deferred.reject('Error updating bank info');
                    }
                });
        } else {
            deferred.reject('Missing debit card info.');
        }

        return deferred.promise;
    };

    self.getLoansByClient = function(clientId) {
        var deferred = $q.defer();

        if (!self.getCurrentLoan()) {
            $http.get(rootConstants.server + 'clients/' + clientId + '/loans')
                .then(function (res) {
                    self.setCurrentLoan(res.data[0]);
                    deferred.resolve( res.data );
                }, function (err) {
                    console.info(err);
                    deferred.reject('Error getting loans');
                });
        }
        else {
            deferred.resolve([ self.getCurrentLoan() ]);
        }

        return deferred.promise;
    };

    self.getDenialReasons = function() {
        var deferred = $q.defer();
        self.refreshCurrentLoanFromDB()
            .then(function(loan) {
                if (loan.hasOwnProperty("denialReasons")) {
                    deferred.resolve({
                        denialReasons: loan.denialReasons
                    });
                } else {
                    deferred.reject("No reasons for denial present");
                }
            }, function(error) {
                deferred.reject(error);
            });
        return deferred.promise;
    };

    self.automaticIncomeVerification = function () {
        var currentLoan = self.getCurrentLoan();
        var deferred = $q.defer();

        $http.put(rootConstants.server + 'loans/' + currentLoan.loanId + '/automaticIncomeVerification')
            .then(function (res) {
                self.setCurrentLoan(res.data);
                deferred.resolve(self.getCurrentLoan());
            }, function (err) {
                console.info(err);
                deferred.reject('Error verifying income');
            });

        return deferred.promise;
    };

    self.verifyIncome = function () {
        var currentLoan = self.getCurrentLoan();
        var deferred = $q.defer();

        $http.put(rootConstants.server + 'loans/' + currentLoan.loanId + '/verifyIncome')
            .then(function (res) {
                self.setCurrentLoan(res.data);
                deferred.resolve(self.getCurrentLoan());
            }, function (err) {
                console.info(err);
                deferred.reject('Error verifying income');
            });

        return deferred.promise;
    };

    self.requestBankLogin = function (bankId) {
        var currentLoan = self.getCurrentLoan();
        var deferred = $q.defer();

        $http.get(rootConstants.server + 'loans/' + currentLoan.loanId + '/requestBankLogin/' + bankId)
            .then(function (res) {
                deferred.resolve(res.data);
            }, function (res) {
                deferred.reject('Error requesting bank login form: ' + JSON.stringify(res.data));
            });

        return deferred.promise;
    };

    self.bankNameSearch = function (bankName) {
        var currentLoan = self.getCurrentLoan();
        var deferred = $q.defer();

        $http.post(rootConstants.server + 'loans/' + currentLoan.loanId + '/bankNameSearch', {bankName: bankName})
            .then(function (res) {
                deferred.resolve(res.data);
            }, function (res) {
                deferred.reject('Error searching for bank name: ' + JSON.stringify(res.data));
            });

        return deferred.promise;
    };

    self.getFirmOffer = function() {
        var loanId = self.getCurrentLoan().loanId;
        var deferred = $q.defer();
        $http.post(rootConstants.server + 'loans/' + loanId + '/firmOffer')
            .then(function (res) {
                self.setCurrentLoan(res.data);
                deferred.resolve(self.getCurrentLoan());
            }, function (res) {
                deferred.reject(res.data);
            });
        return deferred.promise;
    }

    self.acceptOffer = function() {
        var loanId = self.getCurrentLoan().loanId;
        var deferred = $q.defer();
        $http.post(rootConstants.server + 'loans/' + loanId + '/acceptOffer')
            .then(function (res) {
                self.setCurrentLoan(res.data);
                deferred.resolve(self.getCurrentLoan());
            }, function (err) {
                console.info(err);
                deferred.reject('Error accepting offer');
            });
        return deferred.promise;
    };

    self.generateUploadUrl = function(form) {
        var loanId = self.getCurrentLoan().loanId;
        return $http.post(rootConstants.server + 'loans/' + loanId + '/documents/generate/uploadUrl', form);
    };

    self.generateDownloadUrl = function(params) {
        var deferred = $q.defer();
        var loanId = self.getCurrentLoan().loanId;
        $http.put(rootConstants.server + 'loans/' + loanId + '/documents/generate/downloadUrl', params)
            .then(function (res) {
                deferred.resolve(res.data);
            }, function (err) {
                deferred.resolve(null);
            });
        return deferred.promise;
    };

    self.uploadCallback = function(url) {
        var deferred = $q.defer();
        $http.put(url)
            .then(function(response) {
                deferred.resolve(response.data);
            }, function(error) {
                deferred.reject(error.data);
            });
        return deferred.promise;
    };

    self.getRequiredDisclosures = function (requiredFor) {
        var deferred = $q.defer();
        var data = {};
        if (requiredFor) {
            data.requiredFor = requiredFor;
        }

        $http.post(rootConstants.server + 'disclosures', data)
            .then(function (res) {
                deferred.resolve(res.data);
            }, function (err) {
                // MAKE IT PASS UNTIL WE CAN SEED THE CI DB
                deferred.resolve(null);
                //deferred.reject(err);
            });
        return deferred.promise;
    };

    self.getLoanDisclosures = function () {
        var deferred = $q.defer();
        var currentLoan = self.getCurrentLoan();
        $http.get(rootConstants.server + 'loans/' + currentLoan.loanId + '/disclosures')
            .then(function (res) {
                deferred.resolve(res.data);
            }, function (err) {
                deferred.reject(err);
            });
        return deferred.promise;
    };

    self.toggleIncomeProvider = function (providerName, include) {
        var deferred = $q.defer();
        var currentLoan = self.getCurrentLoan();
        var body = {
            provider: providerName,
            include: include
        };
        $http.put(rootConstants.server + 'loans/' + currentLoan.loanId + '/toggleIncomeProvider', body)
            .then(function (res) {
                self.setCurrentLoan(res.data);
                deferred.resolve(res.data);
            }, function (err) {
                deferred.reject(err);
            });
        return deferred.promise;
    };

    self.updateIncomeStatus = function (status) {
        var deferred = $q.defer();
        var currentLoan = self.getCurrentLoan();
        var body = {
            status: status
        };
        $http.put(rootConstants.server + 'loans/' + currentLoan.loanId + '/updateIncomeStatus', body)
            .then(function (res) {
                self.setCurrentLoan(res.data);
                deferred.resolve(res.data);
            }, function (err) {
                deferred.reject(err);
            });
        return deferred.promise;
    };

    self.toggleIncomeSource = function (providerName, sIdx, include) {
        var deferred = $q.defer();
        var currentLoan = self.getCurrentLoan();
        var body = {
            providerName: providerName,
            sourceIndex: sIdx,
            include: include
        };
        $http.put(rootConstants.server + 'loans/' + currentLoan.loanId + '/toggleIncomeSource', body)
            .then(function (res) {
                self.setCurrentLoan(res.data);
                deferred.resolve(res.data);
            }, function (err) {
                deferred.reject(err);
            });
        return deferred.promise;
    };

    self.addBankAccount = function (bankAccount, payMethodName) {
        // see loan model for bankAccount schema
        var deferred = $q.defer();
        var currentLoan = self.getCurrentLoan();
        if (payMethodName) {
            bankAccount.payMethodName = payMethodName;
            bankAccount.setDefaultServicing = (payMethodName !== 'check');
        }
        if (bankAccount.type === 'debit') {
            bankAccount.setDefaultFunding = true;
        }

        $http.post(rootConstants.server + 'loans/' + currentLoan.loanId + '/bankAccount', bankAccount)
            .then(function (res) {
                self.setCurrentLoan(res.data);
                deferred.resolve(res.data);
            }, function (err) {
                deferred.reject(err.data);
            });
        return deferred.promise;
    };

    self.getFundingAccount = function () {
        var currentLoan = self.getCurrentLoan();
        var banks = currentLoan.bank && currentLoan.bank.accounts;
        var fundingAcct;

        if (banks) {
            var i = 0;
            while (banks[i] && !fundingAcct) {
                fundingAcct = banks[i].funding && banks[i];
                i++;
            }
        }

        return fundingAcct;
    };

    self.verifyTrialDeposits = function (amounts, payMethodName) {
        var deferred = $q.defer();
        var currentLoan = self.getCurrentLoan();
        $http.post(rootConstants.server + 'loans/' + currentLoan.loanId + '/trialDeposits', {
            amounts: amounts,
            payMethodName: payMethodName
        }).then(function (res) {
            self.setCurrentLoan(res.data);
            deferred.resolve(res.data);
        }, function (err) {
            deferred.reject(err.data || err);
        });
        return deferred.promise;
    };

    self.setPayMethod = function (payMethodName) {
        var deferred = $q.defer();
        var currentLoan = self.getCurrentLoan();
        $http.post(rootConstants.server + 'loans/' + currentLoan.loanId + '/payMethod', { payMethodName: payMethodName })
            .then(function (res) {
                self.setCurrentLoan(res.data);
                deferred.resolve(res.data);
            }, function (err) {
                deferred.reject(err.data);
            });
        return deferred.promise;
    };

    self.hasFundingAcct = function () {
        var currentLoan = self.getCurrentLoan();
        // needed in case fundingAccountNo == 0
        return currentLoan.bank
               && currentLoan.bank.hasOwnProperty('fundingAccountNo')
               && (typeof currentLoan.bank.fundingAccountNo === 'string' ||
                   typeof currentLoan.bank.fundingAccountNo === 'number')
               && currentLoan.bank.fundingAccountNo.toString().length;
    };

    self.hasServicingAcct = function () {
        var currentLoan = self.getCurrentLoan();
        // needed in case servicingAccountNo == 0
        return currentLoan.bank
               && currentLoan.bank.hasOwnProperty('servicingAccountNo')
               && (typeof currentLoan.bank.servicingAccountNo === 'string' ||
                   typeof currentLoan.bank.servicingAccountNo === 'number')
               && currentLoan.bank.servicingAccountNo.toString().length;
    };

    self.validBankAcct = function () {
        // loop all bank accounts, find type bank,
        // return any set as servicing or funding,
        // alternatively any marked as valid
        var currentLoan = self.getCurrentLoan();
        var retVal, acct;
        if (currentLoan.bank && currentLoan.bank.accounts) {
            for (var i = 0; i < currentLoan.bank.accounts.length; i++) {
                acct = currentLoan.bank.accounts[i];
                if (acct.valid && acct.type === 'bank') {
                    if ((acct.servicing || acct.funding) || !retVal) {
                        retVal = acct;
                    }
                }
            }
        }
        return retVal;
    };


}]);