service-financial/app/service/tGovernmentStatistics.js

'use strict';


const assert = require('assert');
const _ = require('lodash');
const {ObjectId} = require('mongoose').Types;
const {CrudService} = require('naf-framework-mongoose/lib/service');
const {BusinessError, ErrorCode} = require('naf-core').Error;
const moment = require('moment');

class TGovernmentStatisticsService extends CrudService {
    constructor(ctx) {
        super(ctx, 't_guidance_unit');
        this.model = this.ctx.model.TGuidanceUnit;
        this.cModel = this.ctx.model.Claimneed;
        this.sModel = this.ctx.model.Stockneed;
        this.fModel = this.ctx.model.Financefollow;
        this.companyidentifyModel = this.ctx.model.Companyidentify;
        this.pModel = this.ctx.model.Profession;
        this.dModel = this.ctx.model.Dictionary;
        this.loanProModel = this.ctx.model.Loanpro;
        this.financeClaimsModel = this.ctx.model.Tfinanceclaims;
        this.manageMoneyModel = this.ctx.model.Managemoney;
        this.institutionModel = this.ctx.model.Institution;
        this.intelligentDockingModel = this.ctx.model.IntelligentDocking;
        this.intelligentFollowModel = this.ctx.model.IntelligentFollow;
    }


    // 企业发布需求金额
    async demandAmount(payload) {

        let dateType = payload.dateType || '2';
        let {startTime, endTime} = this.getTime(payload, dateType);
        let timeArray = this.getTimeArray(startTime, endTime, dateType);

        const cAgg = [

            {
                $project: {
                    status: 1,
                    money: {
                        $toDouble: '$money'
                    },
                    time: {
                        $toLong: '$meta.createdAt'
                    },
                    year: {
                        $year: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },
                    month: {
                        $month: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },
                    day: {
                        $dayOfMonth: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },

                },

            },
            {
                $match: this.getTimeMatch("1", {startTime, endTime}, payload),

            },
            {
                $group: this.getTimeGroup("1", dateType)
            },
            {
                $sort: this.getTimeSort(dateType)
            },
            {
                $project: {
                    _id: 0,
                    value: 1,
                    label: this.getTimeLabel(dateType)
                },

            },

        ];

        const sAgg = [

            {
                $project: {
                    status: 1,
                    money: {
                        $toDouble: '$stock_money'
                    },
                    time: {
                        $toLong: '$meta.createdAt'
                    },
                    year: {
                        $year: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },
                    month: {
                        $month: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },
                    day: {
                        $dayOfMonth: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },

                },

            },
            {
                $match: this.getTimeMatch("1", {startTime, endTime}, payload),

            },
            {
                $group: this.getTimeGroup("1", dateType)
            },
            {
                $sort: this.getTimeSort(dateType)
            },
            {
                $project: {
                    _id: 0,
                    value: 1,
                    label: this.getTimeLabel(dateType)
                },

            },

        ];

        const iAgg = [

            {
                $project: {
                    money: {
                        $toDouble: '$money'
                    },
                    time: {
                        $toLong: '$meta.createdAt'
                    },
                    year: {
                        $year: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },
                    month: {
                        $month: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },
                    day: {
                        $dayOfMonth: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },

                },

            },
            {
                $match: this.getTimeMatch("9", {startTime, endTime}, payload),

            },
            {
                $group: this.getTimeGroup("9", dateType)
            },
            {
                $sort: this.getTimeSort(dateType)
            },
            {
                $project: {
                    _id: 0,
                    value: 1,
                    label: this.getTimeLabel(dateType)
                },

            },

        ];

        let cData = await this.cModel.aggregate(cAgg);
        let sData = await this.sModel.aggregate(sAgg);
        let iData = await this.intelligentDockingModel.aggregate(iAgg);

        let tempData = [...cData, ...sData, ...iData];
        let data = this.formatTimeData(timeArray, tempData);
        return data;
    }

