OperationalService/api/app/lib/controllers/project/index.js

'use strict';

async function appList (ctx) {
   try {
      const models = ctx.fs.dc.models;

      const appRes = await models.App.findAll({

      })
      ctx.status = 200;
      ctx.body = appRes
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         message: typeof error == 'string' ? error : undefined
      }
   }
}

async function pomsProject (ctx) {
   try {
      const models = ctx.fs.dc.models;
      const { clickHouse } = ctx.app.fs
      const { userId, pepUserId, userInfo, pepUserInfo } = ctx.fs.api
      const { limit, page, global, pepId } = ctx.query

      let findOption = {
         where: {
            del: false
         },
         order: [['updateTime', 'desc']],
         distinct: true,
         include: {
            model: models.App,
         }
      }
      if (global && !userInfo.role.includes('SuperAdmin') && !userInfo.role.includes('admin')) {
         findOption.where.id = { $in: userInfo.correlationProject }
      }
      if (pepId) {
         findOption.where.id = pepId
      }
      if (limit) {
         findOption.limit = limit
      }
      if (page && limit) {
         findOption.offset = page * limit
      }

      const proRes = await models.ProjectCorrelation.findAndCountAll(findOption)

      let pepProjectIds = new Set()
      let anxinProjectIds = new Set()
      for (let p of proRes.rows) {
         if (p.pepProjectId) {
            pepProjectIds.add(p.pepProjectId)
         }
         for (let ap of p.anxinProjectId) {
            if (ap) {
               anxinProjectIds.add(ap)
            }
         }
      }
      const pepProjectRes = pepProjectIds.size ?
         await clickHouse.projectManage.query(
            `
            SELECT 
               t_pim_project.id AS id, 
               t_pim_project.project_name AS project_name, 
               t_pim_project.isdelete AS isdelete,
               t_pim_project_construction.construction_status_id AS construction_status_id, 
               t_pim_project_state.construction_status AS construction_status 
            FROM t_pim_project 
               LEFT JOIN t_pim_project_construction 
                  ON t_pim_project.id = t_pim_project_construction.project_id 
               LEFT JOIN t_pim_project_state 
                  ON t_pim_project_construction.construction_status_id = t_pim_project_state.id 
               WHERE id IN (${[...pepProjectIds].join(',')}, -1)
            `
         ).toPromise() :
         []


      const anxinProjectRes = anxinProjectIds.size ?
         await clickHouse.anxinyun.query(`SELECT id,"name",project_state AS projectState FROM t_project WHERE id IN (${[...anxinProjectIds].join(',')},-1)`).toPromise() :
         []


      for (let p of proRes.rows) {
         const corPro = pepProjectRes.find(pp => pp.id == p.pepProjectId) || {}
         p.dataValues.pepProjectName = corPro.project_name
         p.dataValues.pepProjectIsDelete = corPro.isdelete
         p.dataValues.constructionStatusId = corPro.construction_status_id
         p.dataValues.constructionStatus = corPro.construction_status

         let nextAnxinProject = anxinProjectRes.filter(ap => p.anxinProjectId.includes(ap.id))
         p.dataValues.anxinProject = nextAnxinProject
         delete p.dataValues.anxinProjectId
      }
      ctx.status = 200;
      ctx.body = proRes
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         message: typeof error == 'string' ? error : undefined
      }
   }
}

async function projectAnxincloud (ctx) {
   try {
      const { clickHouse } = ctx.app.fs
      const { includeDelete } = ctx.query

      const projectRes = await clickHouse.anxinyun.query(`SELECT * FROM t_project WHERE project_state = 4 ${includeDelete == 1 ? 'OR project_state = -1' : ''} ORDER BY id DESC`).toPromise()

      ctx.status = 200;
      ctx.body = projectRes
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         message: typeof error == 'string' ? error : undefined
      }
   }
}

async function projectPManage (ctx) {
   try {
      const { clickHouse } = ctx.app.fs
      const { includeDelete } = ctx.query

      const projectRes = await clickHouse.projectManage.query(`SELECT id, project_name, isdelete FROM t_pim_project WHERE isdelete=0 ${includeDelete == 1 ? 'OR isdelete=1' : ''} ORDER BY id DESC`).toPromise()

      ctx.status = 200;
      ctx.body = projectRes
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         message: typeof error == 'string' ? error : undefined
      }
   }
}

async function pepProjectConstrictionState (ctx) {
   try {
      const { models } = ctx.fs.dc;
      const { clickHouse } = ctx.app.fs

      const cRes = await clickHouse.projectManage.query(`
         SELECT * FROM t_pim_project_state ORDER BY id
      `).toPromise()

      ctx.status = 200;
      ctx.body = cRes
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: error`);
      ctx.status = 400;
      ctx.body = {
         message: typeof error == 'string' ? error : undefined
      }
   }
}

async function strucWithPomsProject (ctx) {
   try {
      const { models } = ctx.fs.dc;
      const { clickHouse } = ctx.app.fs
      const { pomsProjectId } = ctx.query

      const bindRes = await models.ProjectCorrelation.findOne({
         where: {
            id: pomsProjectId
         }
      })

      let undelStruc = []
      if (bindRes) {
         const undelStrucRes = bindRes.anxinProjectId.length ?
            await clickHouse.anxinyun.query(
               `  
               SELECT 
                  t_structure.id AS strucId, 
                  t_structure.name AS strucName
               FROM 
                  t_project 
               LEFT JOIN
                  t_project_structure
                     ON t_project_structure.project = t_project.id
               LEFT JOIN
                  t_project_structuregroup
                     ON t_project_structuregroup.project = t_project.id
               LEFT JOIN 
                  t_structuregroup_structure
                     ON t_structuregroup_structure.structuregroup = t_project_structuregroup.structuregroup
               LEFT JOIN
                  t_project_construction
                     ON t_project_construction.project = t_project.id
               LEFT JOIN
                  t_structure_site
                     ON t_structure_site.siteid = t_project_construction.construction
               RIGHT JOIN
                  t_structure
                     ON t_structure.id = t_project_structure.structure
                     OR t_structure.id = t_structuregroup_structure.structure
                     OR t_structure.id = t_structure_site.structid
               WHERE 
                  project_state != -1 
                     AND
                  t_project.id IN (${ bindRes.anxinProjectId.join(',')})
               ORDER BY strucId
            `
            ).toPromise() :
            []
         for (let s of undelStrucRes) {
            if (!undelStruc.some(us => us.id == s.strucId)) {
               undelStruc.push({
                  id: s.strucId,
                  name: s.strucName,
               })
            }
         }
      }

      ctx.status = 200;
      ctx.body = undelStruc
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: error`);
      ctx.status = 400;
      ctx.body = {
         message: typeof error == 'string' ? error : undefined
      }
   }
}

module.exports = {
   appList,
   projectAnxincloud,
   projectPManage,
   pomsProject,
   pepProjectConstrictionState,
   strucWithPomsProject,
};