Calculation/app/lib/rm/change.js

'use strict';

/**
 *
 *
 * @author Mai
 * @date
 * @version
 */

const RptMemBase = require('./base');
const bindData = {};
const changeConst = require('../../const/change');
const Ledger = require('../ledger');

class rptMemChange extends RptMemBase {
    constructor(ctx) {
        super(ctx, bindData);
    }

    _getChangeConstName(define, value) {
        for (const prop in define) {
            if (define[prop].value === value) {
                return define[prop].name;
            }
        }
        return '';
    }

    async _anaylisChange(change) {
        const self = this;
        const types = this.ctx.helper._.map(change.type.split(','), function (t) {
            return self._getChangeConstName(changeConst.type, self.ctx.helper._.toInteger(t));
        });
        change.type = types.join(';');
        change.class = this._getChangeConstName(changeConst.class, change.class);
        change.quality = this._getChangeConstName(changeConst.quality, change.quality);
        change.charge = this._getChangeConstName(changeConst.charge, change.charge);
    }

    async doCheckChange(changeId) {
        if (this.ctx.change) return;
        this.ctx.change = await this.ctx.service.change.getDataByCondition({ cid: changeId });
        this._anaylisChange(this.ctx.change);
    }

    async doCheckTender(tenderId) {
        if (this.ctx.tender) return;
        this.ctx.tender = { id: tenderId };
        this.ctx.tender.data = await this.ctx.service.tender.getTender(tenderId);
        this.ctx.tender.info = await this.ctx.service.tenderInfo.getTenderInfo(tenderId);
    }

    async doBeforeLoadReport(params) {
        await this.doCheckChange(params.change_id);
        await this.doCheckTender(this.ctx.change.tid);
    }

    async _getChangeBills() {
        const decimal = this.ctx.tender.info.decimal;
        const changeBills = await this.ctx.service.changeAuditList.getAllDataByCondition({ where: { cid: this.ctx.change.cid} });
        for (const d of changeBills) {
            d.o_qty = d.oamount;
            d.o_tp = this.ctx.helper.mul(d.o_qty, d.unit_price, decimal.tp);
            d.o_qty2 = d.oamount2;
            d.o_tp2 = this.ctx.helper.mul(d.o_qty2, d.unit_price, decimal.tp);
            d.c_qty = d.camount;
            d.c_tp = this.ctx.helper.mul(d.c_qty, d.unit_price, decimal.tp);
            d.s_qty = d.samount ? parseFloat(d.samount) : 0;
            d.s_tp = this.ctx.helper.mul(d.s_qty, d.unit_price, decimal.tp);
            d.sp_qty = d.spamount;
            d.sp_tp = this.ctx.helper.mul(d.sp_qty, d.unit_price, decimal.tp);

            const auditAmount = d.audit_amount ? d.audit_amount.split(',') : [];
            const relaChange = this.ctx.helper._.find(this.ctx.change, {cid: d.cid});
            for (const [i, aa] of auditAmount.entries()) {
                const amountField = 'qty_' + (i+1), tpField = 'tp_' + (i+1);
                d[amountField] = aa ? parseFloat(aa) : 0;
                d[tpField] = this.ctx.helper.mul(d[amountField], d.unit_price, decimal.tp);
                if (relaChange) {
                    relaChange[tpField] = this.ctx.helper.add(relaChange[tpField], d[tpField]);
                }
            }
        }
        return changeBills;
    }

    _getNewBillsTree(calcFields) {
        return new Ledger.billsTree(this.ctx, {
            id: 'ledger_id',
            pid: 'ledger_pid',
            order: 'order',
            level: 'level',
            rootId: -1,
            keys: ['id', 'tender_id', 'ledger_id'],
            stageId: 'id',
            calcFields: calcFields || ['deal_tp', 'total_price', 'sgfh_tp', 'sjcl_tp', 'qtcl_tp'],
            calc: function (node, helper) {
            }
        });
    }

    _calcLeafXmjRela(billsTree) {
        for (const node of billsTree.nodes) {
            if (node.b_code) {
                const leafXmj = billsTree.getLeafXmjParent(node);
                node.leaf_xmj_id = leafXmj ? leafXmj.id : -1;
            }
        }
    }

    async getChangeLedgerBillsData(fields, showLevel) {
        try {
            const billsData = await this.ctx.service.ledger.getData(this.ctx.tender.id);
            const changeBillsData = await this.ctx.service.changeLedger.getAllDataByCondition({ where: { ccid: this.ctx.change.id } });
            billsData.push(...changeBillsData);

            const billsTree = this._getNewBillsTree();
            billsTree.loadDatas(billsData);
            billsTree.calculateAll();

            if (this._checkFieldsExist(fields, ['leaf_xmj_id'])) {
                this._calcLeafXmjRela(billsTree);
            }

            return showLevel ? billsTree.getDefaultDatasByLevel(this.ctx.tender.rpt_show_level) : billsTree.getDefaultDatas();
        } catch(err) {
            this.ctx.log(err);
            return [];
        }
    }
    async getChangeLedgerPosData() {
        try {
            const posData = await this.ctx.service.pos.getAllDataByCondition({ where: {tid: this.ctx.tender.id }});
            const changePosData = await this.ctx.service.changePos.getAllDataByCondition({ where: { ccid: this.ctx.change.id } });
            posData.push(...changePosData);

            const pos = new Ledger.pos({
                id: 'id', ledgerId: 'lid',
                updateFields: ['contract_qty', 'qc_qty', 'postil'],
                calc: function (p) {
                }
            });
            pos.loadDatas(posData);
            pos.calculateAll();

            return pos.getDatas();
        } catch (err) {
            return [];
        }
    }

    getCommonData(params, tableName, fields, customDefine, customSelect) {
        switch (tableName) {
            case 'mem_change':
                return [this.ctx.change];
            case 'mem_change_bills':
                return this._getChangeBills();
            case 'mem_change_audit':
                return this.ctx.service.changeAudit.getListGroupByTimes(this.ctx.change.cid, this.ctx.change.times);
            case 'mem_change_att':
                return this.ctx.service.changeAtt.getChangeAttachment(this.ctx.change.cid);
            case 'mem_project':
                return this.ctx.service.project.getDataByCondition({ id: this.ctx.session.sessionProject.id });
            case 'mem_tender':
                return [this.ctx.tender.data];
            case 'mem_tender_info':
                return [this.ctx.tender.info];
            case 'mem_change_ledger_bills':
                return this.getChangeLedgerBillsData(fields);
            case 'mem_change_ledger_bills_filter':
                return this.getChangeLedgerBillsData(fields, true);
            case 'mem_change_ledger_pos':
                return this.getChangeLedgerPosData();
            default:
                return [];
        }
    }
}

module.exports = rptMemChange;