    // 解决融资
    async financingSolution(payload) {

        let dateType = payload.dateType || '2';
        let {startTime, endTime} = this.getTime(payload, dateType);
        let timeArray = this.getTimeArray(startTime, endTime, dateType);
        const fAgg = [
            {
                $project: {
                    orcredit: 1,
                    money: {
                        $toDouble: '$credit_money'
                    },
                    time: {
                        $toLong: '$credit_time'
                    },
                    year: {
                        $year: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$credit_time'
                                }, 28800000],

                            },

                        },

                    },
                    month: {
                        $month: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$credit_time'
                                }, 28800000],

                            },

                        },

                    },
                    day: {
                        $dayOfMonth: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$credit_time'
                                }, 28800000],

                            },

                        },

                    },

                },

            },
            {
                $match: this.getTimeMatch("2", {startTime, endTime}, payload),

            },
            {
                $group: this.getTimeGroup("2", dateType)
            },
            {
                $sort: this.getTimeSort(dateType)
            },
            {
                $project: {
                    _id: 0,
                    value: 1,
                    label: this.getTimeLabel(dateType)
                },

            },

        ];
        const iAgg = [
            {
                $project: {
                    orcredit: '$creditStatus',
                    money: {
                        $toDouble: '$credit_money'
                    },
                    time: {
                        $toLong: '$credit_time'
                    },
                    year: {
                        $year: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$credit_time'
                                }, 28800000],

                            },

                        },

                    },
                    month: {
                        $month: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$credit_time'
                                }, 28800000],

                            },

                        },

                    },
                    day: {
                        $dayOfMonth: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$credit_time'
                                }, 28800000],

                            },

                        },

                    },

                },

            },
            {
                $match: this.getTimeMatch("2", {startTime, endTime}, payload),

            },
            {
                $group: this.getTimeGroup("2", dateType)
            },
            {
                $sort: this.getTimeSort(dateType)
            },
            {
                $project: {
                    _id: 0,
                    value: 1,
                    label: this.getTimeLabel(dateType)
                },

            },

        ];
        let fData = await this.fModel.aggregate(fAgg);
        let iData = await this.intelligentFollowModel.aggregate(iAgg);
        let tempData = [...fData, ...iData];
        let data = this.formatTimeData(timeArray, tempData);
        return data;
    }

    // 注册企业年月
    async companyDate(payload) {

        let dateType = payload.dateType || '2';
        let {startTime, endTime} = this.getTime(payload, dateType);
        let timeArray = this.getTimeArray(startTime, endTime, dateType);

        const agg = [

            {
                $project: {
                    status: 1,
                    profession_one: 1,
                    belong_addr_city: 1,
                    time: {
                        $toLong: '$meta.createdAt'
                    },
                    year: {
                        $year: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },
                    month: {
                        $month: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },
                    day: {
                        $dayOfMonth: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },

                },

            },
            {
                $match: this.getTimeMatch("3", {startTime, endTime}, payload),

            },
            {
                $group: this.getTimeGroup("3", dateType)
            },
            {
                $sort: this.getTimeSort(dateType)
            },
            {
                $project: {
                    _id: 0,
                    value: 1,
                    label: this.getTimeLabel(dateType)
                },

            },

        ];

        let tempData = await this.companyidentifyModel.aggregate(agg);
        let data = this.formatTimeData(timeArray, tempData);
        return data;
    }

    // 注册企业行业
    async companyIndustry(payload) {

        const agg = [

            {
                $project: {
                    status: 1,
                    profession_one: 1,
                    belong_addr_city: 1,
                    time: {
                        $toLong: '$meta.createdAt'
                    },
                    year: {
                        $year: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },
                    month: {
                        $month: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },
                    day: {
                        $dayOfMonth: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },

                },

            },
            {
                $match: this.getMatch("1", payload),

            },
            {
                $group: {
                    _id: '$profession_one',
                    value: {
                        $sum: 1,
                    },

                }
            },
            {
                $sort: {
                    'value': -1,
                }
            },
            {
                $project: {
                    _id: 0,
                    code: '$_id',
                    value: 1
                },

            },

        ];
        let tempData = await this.companyidentifyModel.aggregate(agg);

        let professionArray = await this.pModel.find({pcode: '0'});
        //let professionTotal = await this.pModel.find({pcode:'0'}).countDocuments();

        let data = this.formatData(professionArray, tempData);
        let companyTotal = 0;
        data.forEach((item) => {
            companyTotal += item.value;
        });
        return {data,companyTotal};
    }

    // 注册企业地区
    async companyRegion(payload) {

        const agg = [

            {
                $project: {
                    status: 1,
                    profession_one: 1,
                    belong_addr_city: 1,
                    time: {
                        $toLong: '$meta.createdAt'
                    },
                    year: {
                        $year: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },
                    month: {
                        $month: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },
                    day: {
                        $dayOfMonth: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },

                },

            },
            {
                $match: this.getMatch("2", payload),

            },
            {
                $group: {
                    _id: '$belong_addr_city',
                    value: {
                        $sum: 1,
                    },

                }
            },
            {
                $sort: {
                    'value': -1,
                }
            },
            {
                $project: {
                    _id: 0,
                    code: '$_id',
                    value: 1
                },

            },

        ];
        let tempData = await this.companyidentifyModel.aggregate(agg);

        let regionArray = await this.dModel.find({type:'dz',pcode: '220000'});
        let regionTotal = await this.dModel.find({type:'dz',pcode: '220000'}).countDocuments();

        let data = this.formatData(regionArray, tempData);
        let companyTotal = 0;
        data.forEach((item) => {
            companyTotal += item.value;
        });
        return {data,companyTotal,regionTotal};
    }

    // 帮助企业年月
    async helpBusinessesDate(payload) {

        let dateType = payload.dateType || '2';
        let {startTime, endTime} = this.getTime(payload, dateType);
        let timeArray = this.getTimeArray(startTime, endTime, dateType);

        const fAgg = [
            {
                $project: {
                    orcredit: 1,
                    finceId: 1,
                    time: {
                        $toLong: '$credit_time'
                    },
                    year: {
                        $year: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$credit_time'
                                }, 28800000],

                            },

                        },

                    },
                    month: {
                        $month: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$credit_time'
                                }, 28800000],

                            },

                        },

                    },
                    day: {
                        $dayOfMonth: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$credit_time'
                                }, 28800000],

                            },

                        },

                    },

                },

            },
            {
                $match:this.getTimeMatch("4", {startTime, endTime}, payload),

            },
            {
                $group: this.getTimeGroup("4", dateType)
            },
            {
                $sort: this.getTimeSort(dateType)
            },
            {
                $project: {
                    _id: 0,
                    value: 1,
                    label: this.getTimeLabel(dateType)
                },

            },

        ];
        const iAgg = [
            {
                $project: {
                    orcredit: '$creditStatus',
                    time: {
                        $toLong: '$credit_time'
                    },
                    year: {
                        $year: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$credit_time'
                                }, 28800000],

                            },

                        },

                    },
                    month: {
                        $month: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$credit_time'
                                }, 28800000],

                            },

                        },

                    },
                    day: {
                        $dayOfMonth: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$credit_time'
                                }, 28800000],

                            },

                        },

                    },

                },

            },
            {
                $match:this.getTimeMatch("4", {startTime, endTime}, payload),

            },
            {
                $group: this.getTimeGroup("4", dateType)
            },
            {
                $sort: this.getTimeSort(dateType)
            },
            {
                $project: {
                    _id: 0,
                    value: 1,
                    label: this.getTimeLabel(dateType)
                },

            },

        ];

        let fData = await this.fModel.aggregate(fAgg);
        let iData = await this.intelligentFollowModel.aggregate(iAgg);
        let tempData = [...fData, ...iData];
        let data = this.formatTimeData(timeArray, tempData);
        return data;
    }

    // 帮助企业行业
    async helpBusinessesIndustry(payload) {

        const cAgg = [
            {
                $project: {
                    orcredit: 1,
                    objId: {
                        $toObjectId: "$finceId"
                    },
                    time: {
                        $toLong: '$credit_time'
                    },

                },

            },
            {
                $match:this.getMatch("3", payload),

            },
            {
                $lookup: {
                    from: 'claim_need',
                    localField: 'objId',
                    foreignField: '_id',
                    as: 'claim_needs',

                },

            },
            {
                $unwind: {
                    path: '$claim_needs',
                    preserveNullAndEmptyArrays: false,

                },

            },
            {
                $lookup: {
                    from: 'company_identify',
                    localField: 'claim_needs.userid',
                    foreignField: 'uid',
                    as: 'company_identifys',

                },

            },
            {
                $unwind: {
                    path: '$company_identifys',
                    preserveNullAndEmptyArrays: false,

                },

            },
            {
                $group: {
                    _id: '$company_identifys.profession_one',
                    value: {
                        $sum: 1,

                    },

                }
            },
            {
                $sort: {
                    'value': - 1,

                }
            },
            {
                $project: {
                    _id: 0,
                    code: '$_id',
                    value: 1
                },

            },

        ];
        const sAgg = [
            {
                $project: {
                    orcredit: 1,
                    objId: {
                        $toObjectId: "$finceId"
                    },
                    time: {
                        $toLong: '$credit_time'
                    },

                },

            },
            {
                $match:this.getMatch("3", payload),

            },
            {
                $lookup: {
                    from: 'stock_need',
                    localField: 'objId',
                    foreignField: '_id',
                    as: 'stock_needs',

                },

            },
            {
                $unwind: {
                    path: '$stock_needs',
                    preserveNullAndEmptyArrays: false,

                },

            },
            {
                $lookup: {
                    from: 'company_identify',
                    localField: 'stock_needs.userid',
                    foreignField: 'uid',
                    as: 'company_identifys',

                },

            },
            {
                $unwind: {
                    path: '$company_identifys',
                    preserveNullAndEmptyArrays: false,

                },

            },
            {
                $group: {
                    _id: '$company_identifys.profession_one',
                    value: {
                        $sum: 1,

                    },

                }
            },
            {
                $sort: {
                    'value': - 1,

                }
            },
            {
                $project: {
                    _id: 0,
                    code: '$_id',
                    value: 1
                },

            },

        ];
        const iAgg = [
            {
                $project: {
                    orcredit: '$creditStatus',
                    objId: {
                        $toObjectId: "$intelligentId"
                    },
                    time: {
                        $toLong: '$credit_time'
                    },

                },

            },
           {
               $match:this.getMatch("3", payload),

           },
            {
                $lookup: {
                    from: 'intelligent_docking',
                    localField: 'objId',
                    foreignField: '_id',
                    as: 'intelligent_dockings',

                },

            },
            {
                $unwind: {
                    path: '$intelligent_dockings',
                    preserveNullAndEmptyArrays: false,

                },

            },
            {
                $lookup: {
                    from: 'company_identify',
                    localField: 'intelligent_dockings.uid',
                    foreignField: 'uid',
                    as: 'company_identifys',

                },

            },
            {
                $unwind: {
                    path: '$company_identifys',
                    preserveNullAndEmptyArrays: false,

                },

            },
            {
                $group: {
                    _id: '$company_identifys.profession_one',
                    value: {
                        $sum: 1,

                    },

                }
            },
            {
                $sort: {
                    'value': - 1,

                }
            },
            {
                $project: {
                    _id: 0,
                    code: '$_id',
                    value: 1
                },

            },

        ];
        let cData = await this.fModel.aggregate(cAgg);
        let sData = await this.fModel.aggregate(sAgg);
        let iData = await this.intelligentFollowModel.aggregate(iAgg);
        let tempData = [...cData, ...sData, ...iData];

        let professionArray = await this.pModel.find({pcode: '0'});
        //let professionTotal = await this.pModel.find({pcode:'0'}).countDocuments();

        let data = this.formatAddData(professionArray, tempData);
        let companyTotal = 0;
        data.forEach((item) => {
            companyTotal += item.value;
        });
        return {data,companyTotal};
    }

    // 帮助企业地区
    async  helpBusinessesRegion(payload) {

        const cAgg = [
            {
                $project: {
                    orcredit: 1,
                    objId: {
                        $toObjectId: "$finceId"
                    },
                    time: {
                        $toLong: '$credit_time'
                    },

                },

            },
            {
                $match:this.getMatch("4", payload),

            },
            {
                $lookup: {
                    from: 'claim_need',
                    localField: 'objId',
                    foreignField: '_id',
                    as: 'claim_needs',

                },

            },
            {
                $unwind: {
                    path: '$claim_needs',
                    preserveNullAndEmptyArrays: false,

                },

            },
            {
                $lookup: {
                    from: 'company_identify',
                    localField: 'claim_needs.userid',
                    foreignField: 'uid',
                    as: 'company_identifys',

                },

            },
            {
                $unwind: {
                    path: '$company_identifys',
                    preserveNullAndEmptyArrays: false,

                },

            },
            {
                $group: {
                    _id: '$company_identifys.belong_addr_city',
                    value: {
                        $sum: 1,

                    },

                }
            },
            {
                $sort: {
                    'value': - 1,

                }
            },
            {
                $project: {
                    _id: 0,
                    code: '$_id',
                    value: 1
                },

            },

        ];
        const sAgg = [
            {
                $project: {
                    orcredit: 1,
                    objId: {
                        $toObjectId: "$finceId"
                    },
                    time: {
                        $toLong: '$credit_time'
                    },

                },

            },
            {
                $match:this.getMatch("4", payload),

            },
            {
                $lookup: {
                    from: 'stock_need',
                    localField: 'objId',
                    foreignField: '_id',
                    as: 'stock_needs',

                },

            },
            {
                $unwind: {
                    path: '$stock_needs',
                    preserveNullAndEmptyArrays: false,

                },

            },
            {
                $lookup: {
                    from: 'company_identify',
                    localField: 'stock_needs.userid',
                    foreignField: 'uid',
                    as: 'company_identifys',

                },

            },
            {
                $unwind: {
                    path: '$company_identifys',
                    preserveNullAndEmptyArrays: false,

                },

            },
            {
                $group: {
                    _id: '$company_identifys.belong_addr_city',
                    value: {
                        $sum: 1,

                    },

                }
            },
            {
                $sort: {
                    'value': - 1,

                }
            },
            {
                $project: {
                    _id: 0,
                    code: '$_id',
                    value: 1
                },

            },

        ];
        const iAgg = [
            {
                $project: {
                    orcredit: '$creditStatus',
                    objId: {
                        $toObjectId: "$intelligentId"
                    },
                    time: {
                        $toLong: '$credit_time'
                    },

                },

            },
            {
                $match:this.getMatch("4", payload),

            },
            {
                $lookup: {
                    from: 'intelligent_docking',
                    localField: 'objId',
                    foreignField: '_id',
                    as: 'intelligent_dockings',

                },

            },
            {
                $unwind: {
                    path: '$intelligent_dockings',
                    preserveNullAndEmptyArrays: false,

                },

            },
            {
                $lookup: {
                    from: 'company_identify',
                    localField: 'intelligent_dockings.uid',
                    foreignField: 'uid',
                    as: 'company_identifys',

                },

            },
            {
                $unwind: {
                    path: '$company_identifys',
                    preserveNullAndEmptyArrays: false,

                },

            },
            {
                $group: {
                    _id: '$company_identifys.belong_addr_city',
                    value: {
                        $sum: 1,

                    },

                }
            },
            {
                $sort: {
                    'value': - 1,

                }
            },
            {
                $project: {
                    _id: 0,
                    code: '$_id',
                    value: 1
                },

            },

        ];
        let cData = await this.fModel.aggregate(cAgg);
        let sData = await this.fModel.aggregate(sAgg);
        let iData = await this.intelligentFollowModel.aggregate(iAgg);
        let tempData = [...cData, ...sData, ...iData];

        let regionArray = await this.dModel.find({type:'dz',pcode: '220000'});
        let regionTotal = await this.dModel.find({type:'dz',pcode: '220000'}).countDocuments();

        let data = this.formatAddData(regionArray, tempData);

        let companyTotal = 0;
        data.forEach((item) => {
            companyTotal += item.value;
        });
        return {data,companyTotal,regionTotal};
    }

    // 企业发布需求
    async  needCount(payload) {

        let dateType = payload.dateType || '2';
        let {startTime, endTime} = this.getTime(payload, dateType);
        let timeArray = this.getTimeArray(startTime, endTime, dateType);

        const cAgg = [

            {
                $project: {
                    status: 1,
                    money: {
                        $toDouble: '$money'
                    },
                    time: {
                        $toLong: '$meta.createdAt'
                    },
                    year: {
                        $year: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },
                    month: {
                        $month: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },
                    day: {
                        $dayOfMonth: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },

                },

            },
            {
                $match: this.getTimeMatch("5", {startTime, endTime}, payload),

            },
            {
                $group: this.getTimeGroup("5", dateType)
            },
            {
                $sort: this.getTimeSort(dateType)
            },
            {
                $project: {
                    _id: 0,
                    value: 1,
                    label: this.getTimeLabel(dateType)
                },

            },

        ];

        const sAgg = [

            {
                $project: {
                    status: 1,
                    money: {
                        $toDouble: '$stock_money'
                    },
                    time: {
                        $toLong: '$meta.createdAt'
                    },
                    year: {
                        $year: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },
                    month: {
                        $month: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },
                    day: {
                        $dayOfMonth: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },

                },

            },
            {
                $match: this.getTimeMatch("5", {startTime, endTime}, payload),

            },
            {
                $group: this.getTimeGroup("5", dateType)
            },
            {
                $sort: this.getTimeSort(dateType)
            },
            {
                $project: {
                    _id: 0,
                    value: 1,
                    label: this.getTimeLabel(dateType)
                },

            },

        ];

        const iAgg = [

            {
                $project: {
                    time: {
                        $toLong: '$meta.createdAt'
                    },
                    year: {
                        $year: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },
                    month: {
                        $month: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },
                    day: {
                        $dayOfMonth: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },

                },

            },
            {
                $match: this.getTimeMatch("10", {startTime, endTime}, payload),

            },
            {
                $group: this.getTimeGroup("10", dateType)
            },
            {
                $sort: this.getTimeSort(dateType)
            },
            {
                $project: {
                    _id: 0,
                    value: 1,
                    label: this.getTimeLabel(dateType)
                },

            },

        ];

        let cData = await this.cModel.aggregate(cAgg);
        let sData = await this.sModel.aggregate(sAgg);
        let iData = await this.intelligentDockingModel.aggregate(iAgg);
        let tempData = [...cData, ...sData, ...iData];
        let data = this.formatTimeData(timeArray, tempData);
        return data;
    }

    // 金融产品
    async  financialProducts(payload) {

        let dateType = payload.dateType || '2';
        let {startTime, endTime} = this.getTime(payload, dateType);
        let timeArray = this.getTimeArray(startTime, endTime, dateType);

        const loanProAgg = [

            {
                $project: {
                    status: 1,
                    time: {
                        $toLong: '$meta.createdAt'
                    },
                    year: {
                        $year: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },
                    month: {
                        $month: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },
                    day: {
                        $dayOfMonth: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },

                },

            },
            {
                $match:this.getTimeMatch("6", {startTime, endTime}, payload),

            },
            {
                $group: this.getTimeGroup("6", dateType)
            },
            {
                $sort: this.getTimeSort(dateType)
            },
            {
                $project: {
                    _id: 0,
                    value: 1,
                    label: this.getTimeLabel(dateType)
                },

            },

        ];
        const financeClaimsAgg = [

            {
                $project: {
                    status: 1,
                    time: {
                        $toLong: '$meta.createdAt'
                    },
                    year: {
                        $year: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },
                    month: {
                        $month: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },
                    day: {
                        $dayOfMonth: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },

                },

            },
            {
                $match:this.getTimeMatch("7", {startTime, endTime}, payload),

            },
            {
                $group: this.getTimeGroup("7", dateType)
            },
            {
                $sort: this.getTimeSort(dateType)
            },
            {
                $project: {
                    _id: 0,
                    value: 1,
                    label: this.getTimeLabel(dateType)
                },

            },

        ];
        const manageMoneyAgg = [

            {
                $project: {
                    status: 1,
                    time: {
                        $toLong: '$meta.createdAt'
                    },
                    year: {
                        $year: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },
                    month: {
                        $month: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },
                    day: {
                        $dayOfMonth: {
                            $toDate: {
                                $add: [{
                                    $toLong: '$meta.createdAt'
                                }, 28800000],

                            },

                        },

                    },

                },

            },
            {
                $match:this.getTimeMatch("8", {startTime, endTime}, payload),

            },
            {
                $group: this.getTimeGroup("8", dateType)
            },
            {
                $sort: this.getTimeSort(dateType)
            },
            {
                $project: {
                    _id: 0,
                    value: 1,
                    label: this.getTimeLabel(dateType)
                },

            },

        ];

        let loanProData = await this.loanProModel.aggregate(loanProAgg);
        let financeClaimsData = await this.financeClaimsModel.aggregate(financeClaimsAgg);
        let manageMoneyData = await this.manageMoneyModel.aggregate(manageMoneyAgg);

        let tempData = [...loanProData, ...financeClaimsData, ...manageMoneyData];
        let data = this.formatTimeData(timeArray, tempData);
        return data;
    }

    // 服务金融机构
    async  financialInstitution(payload) {

        let {skip = 0, limit = 10} = payload;
        let match = {};
        if (payload.name) {
            match.name = {$regex: payload.name, $options: '$i'};
        }
        if (payload.type) {
            match.type = payload.type;
        }
        if (payload.status) {
            match.status = payload.status;
        }
        let sort = {};
        if (payload.sort && payload.asc) {
            sort[payload.sort] = Number.parseInt(payload.asc);
        } else {
            sort = {'meta.createdAt': -1};
        }

        const total = await this.institutionModel.find(match).countDocuments();
        const data = await this.institutionModel.find(match).sort(sort).skip(Number.parseInt(skip)).limit(Number.parseInt(limit));

        return {
            data,
            total,
        };
    }

    // 首页查询
    async  pageSelect(payload) {

        let registerCompany = await this.companyidentifyModel.find({'status':'1'}).countDocuments();
        let financialInstitution = await this.institutionModel.find().countDocuments();
        let temp1 = await this.loanProModel.find({'status':'0'}).countDocuments();
        let temp2 = await this.financeClaimsModel.find({'status':'1'}).countDocuments();
        let temp3 = await this.manageMoneyModel.find({'status':'1'}).countDocuments();
        let financialProduct = temp1 + temp2 + temp3;
        let temp4 = await this.cModel.find({'status':'0'}).countDocuments();
        let temp5 = await this.sModel.find({'status':'0'}).countDocuments();
        let tempAdd1 = await this.intelligentDockingModel.find().countDocuments();
        let demandCount = temp4 + temp5 + tempAdd1;
        let temp6 = 0;
        let temp7 = 0;
        let tempAdd2 = 0;
        let data6 = await this.cModel.aggregate([

            {
                $project: {
                    status: 1,
                    money: {
                        $toDouble: '$money'
                    },
                },

            },
            {
                $match:
                    {
                        $expr:
                            {
                                $and:
                                    [
                                        {
                                            $eq: ['$status', '0'],

                                        },

                                    ],

                            },

                    },

            },
            {
                $group: {
                    _id: null,
                    value: {
                        $sum: '$money',

                    },

                }
            },
        ]);
        if(data6.length > 0){
            temp6 = data6[0].value;
        }
        let data7 = await this.sModel.aggregate([

            {
                $project: {
                    status: 1,
                    money: {
                        $toDouble: '$stock_money'
                    },
                },

            },
            {
                $match:
                    {
                        $expr:
                            {
                                $and:
                                    [
                                        {
                                            $eq: ['$status', '0'],

                                        },

                                    ],

                            },

                    },

            },
            {
                $group: {
                    _id: null,
                    value: {
                        $sum: '$money',

                    },

                }
            },
        ]);
        if(data7.length > 0){
            temp7 = data7[0].value;
        }
        let dataAdd2 = await this.intelligentDockingModel.aggregate([

            {
                $project: {
                    money: {
                        $toDouble: '$money'
                    },
                },

            },
            {
                $group: {
                    _id: null,
                    value: {
                        $sum: '$money',

                    },

                }
            },
        ]);
        if(dataAdd2.length > 0){
            tempAdd2 = dataAdd2[0].value;
        }
        let demandMoney = temp6 + temp7 + tempAdd2;
        let tempAdd3 = await this.fModel.find({'orcredit':'1'}).countDocuments();
        let tempAdd4 = await this.intelligentFollowModel.find({'creditStatus':'1'}).countDocuments();
        let helpCompany = tempAdd3 + tempAdd4;
        let temp8 = 0;
        let tempAdd5 = 0;
        let data8 = await this.fModel.aggregate([
            {
                $project: {
                    orcredit: 1,
                    money: {
                        $toDouble: '$credit_money'
                    }
                },

            },
            {
                $match: {
                    $expr:
                        {
                            $and:
                                [
                                    {
                                        $eq: ['$orcredit', '1'],

                                    },

                                ],

                        },

                },

            },
            {
                $group: {
                    _id: null,
                    value: {
                        $sum: '$money',

                    },

                }
            },

        ]);
        let dataAdd5 = await this.intelligentFollowModel.aggregate([
            {
                $project: {
                    orcredit: '$creditStatus',
                    money: {
                        $toDouble: '$credit_money'
                    }
                },

            },
            {
                $match: {
                    $expr:
                        {
                            $and:
                                [
                                    {
                                        $eq: ['$orcredit', '1'],

                                    },

                                ],

                        },

                },

            },
            {
                $group: {
                    _id: null,
                    value: {
                        $sum: '$money',

                    },

                }
            },

        ]);
        if(data8.length > 0){
            temp8 = data8[0].value;
        }
        if(dataAdd5.length > 0){
            tempAdd5 = dataAdd5[0].value;
        }
        let solutionFinancing = temp8 + tempAdd5;

        return {
            registerCompany,
            financialInstitution,
            financialProduct,
            demandCount,
            demandMoney,
            helpCompany,
            solutionFinancing
        };
    }

    // 银行统计
    async bank(payload) {

        let {skip = 0, limit = 10} = payload;

        let dataAgg = [
            {
                $lookup:
                    {
                        from: "t_finance_follow",
                        let: {
                            jg_id: {
                                $toString: "$_id"
                            }
                        },
                        pipeline: [
                            {
                                $match:
                                    {
                                        $expr:
                                            {
                                                $and:
                                                    [
                                                        {
                                                            $eq: ['$userid', "$$jg_id"]
                                                        },

                                                    ]
                                            }
                                    }
                            },

                        ],
                        as: "t_finance_follows"
                    }
            },
            {
                $unwind: {
                    path: '$t_finance_follows',
                    preserveNullAndEmptyArrays: true,

                },

            },
            {
                $group: {
                    _id: '$name',
                    id: {
                        $first: "$_id"
                    },
                    name: {
                        $first: "$name"
                    },
                    help_count1: {
                        $sum: {
                            $cond: [{
                                $eq: ['$t_finance_follows.orcredit', '1']
                            }, 1, 0],

                        }
                    },
                    receive_count1: {
                        $sum: {
                            $cond: [{
                                $eq: ['$t_finance_follows.orcredit', '0']
                            }, 1, 0],

                        }
                    },
                    approval_count1: {
                        $sum: {
                            $cond: [{
                                $eq: ['$t_finance_follows.orcredit', '2']
                            }, 1, 0],

                        }
                    },
                    refuse_count1: {
                        $sum: {
                            $cond: [{
                                $eq: ['$t_finance_follows.orcredit', '3']
                            }, 1, 0],

                        }
                    },
                    sum_count1: {
                        $sum: {
                            $cond: [{
                                $eq: ['$t_finance_follows.orcredit', '1']
                            }, '$t_finance_follows.credit_money', 0],

                        }
                    },
                    sum_time1: {
                        $sum: {
                            $cond: [{
                                $eq: ['$t_finance_follows.orcredit', '1']
                            }, '$t_finance_follows.accept_time', 0],

                        }
                    },

                }
            },
            {
                $lookup:
                    {
                        from: "intelligent_follow",
                        let: {
                            jg_id: {
                                $toString: "$id"
                            }
                        },
                        pipeline: [
                            {
                                $match:
                                    {
                                        $expr:
                                            {
                                                $and:
                                                    [
                                                        {
                                                            $eq: ['$uid', "$$jg_id"]
                                                        },

                                                    ]
                                            }
                                    }
                            },

                        ],
                        as: "intelligent_follows"
                    }
            },
            {
                $unwind: {
                    path: '$intelligent_follows',
                    preserveNullAndEmptyArrays: true,

                },

            },
            {
                $group: {
                    _id: '$name',
                    id: {
                        $first: "$id"
                    },
                    help_count1: {
                        $first: "$help_count1"
                    },
                    receive_count1: {
                        $first: "$receive_count1"
                    },
                    approval_count1: {
                        $first: "$approval_count1"
                    },
                    refuse_count1: {
                        $first: "$refuse_count1"
                    },
                    sum_count1: {
                        $first: "$sum_count1"
                    },
                    sum_time1: {
                        $first: "$sum_time1"
                    },
                    help_count2: {
                        $sum: {
                            $cond: [{
                                $eq: ['$intelligent_follows.creditStatus', '1']
                            }, 1, 0],

                        }
                    },
                    receive_count2: {
                        $sum: {
                            $cond: [{
                                $eq: ['$intelligent_follows.creditStatus', '0']
                            }, 1, 0],

                        }
                    },
                    approval_count2: {
                        $sum: {
                            $cond: [{
                                $eq: ['$intelligent_follows.creditStatus', '2']
                            }, 1, 0],

                        }
                    },
                    refuse_count2: {
                        $sum: {
                            $cond: [{
                                $eq: ['$intelligent_follows.creditStatus', '3']
                            }, 1, 0],

                        }
                    },
                    sum_count2: {
                        $sum: {
                            $cond: [{
                                $eq: ['$intelligent_follows.creditStatus', '1']
                            }, '$intelligent_follows.credit_money', 0],

                        }
                    },
                    sum_time2: {
                        $sum: {
                            $cond: [{
                                $eq: ['$intelligent_follows.creditStatus', '1']
                            }, '$intelligent_follows.accept_time', 0],

                        }
                    },

                }
            },
            {
                $lookup:
                    {
                        from: "claim_need",
                        let: {
                            jg_id: {
                                $toString: "$id"
                            }
                        },
                        pipeline: [
                            {
                                $match:
                                    {
                                        $expr:
                                            {
                                                $and:
                                                    [
                                                        {
                                                            $eq: ['$status', "0"],
                                                        },
                                                        {
                                                            $eq: ['$jg_id', "$$jg_id"]
                                                        },

                                                    ]
                                            }
                                    }
                            },

                        ],
                        as: "claim_needs"
                    }
            },
            {
                $lookup:
                    {
                        from: "intelligent_docking",
                        let: {
                            jg_id: {
                                $toString: "$id"
                            }
                        },
                        pipeline: [
                            {
                                $match:
                                    {
                                        $expr:
                                            {
                                                $and:
                                                    [
                                                        {
                                                            $eq: ['$jg_id', "$$jg_id"]
                                                        },

                                                    ]
                                            }
                                    }
                            },

                        ],
                        as: "intelligent_dockings"
                    }
            },
            {
                $project: {
                    id: 1,
                    help_count1: 1,
                    receive_count1: 1,
                    approval_count1: 1,
                    refuse_count1: 1,
                    sum_count1: 1,
                    sum_time1: 1,
                    help_count2: 1,
                    receive_count2: 1,
                    approval_count2: 1,
                    refuse_count2: 1,
                    sum_count2: 1,
                    sum_time2: 1,
                    push_count1: {
                        $size: "$claim_needs"
                    },
                    push_count2: {
                        $size: "$intelligent_dockings"
                    },

                }
            },
            {
                $project: {
                    _id: 0,
                    bank_name: '$_id',
                    push_count: {
                        $add: ["$push_count1", "$push_count2"]
                    },
                    //                    receive_count:{ $add: [ "$receive_count1", "$receive_count2" ] },
                    approval_count: {
                        $add: ["$approval_count1", "$approval_count2"]
                    },
                    help_count: {
                        $add: ["$help_count1", "$help_count2"]
                    },
                    refuse_count: {
                        $add: ["$refuse_count1", "$refuse_count2"]
                    },
                    sum_money: {
                        $add: ["$sum_count1", "$sum_count2"]
                    },
                    avg_money: {
                        $cond: {
                            if : {
                                $eq: [{
                                    $add: ["$help_count1", "$help_count2"]
                                }, 0]
                            },
                            then: 0,
                            else : {
                                $divide: [{
                                    $add: ["$sum_count1", "$sum_count2"]
                                }, {
                                    $add: ["$help_count1", "$help_count2"]
                                }]
                            },

                        }
                    },
                    avg_time: {
                        $cond: {
                            if : {
                                $eq: [{
                                    $add: ["$help_count1", "$help_count2"]
                                }, 0]
                            },
                            then: 0,
                            else : {
                                $divide: [{
                                    $add: ["$sum_time1", "$sum_time2"]
                                }, {
                                    $multiply: [{
                                        $add: ["$help_count1", "$help_count2"]
                                    }, 86400000]
                                }]
                            },

                        }
                    },
                    success_probability: {
                        $cond: {
                            if : {
                                $eq: [{
                                    $add: ["$help_count1", "$help_count2", "$refuse_count1", "$refuse_count2"]
                                }, 0]
                            },
                            then: 0,
                            else : {
                                $multiply: [{
                                    $divide: [{
                                        $add: ["$help_count1", "$help_count2"]
                                    }, {
                                        $add: ["$help_count1", "$help_count2", "$refuse_count1", "$refuse_count2"]
                                    }]
                                }, 100]
                            },

                        }
                    },

                }
            },
            {
                $sort: {success_probability:-1}
            },
            {
                $skip: Number.parseInt(skip),
            },
            {
                $limit:Number.parseInt(limit),
            },
        ];
        let totalAgg =  [
            {
                $lookup:
                    {
                        from: "t_finance_follow",
                        let: {
                            jg_id: {
                                $toString: "$_id"
                            }
                        },
                        pipeline: [
                            {
                                $match:
                                    {
                                        $expr:
                                            {
                                                $and:
                                                    [
                                                        {
                                                            $eq: ['$userid', "$$jg_id"]
                                                        },

                                                    ]
                                            }
                                    }
                            },

                        ],
                        as: "t_finance_follows"
                    }
            },
            {
                $unwind: {
                    path: '$t_finance_follows',
                    preserveNullAndEmptyArrays: true,

                },

            },
            {
                $group: {
                    _id: '$name',
                    id: {
                        $first: "$_id"
                    },
                    name: {
                        $first: "$name"
                    },
                    help_count1: {
                        $sum: {
                            $cond: [{
                                $eq: ['$t_finance_follows.orcredit', '1']
                            }, 1, 0],

                        }
                    },
                    receive_count1: {
                        $sum: {
                            $cond: [{
                                $eq: ['$t_finance_follows.orcredit', '0']
                            }, 1, 0],

                        }
                    },
                    approval_count1: {
                        $sum: {
                            $cond: [{
                                $eq: ['$t_finance_follows.orcredit', '2']
                            }, 1, 0],

                        }
                    },
                    refuse_count1: {
                        $sum: {
                            $cond: [{
                                $eq: ['$t_finance_follows.orcredit', '3']
                            }, 1, 0],

                        }
                    },
                    sum_count1: {
                        $sum: {
                            $cond: [{
                                $eq: ['$t_finance_follows.orcredit', '1']
                            }, '$t_finance_follows.credit_money', 0],

                        }
                    },
                    sum_time1: {
                        $sum: {
                            $cond: [{
                                $eq: ['$t_finance_follows.orcredit', '1']
                            }, '$t_finance_follows.accept_time', 0],

                        }
                    },

                }
            },
            {
                $lookup:
                    {
                        from: "intelligent_follow",
                        let: {
                            jg_id: {
                                $toString: "$id"
                            }
                        },
                        pipeline: [
                            {
                                $match:
                                    {
                                        $expr:
                                            {
                                                $and:
                                                    [
                                                        {
                                                            $eq: ['$uid', "$$jg_id"]
                                                        },

                                                    ]
                                            }
                                    }
                            },

                        ],
                        as: "intelligent_follows"
                    }
            },
            {
                $unwind: {
                    path: '$intelligent_follows',
                    preserveNullAndEmptyArrays: true,

                },

            },
            {
                $group: {
                    _id: '$name',
                    id: {
                        $first: "$id"
                    },
                    help_count1: {
                        $first: "$help_count1"
                    },
                    receive_count1: {
                        $first: "$receive_count1"
                    },
                    approval_count1: {
                        $first: "$approval_count1"
                    },
                    refuse_count1: {
                        $first: "$refuse_count1"
                    },
                    sum_count1: {
                        $first: "$sum_count1"
                    },
                    sum_time1: {
                        $first: "$sum_time1"
                    },
                    help_count2: {
                        $sum: {
                            $cond: [{
                                $eq: ['$intelligent_follows.creditStatus', '1']
                            }, 1, 0],

                        }
                    },
                    receive_count2: {
                        $sum: {
                            $cond: [{
                                $eq: ['$intelligent_follows.creditStatus', '0']
                            }, 1, 0],

                        }
                    },
                    approval_count2: {
                        $sum: {
                            $cond: [{
                                $eq: ['$intelligent_follows.creditStatus', '2']
                            }, 1, 0],

                        }
                    },
                    refuse_count2: {
                        $sum: {
                            $cond: [{
                                $eq: ['$intelligent_follows.creditStatus', '3']
                            }, 1, 0],

                        }
                    },
                    sum_count2: {
                        $sum: {
                            $cond: [{
                                $eq: ['$intelligent_follows.creditStatus', '1']
                            }, '$intelligent_follows.credit_money', 0],

                        }
                    },
                    sum_time2: {
                        $sum: {
                            $cond: [{
                                $eq: ['$intelligent_follows.creditStatus', '1']
                            }, '$intelligent_follows.accept_time', 0],

                        }
                    },

                }
            },
            {
                $lookup:
                    {
                        from: "claim_need",
                        let: {
                            jg_id: {
                                $toString: "$id"
                            }
                        },
                        pipeline: [
                            {
                                $match:
                                    {
                                        $expr:
                                            {
                                                $and:
                                                    [
                                                        {
                                                            $eq: ['$status', "0"],
                                                        },
                                                        {
                                                            $eq: ['$jg_id', "$$jg_id"]
                                                        },

                                                    ]
                                            }
                                    }
                            },

                        ],
                        as: "claim_needs"
                    }
            },
            {
                $lookup:
                    {
                        from: "intelligent_docking",
                        let: {
                            jg_id: {
                                $toString: "$id"
                            }
                        },
                        pipeline: [
                            {
                                $match:
                                    {
                                        $expr:
                                            {
                                                $and:
                                                    [
                                                        {
                                                            $eq: ['$jg_id', "$$jg_id"]
                                                        },

                                                    ]
                                            }
                                    }
                            },

                        ],
                        as: "intelligent_dockings"
                    }
            },
            {
                $project: {
                    id: 1,
                    help_count1: 1,
                    receive_count1: 1,
                    approval_count1: 1,
                    refuse_count1: 1,
                    sum_count1: 1,
                    sum_time1: 1,
                    help_count2: 1,
                    receive_count2: 1,
                    approval_count2: 1,
                    refuse_count2: 1,
                    sum_count2: 1,
                    sum_time2: 1,
                    push_count1: {
                        $size: "$claim_needs"
                    },
                    push_count2: {
                        $size: "$intelligent_dockings"
                    },

                }
            },
            {
                $project: {
                    _id: 0,
                    bank_name: '$_id',
                    push_count: {
                        $add: ["$push_count1", "$push_count2"]
                    },
                    //                    receive_count:{ $add: [ "$receive_count1", "$receive_count2" ] },
                    approval_count: {
                        $add: ["$approval_count1", "$approval_count2"]
                    },
                    help_count: {
                        $add: ["$help_count1", "$help_count2"]
                    },
                    refuse_count: {
                        $add: ["$refuse_count1", "$refuse_count2"]
                    },
                    sum_money: {
                        $add: ["$sum_count1", "$sum_count2"]
                    },
                    avg_money: {
                        $cond: {
                            if : {
                                $eq: [{
                                    $add: ["$help_count1", "$help_count2"]
                                }, 0]
                            },
                            then: 0,
                            else : {
                                $divide: [{
                                    $add: ["$sum_count1", "$sum_count2"]
                                }, {
                                    $add: ["$help_count1", "$help_count2"]
                                }]
                            },

                        }
                    },
                    avg_time: {
                        $cond: {
                            if : {
                                $eq: [{
                                    $add: ["$help_count1", "$help_count2"]
                                }, 0]
                            },
                            then: 0,
                            else : {
                                $divide: [{
                                    $add: ["$sum_time1", "$sum_time2"]
                                }, {
                                    $multiply: [{
                                        $add: ["$help_count1", "$help_count2"]
                                    }, 86400000]
                                }]
                            },

                        }
                    },
                    success_probability: {
                        $cond: {
                            if : {
                                $eq: [{
                                    $add: ["$help_count1", "$help_count2", "$refuse_count1", "$refuse_count2"]
                                }, 0]
                            },
                            then: 0,
                            else : {
                                $multiply: [{
                                    $divide: [{
                                        $add: ["$help_count1", "$help_count2"]
                                    }, {
                                        $add: ["$help_count1", "$help_count2", "$refuse_count1", "$refuse_count2"]
                                    }]
                                }, 100]
                            },

                        }
                    },

                }
            },
            {
                $count: 'total',
            },
        ];

        const data = await this.institutionModel.aggregate(dataAgg);
        const totalTemp = await this.institutionModel.aggregate(totalAgg);

        if (totalTemp.length == 0) {
            totalTemp.push({ total: 0 });
        }
        const [{ total }] = totalTemp;

        return {
            data,
            total,
        };
    }

    /*// 银行统计
    async bank(payload) {

        let {skip = 0, limit = 10} = payload;

        let dataAgg =  [
            {
                $lookup:
                    {
                        from: "t_finance_follow",
                        let: {
                            jg_id: {
                                $toString: "$_id"
                            }
                        },
                        pipeline: [
                            {
                                $match:
                                    {
                                        $expr:
                                            {
                                                $and:
                                                    [
                                                        {
                                                            $eq: ['$userid', "$$jg_id"]
                                                        },

                                                    ]
                                            }
                                    }
                            },

                        ],
                        as: "t_finance_follows"
                    }
            },
            {
                $unwind: {
                    path: '$t_finance_follows',
                    preserveNullAndEmptyArrays: true,

                },

            },
            {
                $group: {
                    _id: '$name',
                    id: {
                        $first: "$_id"
                    },
                    name: {
                        $first: "$name"
                    },
                    help_count1: {
                        $sum: {
                            $cond: [{
                                $eq: ['$t_finance_follows.orcredit', '1']
                            }, 1, 0],

                        }
                    },
                    ing_count1: {
                        $sum: {
                            $cond: [{
                                $eq: ['$t_finance_follows.orcredit', '0']
                            }, 1, 0],

                        }
                    },
                    ing_count2: {
                        $sum: {
                            $cond: [{
                                $eq: ['$t_finance_follows.orcredit', '2']
                            }, 1, 0],

                        }
                    },
                    refuse_count1: {
                        $sum: {
                            $cond: [{
                                $eq: ['$t_finance_follows.orcredit', '3']
                            }, 1, 0],

                        }
                    },

                }
            },
            {
                $lookup:
                    {
                        from: "intelligent_follow",
                        let: {
                            jg_id: {
                                $toString: "$id"
                            }
                        },
                        pipeline: [
                            {
                                $match:
                                    {
                                        $expr:
                                            {
                                                $and:
                                                    [
                                                        {
                                                            $eq: ['$uid', "$$jg_id"]
                                                        },

                                                    ]
                                            }
                                    }
                            },

                        ],
                        as: "intelligent_follows"
                    }
            },
            {
                $unwind: {
                    path: '$intelligent_follows',
                    preserveNullAndEmptyArrays: true,

                },

            },
            {
                $group: {
                    _id: '$name',
                    help_count1: {
                        $first: "$help_count1"
                    },
                    help_count2: {
                        $sum: {
                            $cond: [{
                                $eq: ['$intelligent_follows.creditStatus', '1']
                            }, 1, 0],

                        }
                    },
                    ing_count1: {
                        $first: "$ing_count1"
                    },
                    ing_count2: {
                        $first: "$ing_count2"
                    },
                    ing_count3: {
                        $sum: {
                            $cond: [{
                                $eq: ['$intelligent_follows.creditStatus', '0']
                            }, 1, 0],

                        }
                    },
                    ing_count4: {
                        $sum: {
                            $cond: [{
                                $eq: ['$intelligent_follows.creditStatus', '2']
                            }, 1, 0],

                        }
                    },
                    refuse_count1: {
                        $first: "$refuse_count1"
                    },
                    refuse_count2: {
                        $sum: {
                            $cond: [{
                                $eq: ['$intelligent_follows.creditStatus', '3']
                            }, 1, 0],

                        }
                    },

                }
            },
            {
                $project: {
                    _id : 0,
                    bank_name: '$_id',
                    help_count: { $add: [ "$help_count1", "$help_count2" ] },
                    ing_count: { $add: [ "$ing_count1", "$ing_count2" , "$ing_count3" , "$ing_count4" ] },
                    refuse_count: { $add: [ "$refuse_count1", "$refuse_count2" ] },

                }
            },
            {
                $skip: Number.parseInt(skip),
            },
            {
                $limit:Number.parseInt(limit),
            },

        ];
        let totalAgg =  [
            {
                $lookup:
                    {
                        from: "t_finance_follow",
                        let: {
                            jg_id: {
                                $toString: "$_id"
                            }
                        },
                        pipeline: [
                            {
                                $match:
                                    {
                                        $expr:
                                            {
                                                $and:
                                                    [
                                                        {
                                                            $eq: ['$userid', "$$jg_id"]
                                                        },

                                                    ]
                                            }
                                    }
                            },

                        ],
                        as: "t_finance_follows"
                    }
            },
            {
                $unwind: {
                    path: '$t_finance_follows',
                    preserveNullAndEmptyArrays: true,

                },

            },
            {
                $group: {
                    _id: '$name',
                    id: {
                        $first: "$_id"
                    },
                    name: {
                        $first: "$name"
                    },
                    help_count1: {
                        $sum: {
                            $cond: [{
                                $eq: ['$t_finance_follows.orcredit', '1']
                            }, 1, 0],

                        }
                    },
                    ing_count1: {
                        $sum: {
                            $cond: [{
                                $eq: ['$t_finance_follows.orcredit', '0']
                            }, 1, 0],

                        }
                    },
                    ing_count2: {
                        $sum: {
                            $cond: [{
                                $eq: ['$t_finance_follows.orcredit', '2']
                            }, 1, 0],

                        }
                    },
                    refuse_count1: {
                        $sum: {
                            $cond: [{
                                $eq: ['$t_finance_follows.orcredit', '3']
                            }, 1, 0],

                        }
                    },

                }
            },
            {
                $lookup:
                    {
                        from: "intelligent_follow",
                        let: {
                            jg_id: {
                                $toString: "$id"
                            }
                        },
                        pipeline: [
                            {
                                $match:
                                    {
                                        $expr:
                                            {
                                                $and:
                                                    [
                                                        {
                                                            $eq: ['$uid', "$$jg_id"]
                                                        },

                                                    ]
                                            }
                                    }
                            },

                        ],
                        as: "intelligent_follows"
                    }
            },
            {
                $unwind: {
                    path: '$intelligent_follows',
                    preserveNullAndEmptyArrays: true,

                },

            },
            {
                $group: {
                    _id: '$name',
                    help_count1: {
                        $first: "$help_count1"
                    },
                    help_count2: {
                        $sum: {
                            $cond: [{
                                $eq: ['$intelligent_follows.creditStatus', '1']
                            }, 1, 0],

                        }
                    },
                    ing_count1: {
                        $first: "$ing_count1"
                    },
                    ing_count2: {
                        $first: "$ing_count2"
                    },
                    ing_count3: {
                        $sum: {
                            $cond: [{
                                $eq: ['$intelligent_follows.creditStatus', '0']
                            }, 1, 0],

                        }
                    },
                    ing_count4: {
                        $sum: {
                            $cond: [{
                                $eq: ['$intelligent_follows.creditStatus', '2']
                            }, 1, 0],

                        }
                    },
                    refuse_count1: {
                        $first: "$refuse_count1"
                    },
                    refuse_count2: {
                        $sum: {
                            $cond: [{
                                $eq: ['$intelligent_follows.creditStatus', '3']
                            }, 1, 0],

                        }
                    },

                }
            },
            {
                $project: {
                    _id : 0,
                    bank_name: '$_id',
                    help_count: { $add: [ "$help_count1", "$help_count2" ] },
                    ing_count: { $add: [ "$ing_count1", "$ing_count2" , "$ing_count3" , "$ing_count4" ] },
                    refuse_count: { $add: [ "$refuse_count1", "$refuse_count2" ] },

                }
            },
            {
                $count: 'total',
            },

        ];

        const data = await this.institutionModel.aggregate(dataAgg);
        const totalTemp = await this.institutionModel.aggregate(totalAgg);

        if (totalTemp.length == 0) {
            totalTemp.push({ total: 0 });
        }
        const [{ total }] = totalTemp;

        return {
            data,
            total,
        };
    }*/

    getTime(payload, dateType) {
        if (dateType === '1') {
            let tempYear = moment().get('year');
            let startTime = moment([tempYear]).add(-11, 'years').valueOf();
            if (payload.start_time && payload.end_time) {
                tempYear = moment(Number(payload.end_time)).get('year');
                startTime = Number(payload.start_time);
            }
            let endTime = moment([tempYear]).add(1, 'years').valueOf();
            return {startTime, endTime};
        } else {
            let tempYear = moment().get('year');
            let tempMonth = moment().get('month');
            let startTime = moment([tempYear, tempMonth]).add(-11, 'months').valueOf();
            if (payload.start_time && payload.end_time) {
                tempYear = moment(Number(payload.end_time)).get('year');
                tempMonth = moment(Number(payload.end_time)).get('month');
                startTime = Number(payload.start_time);
            }
            let endTime = moment([tempYear, tempMonth]).add(1, 'months').valueOf();
            return {startTime, endTime};
        }

    }

    getTimeArray(startTime, endTime, dateType) {
        if (dateType === '1') {
            let temp = startTime;
            let timeArray = [];
            while (true) {
                if (temp >= endTime) {
                    break;
                }
                let label = moment(temp).get('year') + '';
                timeArray.push({label: label, value: 0});
                temp = moment(temp).add(1, 'years').valueOf();
            }
            return timeArray;
        } else {
            let temp = startTime;
            let timeArray = [];
            while (true) {
                if (temp >= endTime) {
                    break;
                }
                let tempMonth = moment(temp).get('month') + 1 >= 10 ? (moment(temp).get('month') + 1).toString() : '0' + (moment(temp).get('month') + 1).toString();
                let label = moment(temp).get('year') + '/' + tempMonth;
                timeArray.push({label: label, value: 0});
                temp = moment(temp).add(1, 'months').valueOf();
            }
            return timeArray;
        }
    }

    getTimeMatch(type, reserve, payload) {
        switch (type) {
            case '1':
                let matchA = [];
                return {
                    $expr:
                        {
                            $and:
                                [
                                    {
                                        $gte: ['$time', reserve.startTime],

                                    },
                                    {
                                        $lt: ['$time', reserve.endTime],

                                    },
                                    {
                                        $eq: ['$status', '0'],

                                    },
                                    ...matchA,

                                ],

                        },

                };
            case '2':
                let matchB = [];
                return {
                    $expr:
                        {
                            $and:
                                [
                                    {
                                        $gte: ['$time', reserve.startTime],

                                    },
                                    {
                                        $lt: ['$time', reserve.endTime],

                                    },
                                    {
                                        $eq: ['$orcredit', '1'],

                                    },
                                    ...matchB,

                                ],

                        },

                };
            case '3':
                let matchC = [];
                return {
                    $expr:
                        {
                            $and:
                                [
                                    {
                                        $gte: ['$time', reserve.startTime],

                                    },
                                    {
                                        $lt: ['$time', reserve.endTime],

                                    },
                                    {
                                        $eq: ['$status', '1'],

                                    },
                                    ...matchC,

                                ],

                        },

                };
            case '4':
                let matchD = [];
                return {
                    $expr:
                        {
                            $and:
                                [
                                    {
                                        $gte: ['$time', reserve.startTime],

                                    },
                                    {
                                        $lt: ['$time', reserve.endTime],

                                    },
                                    {
                                        $eq: ['$orcredit', '1'],

                                    },
                                    ...matchD,

                                ],

                        },

                };
            case '5':
                let matchE = [];
                return {
                    $expr:
                        {
                            $and:
                                [
                                    {
                                        $gte: ['$time', reserve.startTime],

                                    },
                                    {
                                        $lt: ['$time', reserve.endTime],

                                    },
                                    {
                                        $eq: ['$status', '0'],

                                    },
                                    ...matchE,

                                ],

                        },

                };
            case '6':
                let matchF = [];
                return {
                    $expr:
                        {
                            $and:
                                [
                                    {
                                        $gte: ['$time', reserve.startTime],

                                    },
                                    {
                                        $lt: ['$time', reserve.endTime],

                                    },
                                    {
                                        $eq: ['$status', '0'],

                                    },
                                    ...matchF,

                                ],

                        },

                };
            case '7':
                let matchG = [];
                return {
                    $expr:
                        {
                            $and:
                                [
                                    {
                                        $gte: ['$time', reserve.startTime],

                                    },
                                    {
                                        $lt: ['$time', reserve.endTime],

                                    },
                                    {
                                        $eq: ['$status', '1'],

                                    },
                                    ...matchG,

                                ],

                        },

                };
            case '8':
                let matchH = [];
                return {
                    $expr:
                        {
                            $and:
                                [
                                    {
                                        $gte: ['$time', reserve.startTime],

                                    },
                                    {
                                        $lt: ['$time', reserve.endTime],

                                    },
                                    {
                                        $eq: ['$status', '1'],

                                    },
                                    ...matchH,

                                ],

                        },

                };
            case '9':
                let matchI = [];
                return {
                    $expr:
                        {
                            $and:
                                [
                                    {
                                        $gte: ['$time', reserve.startTime],

                                    },
                                    {
                                        $lt: ['$time', reserve.endTime],

                                    },
                                    ...matchI,

                                ],

                        },

                };
            case '10':
                let matchJ = [];
                return {
                    $expr:
                        {
                            $and:
                                [
                                    {
                                        $gte: ['$time', reserve.startTime],

                                    },
                                    {
                                        $lt: ['$time', reserve.endTime],

                                    },
                                    ...matchJ,

                                ],

                        },

                };
        }
    }

    getTimeGroup(type, dateType) {
        if (dateType === '1') {
            switch (type) {
                case '1':
                    return {
                        _id: {
                            year: '$year',
                        },
                        value: {
                            $sum: '$money',

                        },

                    }
                case '2':
                    return {
                        _id: {
                            year: '$year',
                        },
                        value: {
                            $sum: '$money',

                        },

                    }
                case '3':
                    return {
                        _id: {
                            year: '$year',

                        },
                        value: {
                            $sum: 1,

                        },

                    };
                case '4':
                    return {
                        _id: {
                            year: '$year',

                        },
                        value: {
                            $sum: 1,

                        },

                    };
                case '5':
                    return {
                        _id: {
                            year: '$year',

                        },
                        value: {
                            $sum: 1,

                        },

                    };
                case '6':
                    return {
                        _id: {
                            year: '$year',

                        },
                        value: {
                            $sum: 1,

                        },

                    };
                case '7':
                    return {
                        _id: {
                            year: '$year',

                        },
                        value: {
                            $sum: 1,

                        },

                    };
                case '8':
                    return {
                        _id: {
                            year: '$year',

                        },
                        value: {
                            $sum: 1,

                        },

                    };
                case '9':
                    return {
                        _id: {
                            year: '$year',
                        },
                        value: {
                            $sum: '$money',

                        },

                    }
                case '10':
                    return {
                        _id: {
                            year: '$year',

                        },
                        value: {
                            $sum: 1,

                        },

                    };

            }

        } else {
            switch (type) {
                case '1':
                    return {
                        _id: {
                            year: '$year',
                            month: '$month',

                        },
                        value: {
                            $sum: '$money',

                        },

                    }
                case '2':
                    return {
                        _id: {
                            year: '$year',
                            month: '$month',

                        },
                        value: {
                            $sum: '$money',

                        },

                    }
                case '3':
                    return {
                        _id: {
                            year: '$year',
                            month: '$month',

                        },
                        value: {
                            $sum: 1,

                        },

                    };
                case '4':
                    return {
                        _id: {
                            year: '$year',
                            month: '$month',

                        },
                        value: {
                            $sum: 1,

                        },

                    };
                case '5':
                    return {
                        _id: {
                            year: '$year',
                            month: '$month',

                        },
                        value: {
                            $sum: 1,

                        },

                    };
                case '6':
                    return {
                        _id: {
                            year: '$year',
                            month: '$month',

                        },
                        value: {
                            $sum: 1,

                        },

                    };
                case '7':
                    return {
                        _id: {
                            year: '$year',
                            month: '$month',

                        },
                        value: {
                            $sum: 1,

                        },

                    };
                case '8':
                    return {
                        _id: {
                            year: '$year',
                            month: '$month',

                        },
                        value: {
                            $sum: 1,

                        },

                    };
                case '9':
                    return {
                        _id: {
                            year: '$year',
                            month: '$month',

                        },
                        value: {
                            $sum: '$money',

                        },

                    }
                case '10':
                    return {
                        _id: {
                            year: '$year',
                            month: '$month',

                        },
                        value: {
                            $sum: 1,

                        },

                    };

            }

        }
    }

    getTimeSort(dateType) {
        if (dateType === '1') {
            return {
                '_id.year': 1,
            }
        } else {
            return {
                '_id.year': 1,
                '_id.month': 1
            }
        }
    }

    getTimeLabel(dateType) {
        if (dateType === '1') {
            return {
                $toString: '$_id.year'
            };
        } else {
            return {
                $concat: [{
                    $toString: '$_id.year'
                }, '/', {
                    $cond: {
                        if: {
                            $gte: ["$_id.month", 10]
                        },
                        then: {
                            $toString: '$_id.month'
                        },
                        else: {
                            $concat: ['0', {
                                $toString: '$_id.month'
                            }]
                        }
                    }
                }]
            };
        }
    }

    formatTimeData(timeArray, tempData) {
        return timeArray.map(timeItem => {
            let label = timeItem.label;
            let value = timeItem.value;
            tempData.forEach(dataItem => {
                if (timeItem.label === dataItem.label) {
                    value += dataItem.value;
                }
            })
            return {label, value};
        });
    }

    getMatch(type, payload) {
        switch (type) {
            case '1':
                let matchA = [];
                if (payload.start_time && payload.end_time) {
                    matchA.push({
                        $gte: ['$time', Number(payload.start_time)],

                    });
                    matchA.push({
                        $lt: ['$time', Number(payload.end_time)],

                    });
                }
                return {
                    $expr:
                        {
                            $and:
                                [
                                    ...matchA,
                                    {
                                        $eq: ['$status', '1'],

                                    },
                                ],

                        },

                };
            case '2':
                let matchB = [];
                if (payload.start_time && payload.end_time) {
                    matchB.push({
                        $gte: ['$time', Number(payload.start_time)],

                    });
                    matchB.push({
                        $lt: ['$time', Number(payload.end_time)],

                    });
                }
                return {
                    $expr:
                        {
                            $and:
                                [
                                    ...matchB,
                                    {
                                        $eq: ['$status', '1'],

                                    },
                                ],

                        },

                };
            case '3':
                let matchC = [];
                if (payload.start_time && payload.end_time) {
                    matchC.push({
                        $gte: ['$time', Number(payload.start_time)],

                    });
                    matchC.push({
                        $lt: ['$time', Number(payload.end_time)],

                    });
                }
                return {
                    $expr:
                        {
                            $and:
                                [
                                    ...matchC,
                                    {
                                        $eq: ['$orcredit', '1'],

                                    },
                                ],

                        },

                };
            case '4':
                let matchD = [];
                if (payload.start_time && payload.end_time) {
                    matchD.push({
                        $gte: ['$time', Number(payload.start_time)],

                    });
                    matchD.push({
                        $lt: ['$time', Number(payload.end_time)],

                    });
                }
                return {
                    $expr:
                        {
                            $and:
                                [
                                    ...matchD,
                                    {
                                        $eq: ['$orcredit', '1'],

                                    },
                                ],

                        },

                };
        }
    }

    formatData(array, data) {
        return array.map(arrayItem => {
            let label = arrayItem.name;
            let value = 0;
            for (let dataItem of data) {
                if (arrayItem._doc.code === dataItem.code) {
                    value = dataItem.value;
                    break;
                }
            }
            return {label, value};
        }).sort(function (a, b) {
            return b.value - a.value
        });
    }

    formatAddData(array, data) {
        return array.map(arrayItem => {
            let label = arrayItem.name;
            let value = 0;
            for (let dataItem of data) {
                if (arrayItem._doc.code === dataItem.code) {
                    value += dataItem.value;
                }
            }
            return {label, value};
        }).sort(function (a, b) {
            return b.value - a.value
        });
    }
}

module.exports = TGovernmentStatisticsService;