OperationalService/api/app/lib/controllers/alarm/video.js

'use strict';
async function deviceType (ctx) {
   try {
      const { models } = ctx.fs.dc;
      const { clickHouse } = ctx.app.fs

      const kindRes = await clickHouse.vcmp.query(`
         SELECT * FROM camera_kind
      `).toPromise()

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

async function alarmList (ctx) {
   try {
      const { models } = ctx.fs.dc;
      const { clickHouse } = ctx.app.fs
      const { utils: { judgeSuper, anxinStrucIdRange } } = ctx.app.fs
      const { database: anxinyun } = clickHouse.anxinyun.opts.config
      const { pepProjectId, keywordTarget, keyword, state, kindId, sustainTimeStart, sustainTimeEnd, } = ctx.query

      let anxinStruc = await anxinStrucIdRange({
         ctx, pepProjectId, keywordTarget, keyword
      })
      const anxinStrucIds = anxinStruc.map(a => a.strucId)

      let cameraWhereOption = []
      if (keywordTarget == 'source' && keyword) {
         cameraWhereOption.push(`camera.name LIKE '%${keyword}%'`)
      }
      if (state) {
         if (state == 'new') {
            cameraWhereOption.push(`camera_status_alarm.confirm_time IS null`)
         } else if (state == 'histroy') {
            cameraWhereOption.push(`camera_status_alarm.confirm_time IS NOT null`)
         }
      }
      if (kindId) {
         cameraWhereOption.push(`camera.kind_id = ${kindId}`)
      }
      if (sustainTimeStart && sustainTimeEnd) {
         let momentStart = moment(sustainTimeStart).format('YYYY-MM-DD HH:mm:ss')
         let momentEnd = moment(sustainTimeEnd).format('YYYY-MM-DD HH:mm:ss')
         whereOption.push(`
            (
               camera_status_alarm.create_time
                  BETWEEN '${momentStart}' AND '${momentEnd}' 
                  OR 
                  camera_status_alarm.update_time BETWEEN '${momentStart}' AND '${momentEnd}' 
                  OR (
                     camera_status_alarm.create_time <= '${momentStart}' 
                     AND 
                     camera_status_alarm.update_time >= '${momentEnd}'
                  )
            )
         `)
      }
      const alarmRes = await clickHouse.vcmp.query(
         `
            SELECT
               cameraAlarm.cameraId AS cameraId,
               cameraAlarm.cameraName AS cameraName,
                  cameraAlarm.cameraSerialNo AS cameraSerialNo,
                  cameraAlarm.cameraChannelNo AS cameraChannelNo,
               cameraAlarm.alarmId AS alarmId,
               cameraAlarm.createTime AS createTime,
               cameraAlarm.updateTime AS updateTime,
               cameraAlarm.platform AS platform,
               cameraAlarm.confirmContent AS confirmContent,
               cameraAlarm.confirmTime AS confirmTime,
               camera_status_resolve.id AS resolveId,
               camera_status.describe AS statusDescribe,
               camera_status_resolve.resolve AS resolve,
               "gbCamera".online AS cameraOnline,
                  anxinIpc.t_video_ipc.name,
                  anxinStruc.name AS strucName,
                  anxinStruc.id AS strucId
            FROM
               (
                  SELECT
                        camera.id AS cameraId,
                        camera.gb_id AS gbId,
                        camera.name AS cameraName,
                        camera_status_alarm.id AS alarmId,
                        camera_status_alarm.create_time AS createTime,
                        camera_status_alarm.update_time AS updateTime,
                        camera_status_alarm.platform AS platform,
                        camera_status_alarm.status_id AS statusId,
                        camera_status_alarm.serial_no AS cameraSerialNo,
                        camera_status_alarm.channel_no AS cameraChannelNo,
                        camera_status_alarm.confirm AS confirmContent,
                        camera_status_alarm.confirm_time AS confirmTime
                     FROM camera_status_alarm
                     LEFT JOIN camera
                        ON camera.serial_no = camera_status_alarm.serial_no
                        AND camera.channel_no = camera_status_alarm.channel_no
                        ${cameraWhereOption.length ? 'AND ' + cameraWhereOption.join(' AND ') : ''}
                     WHERE 
                        camera.delete = false 
                        AND camera.recycle_time is null
                     AND alarmId IN (
                        SELECT camera_status_alarm.id AS alarmId 
                        FROM camera_status_alarm
                        RIGHT JOIN ${anxinyun}.t_video_ipc
                           ON toString(${anxinyun}.t_video_ipc.channel_no) = camera_status_alarm.channel_no
                           AND ${anxinyun}.t_video_ipc.serial_no = camera_status_alarm.serial_no
                           ${`WHERE ${anxinyun}.t_video_ipc.structure IN (${anxinStrucIds.join(',')})`
         }
                     )
               ) AS cameraAlarm
            LEFT JOIN camera_status
               ON cameraAlarm.platform = camera_status.platform
               AND cameraAlarm.statusId = camera_status.id
            LEFT JOIN camera_status_resolve
               ON camera_status_resolve.status_id = camera_status.id
            LEFT JOIN "gbCamera"
               ON "gbCamera".id = cameraAlarm.gbId

            LEFT JOIN ${anxinyun}.t_video_ipc AS anxinIpc
               ON toString(anxinIpc.channel_no) = cameraAlarm.cameraChannelNo
               AND anxinIpc.serial_no = cameraAlarm.cameraSerialNo
            LEFT JOIN ${anxinyun}.t_structure AS anxinStruc
               ON anxinStruc.id = anxinIpc.structure
         `
      ).toPromise()

      let returnD = []
      let positionD = {}
      // 每个设备一个告警
      for (let a of alarmRes) {
         if (positionD[a.cameraId]) {
            let curD = returnD[positionD[a.cameraId].positionReturnD]
            if (a.resolveId && !curD.resolve.some(r => r.id == a.resolveId)) {
               curD.resolve.push({
                  id: a.resolveId,
                  resolve: a.resolve
               })
            }
            if (a.strucId && !curD.struc.some(s => s.id == a.strucId)) {
               curD.struc.push({
                  id: a.strucId,
                  name: a.strucName
               })
            }
         } else {
            let d = {
               cameraId: a.cameraId,
               cameraName: a.cameraName,
               camerOnline: a.cameraOnline,
               cameraSerialNo: a.cameraSerialNo,
               cameraChannelNo: a.cameraChannelNo,
               createTime: a.createTime,
               updateTime: a.updateTime,
               platform: a.platform,
               statusDescribe: a.statusDescribe,
               alarmId: a.alarmId,
               confirmContent: a.confirmContent,
               confirmTime: a.confirmTime,
               resolve: [],
               struc: []
            }
            if (a.resolveId) {
               d.resolve.push({
                  id: a.resolveId,
                  resolve: a.resolve
               })
            }
            if (a.strucId) {
               d.struc.push({
                  id: a.strucId,
                  name: a.strucName
               })
            }
            returnD.push(d)
            positionD[a.cameraId] = {
               positionReturnD: returnD.length - 1
            }
         }
      }

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

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

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

module.exports = {
   deviceType,
   alarmList
};