Calculation/app/controller/weapp_dashboard_controller.js

'use strict';

const DashboardStats = require('../lib/dashboard_stats');
const auditConst = require('../const/audit');

module.exports = app => {
    class WeappDashboardController extends app.BaseController {
        async workspace(ctx) {
            try {
                let allAuditTenders = await ctx.service.ledgerAudit.getAuditTender(ctx.session.sessionUser.id);
                allAuditTenders = allAuditTenders.filter(item => item.ledger_status !== auditConst.ledger.status.checkNo);
                let allAuditStages = await ctx.service.stageAudit.getAuditStage(ctx.session.sessionUser.id);
                allAuditStages = allAuditStages.filter(item => item.sstatus !== auditConst.stage.status.checkNo);
                let allAuditRevise = await ctx.service.reviseAudit.getAuditRevise(ctx.session.sessionUser.id);
                allAuditRevise = allAuditRevise.filter(item => item.status !== auditConst.revise.status.checkNo);
                const allAuditMaterial = await ctx.service.materialAudit.getAuditMaterial(ctx.session.sessionUser.id);
                let allAuditAdvance = await ctx.service.advanceAudit.getAuditAdvance(ctx.session.sessionUser.id);
                allAuditAdvance = allAuditAdvance.filter(item => item.mstatus !== auditConst.advance.status.checkNo);
                let allAuditChanges = await ctx.service.changeAudit.getAuditChange(ctx.session.sessionUser.id);
                allAuditChanges = allAuditChanges.filter(item => ![auditConst.change.status.checkNo, auditConst.change.status.revise].includes(item.cstatus));
                let allAuditChangeProject = await ctx.service.changeProjectAudit.getAuditChangeProject(ctx.session.sessionUser.id);
                allAuditChangeProject = allAuditChangeProject.filter(item => ![auditConst.changeProject.status.checkNo, auditConst.changeProject.status.revise].includes(item.mstatus));
                let allAuditChangeApply = await ctx.service.changeApplyAudit.getAuditChangeApply(ctx.session.sessionUser.id);
                allAuditChangeApply = allAuditChangeApply.filter(item => [auditConst.changeApply.status.checkNo, auditConst.changeApply.status.revise].includes(item.mstatus));
                let allAuditChangePlan = await ctx.service.changePlanAudit.getAuditChangePlan(ctx.session.sessionUser.id);
                allAuditChangePlan = allAuditChangePlan.filter(item => ![auditConst.changePlan.status.checkNo, auditConst.changePlan.status.revise].includes(item.mstatus));
                // const allAuditPayments = await ctx.service.paymentDetailAudit.getAuditPayment(ctx.session.sessionUser.id);
                // const allAuditStageAss = await ctx.service.stageAuditAss.getAuditStageAss(ctx.session.sessionUser.id);
                // const allAuditFinancials = await ctx.service.financialPayAudit.getAuditFinancial(ctx.session.sessionUser.id);
                const allAuditQualityInspections = await ctx.service.qualityInspectionAudit.getAuditInspection(ctx.session.sessionUser.id);
                const allAuditSafeInspections = await ctx.service.safeInspectionAudit.getAuditInspection(ctx.session.sessionUser.id);
                // const allAuditSafeStage = await ctx.service.safeStageAudit.getAuditStage(ctx.session.sessionUser.id);
                // const allAuditPhasePay = await ctx.service.phasePayAudit.getAuditStage(ctx.session.sessionUser.id);

                const dashboardStatus = {
                    all: 0,
                    dashboard: 0,
                    worry: 0,
                    early: 0,
                    shenpi: {
                        ledger: 0,
                        stage: 0,
                        change: 0,
                        revise: 0,
                        material: 0,
                        advance: 0,
                        changeProject: 0,
                        changeApply: 0,
                        changePlan: 0,
                        payment: 0,
                        financial: 0,
                        inspection: 0,
                        safeInspection: 0,
                        safeStage: 0,
                        phasePay: 0,
                    },
                };
                const subProjects = await ctx.service.subProject.getSubProject(ctx.session.sessionUser.project_id, ctx.session.sessionUser.id, ctx.session.sessionUser.is_admin, true);
                for (const subProject of subProjects) {
                    subProject.page_show = ctx.service.subProject.getPageShow(subProject.page_show);
                }

                const dashboardShenpis = [];
                const auditTenders = await DashboardStats.auditSet(ctx, allAuditTenders, subProjects, dashboardStatus, 'ledger');
                dashboardShenpis.push(...(auditTenders.map(item => ({ ...item, type: 'ledger', subType: 'ledger' }))));
                const auditStages = await DashboardStats.auditSet(ctx, allAuditStages, subProjects, dashboardStatus, 'stage');
                dashboardShenpis.push(...(auditStages.map(item => ({ ...item, type: 'stage', subType: 'stage' }))));
                const auditChanges = await DashboardStats.auditSet(ctx, allAuditChanges, subProjects, dashboardStatus, 'change');
                for (const item of auditChanges) {
                  let sp = null;
                  if (item.spid) {
                      if (ctx.helper._.findIndex(subProjects, { id: item.spid }) !== -1) {
                          sp = ctx.helper._.find(subProjects, { id: item.spid });
                      } else {
                          sp = await ctx.service.subProject.getDataById(item.spid);
                          subProjects.push(sp);
                      }
                  }

                  if (sp && sp.page_show) {
                      if (sp.page_show.openChangeProject) {
                        dashboardShenpis.push({ ...item, type: 'change', subType: 'change' });
                      }
                  }
                }

                const auditRevise = await DashboardStats.auditSet(ctx, allAuditRevise, subProjects, dashboardStatus, 'revise');
                dashboardShenpis.push(...(auditRevise.map(item => ({ ...item, type: 'revise', subType: 'revise' }))));
                const auditMaterial = await DashboardStats.auditSet(ctx, allAuditMaterial, subProjects, dashboardStatus, 'material');
                for (const item of auditMaterial) {
                  let sp = null;
                  if (item.spid) {
                      if (ctx.helper._.findIndex(subProjects, { id: item.spid }) !== -1) {
                          sp = ctx.helper._.find(subProjects, { id: item.spid });
                      } else {
                          sp = await ctx.service.subProject.getDataById(item.spid);
                          subProjects.push(sp);
                      }
                  }
                  if (sp && sp.page_show) {
                      if (sp.page_show.openMaterial) {
                        dashboardShenpis.push({ ...item, type: 'material', subType: 'material' });
                      }
                  }
                }
                const auditAdvance = await DashboardStats.auditSet(ctx, allAuditAdvance, subProjects, dashboardStatus, 'advance');
                dashboardShenpis.push(...(auditAdvance.map(item => ({ ...item, type: 'advance', subType: 'advance' }))));
                const auditChangeProject = await DashboardStats.auditSet(ctx, allAuditChangeProject, subProjects, dashboardStatus, 'changeProject');
                for (const item of auditChangeProject) {
                  let sp = null;
                  if (item.spid) {
                      if (ctx.helper._.findIndex(subProjects, { id: item.spid }) !== -1) {
                          sp = ctx.helper._.find(subProjects, { id: item.spid });
                      } else {
                          sp = await ctx.service.subProject.getDataById(item.spid);
                          subProjects.push(sp);
                      }
                  }
                  if (sp && sp.page_show) {
                      if (sp.page_show.openChangeProject) {
                        dashboardShenpis.push({ ...item, type: 'change', subType: 'changeProject' });
                      }
                  }
                }
                const auditChangeApply = await DashboardStats.auditSet(ctx, allAuditChangeApply, subProjects, dashboardStatus, 'changeApply');
                for (const item of auditChangeApply) {
                  let sp = null;
                  if (item.spid) {
                      if (ctx.helper._.findIndex(subProjects, { id: item.spid }) !== -1) {
                          sp = ctx.helper._.find(subProjects, { id: item.spid });
                      } else {
                          sp = await ctx.service.subProject.getDataById(item.spid);
                          subProjects.push(sp);
                      }
                  }
                  if (sp && sp.page_show) {
                      if (sp.page_show.openChangeApply) {
                        dashboardShenpis.push({ ...item, type: 'change', subType: 'changeApply' });
                      }
                  }
                }
                const auditChangePlan = await DashboardStats.auditSet(ctx, allAuditChangePlan, subProjects, dashboardStatus, 'changePlan');
                for (const item of auditChangePlan) {
                    let sp = null;
                  if (item.spid) {
                      if (ctx.helper._.findIndex(subProjects, { id: item.spid }) !== -1) {
                          sp = ctx.helper._.find(subProjects, { id: item.spid });
                      } else {
                          sp = await ctx.service.subProject.getDataById(item.spid);
                          subProjects.push(sp);
                      }
                  }
                  if (sp && sp.page_show) {
                      if (sp.page_show.openChangePlan) {
                        dashboardShenpis.push({ ...item, type: 'change', subType: 'changePlan' });
                      }
                  }
                }
                // const auditPayments = await DashboardStats.auditSet(ctx, allAuditPayments, subProjects, dashboardStatus, 'payment');
                // dashboardShenpis.push(...auditPayments);
                // const auditStageAss = await DashboardStats.auditSet(ctx, allAuditStageAss, subProjects, dashboardStatus, 'stageAss');
                // dashboardShenpis.push(...auditStageAss);
                // const auditFinancials = await DashboardStats.auditSet(ctx, allAuditFinancials, subProjects, dashboardStatus, 'financial');
                // dashboardShenpis.push(...auditFinancials);
                // const auditInspections = await DashboardStats.auditSet(ctx, allAuditInspections, subProjects, dashboardStatus, 'inspection');
                // dashboardShenpis.push(...auditInspections);
                // const auditQualityInspections = await DashboardStats.auditSet(ctx, allAuditQualityInspections, subProjects, dashboardStatus, 'inspection');
                // dashboardShenpis.push(...(auditQualityInspections.map(item => ({ ...item, type: 'qualityInspection', subType: 'qualityInspection' }))));
                // const auditSafeInspections = await DashboardStats.auditSet(ctx, allAuditSafeInspections, subProjects, dashboardStatus, 'safeInspection');
                // dashboardShenpis.push(...(auditSafeInspections.map(item => ({ ...item, type: 'safeInspection', subType: 'safeInspection' }))));

                // const auditPhasePay = await DashboardStats.auditSet(ctx, allAuditPhasePay, subProjects, dashboardStatus, 'phasePay');
                // dashboardShenpis.push(...auditPhasePay);
                const renderData = {
                    code: 0,
                    msg: '获取成功',
                    data: {
                        dashboardShenpis: ctx.helper._.orderBy(dashboardShenpis, ['start_audit', 'shenpi_time'], ['desc', 'asc']),
                        dashboardStatus: {
                            all: dashboardStatus.all,
                            dashboard: dashboardStatus.dashboard,
                            worry: dashboardStatus.worry,
                            early: dashboardStatus.early,
                        },
                    },
                };

                ctx.body = renderData;
            } catch (error) {
                this.log(error);
                ctx.body = { code: -1, msg: error.toString(), data: null };
            }
        }

    }

    return WeappDashboardController;
};