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

'use strict';
const moment = require('moment')
const { alarmConfirmLog } = require('./alarmConfirmLog');
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, limit, page, } = 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}`)
      }

      let statusAlarmWhereOption = []
      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')
         statusAlarmWhereOption.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 queryStr = `
         SELECT         
            cameraAlarm.cameraId AS cameraId,
            cameraAlarm.cameraName AS cameraName,
            cameraAlarm.cameraKindId AS cameraKindId,
            cameraAlarm.venderId AS venderId,
            cameraAlarm.venderName AS venderName,
               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,
            ${'cameraAlarm.autoRestore AS autoRestore,'}
            camera_status_resolve.id AS resolveId,
            camera_status.describe AS statusDescribe,
            camera_status_resolve.resolve AS resolve,
            "gbCamera".online AS cameraOnline,
            secret_yingshi.token AS yingshiToken,
               anxinIpc.t_video_ipc.name AS anxinIpcPosition,
               anxinStation.id AS anxinStationId,
               anxinStation.name AS anxinStationName,
               anxinStruc.name AS strucName,
               anxinStruc.id AS strucId
         FROM
            (
               SELECT
                     camera.id AS cameraId,
                     camera.gb_id AS gbId,
                     camera.name AS cameraName,
                     camera.kind_id AS cameraKindId,
                     camera.vender_id AS venderId,
                     camera.yingshi_secret_id AS yingshiSecretId,
                     vender.name AS venderName,
                     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.auto_restore AS autoRestore,'}
                     camera_status_alarm.confirm_time AS confirmTime
                  FROM camera_status_alarm
                  INNER 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 ') : ''}
                  LEFT JOIN vender
                     ON vender.id = camera.vender_id
                  WHERE 
                     camera.delete = false 
                     AND camera.recycle_time is null
                     ${statusAlarmWhereOption.length ? 'AND ' + statusAlarmWhereOption.join(' AND ') : ''}
                  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(',')})`}
                  )
                  ${limit ? 'LIMIT ' + limit : ''}
                  ${limit && page ? 'OFFSET ' + parseInt(limit) * parseInt(page) : ''}
            ) 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 "secret_yingshi"
            ON "secret_yingshi".id = cameraAlarm.yingshiSecretId

         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
            AND anxinStruc.id IN (${anxinStrucIds.join(',')})
            ${keywordTarget == 'struc' && keyword ? `AND anxinStruc.name LIKE '%${keyword}%'` : ''}
         LEFT JOIN ${anxinyun}.t_video_ipc_station AS anxinIpcStation
            ON anxinIpcStation.ipc = anxinIpc.id
         LEFT JOIN ${anxinyun}.t_sensor AS anxinStation
            ON anxinStation.id = anxinIpcStation.station
      `
      const alarmRes = anxinStrucIds.length ? await clickHouse.vcmp.query(
         queryStr
      ).toPromise() : []
      console.log(queryStr);
      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,
                  projectId: a.projectId,
                  name: a.strucName
               })
            }
            if (a.anxinStationId && !curD.station.some(s => s.id == a.anxinStationId)) {
               curD.station.push({
                  id: a.anxinStationId,
                  name: a.anxinStationName,
                  position: a.anxinIpcPosition
               })
            }
         } else {
            let d = {
               cameraId: a.cameraId,
               cameraName: a.cameraName,
               camerOnline: a.cameraOnline,
               cameraSerialNo: a.cameraSerialNo,
               cameraChannelNo: a.cameraChannelNo,
               autoRestore: a.autoRestore,
               createTime: a.createTime,
               updateTime: a.updateTime,
               platform: a.platform,
               statusDescribe: a.statusDescribe,
               alarmId: a.alarmId,
               confirmContent: a.confirmContent,
               confirmTime: a.confirmTime,

               venderId: a.venderId,
               venderName: a.venderName,
               cameraKindId: a.cameraKindId,
               yingshiToken: a.yingshiToken,

               resolve: [],
               struc: [],
               station: []
            }

            // pep 项目
            d.pomsProject = (
               anxinStruc.find(as => as.strucId == a.strucId) ||
               {
                  pomsProject: [

                  ]
               }
            ).pomsProject

            if (a.resolveId) {
               d.resolve.push({
                  id: a.resolveId,
                  resolve: a.resolve
               })
            }
            if (a.strucId) {
               d.struc.push({
                  id: a.strucId,
                  projectId: a.projectId,
                  name: a.strucName
               })
            }
            if (a.anxinStationId) {
               d.station.push({
                  id: a.anxinStationId,
                  name: a.anxinStationName,
                  position: a.anxinIpcPosition
               })
            }
            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 { alarmId, content, confirmPost } = ctx.request.body;
      // TODO: 以视频·应用的秘钥进行鉴权
      await ctx.app.fs.vcmpRequest.put('status/alarm/confirm', {
         data: {
            alarmId, content
         }
      })

      await alarmConfirmLog(ctx, confirmPost, content);//告警确认日志

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

async function vcmpAppAuthToken (ctx) {
   try {
      const { models } = ctx.fs.dc;
      const { utils: { vcmpAuth } } = ctx.app.fs

      const token = await vcmpAuth()

      ctx.status = 200;
      ctx.body = { token }
   } 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,
   confirm,
   vcmpAppAuthToken
};