You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
355 lines
12 KiB
355 lines
12 KiB
'use strict';
|
|
|
|
const moment = require("moment");
|
|
|
|
|
|
async function findPatrolRecords(ctx, next) {
|
|
const sequelize = ctx.fs.dc.orm;
|
|
try {
|
|
let rslt = { planCount: 0, done: 0 }
|
|
const models = ctx.fs.dc.models
|
|
const { projectId, startTime, endTime } = ctx.query
|
|
|
|
|
|
const plan = await models.PatrolPlan.findAll({
|
|
where: {
|
|
structureId: { $in: projectId.split(',') },
|
|
$or: [{
|
|
startTime: { $lte: startTime },
|
|
endTime: { $gte: endTime }
|
|
},
|
|
{
|
|
startTime: { $gt: startTime },
|
|
endTime: { $lt: endTime }
|
|
},
|
|
{
|
|
startTime: { $between: [startTime, endTime] },
|
|
},
|
|
{
|
|
endTime: { $between: [startTime, endTime] }
|
|
},
|
|
|
|
]
|
|
}
|
|
})
|
|
if (plan && plan.length) {
|
|
for (let { dataValues: c } of plan) {
|
|
let frequency = Number(c.frequency.split('次')[0]) || 0
|
|
let points = c.points.length || 0
|
|
let done = 0
|
|
//
|
|
if (moment(c.startTime).isSameOrBefore(moment(startTime)) && moment(c.endTime).isSameOrAfter(moment(endTime))) {
|
|
done = await models.PatrolRecord.count({
|
|
where: {
|
|
inspectionTime: { $between: [c.startTime, endTime] },
|
|
patrolPlanId: c.id
|
|
}
|
|
})
|
|
|
|
} else if (moment(c.startTime).isSameOrAfter(moment(startTime)) && moment(c.startTime).isSameOrBefore(moment(endTime))) {
|
|
done = await models.PatrolRecord.count({
|
|
where: {
|
|
inspectionTime: { $between: [c.startTime, endTime] },
|
|
patrolPlanId: c.id
|
|
}
|
|
})
|
|
} else if (moment(c.endTime).isSameOrAfter(moment(startTime)) && moment(c.endTime).isSameOrBefore(moment(endTime))) {
|
|
done = await models.PatrolRecord.count({
|
|
where: {
|
|
inspectionTime: { $between: [c.startTime, c.endTime] },
|
|
patrolPlanId: c.id
|
|
}
|
|
})
|
|
} else if (moment(c.startTime).isAfter(moment(startTime)) && moment(c.endTime).isBefore(moment(endTime))) {
|
|
done = await models.PatrolRecord.count({
|
|
where: {
|
|
inspectionTime: { $between: [c.startTime, c.endTime] },
|
|
patrolPlanId: c.id
|
|
}
|
|
})
|
|
}
|
|
let dones = await models.PatrolRecord.count({
|
|
where: {
|
|
inspectionTime: { $between: [startTime, endTime] },
|
|
patrolPlanId: c.id
|
|
}
|
|
})
|
|
rslt.planCount += frequency * points - done
|
|
rslt.done += dones
|
|
}
|
|
|
|
}
|
|
ctx.status = 200
|
|
ctx.body = rslt
|
|
|
|
} catch (error) {
|
|
ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
|
|
ctx.status = 400;
|
|
ctx.body = { message: '查询巡检记录失败' }
|
|
}
|
|
|
|
}
|
|
|
|
async function findPatrolRate(ctx) {
|
|
try {
|
|
const models = ctx.fs.dc.models
|
|
const sequelize = ctx.fs.dc.orm;
|
|
const { projectId, startTime, endTime } = ctx.query
|
|
const res = await models.PatrolRecord.findAll({
|
|
attributes: ['id'],
|
|
where: {
|
|
projectId: { $in: projectId.split(',') },
|
|
},
|
|
include: [
|
|
{
|
|
model: models.PatrolRecordIssueHandle,
|
|
required: true,
|
|
where: {
|
|
createTime: { $between: [startTime, endTime] },
|
|
},
|
|
attributes: ['createTime', 'state'],
|
|
},
|
|
],
|
|
|
|
});
|
|
ctx.body = res
|
|
ctx.status = 200
|
|
} catch (error) {
|
|
ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
|
|
ctx.status = 400;
|
|
ctx.body = { message: '查询巡检完成率失败' }
|
|
}
|
|
}
|
|
|
|
|
|
async function countByProject(ctx) {
|
|
try {
|
|
const models = ctx.fs.dc.models
|
|
const sequelize = ctx.fs.dc.orm;
|
|
const { projectId, } = ctx.query
|
|
const res = await models.Project.findAll({
|
|
attributes: [
|
|
'id',
|
|
'name',
|
|
[sequelize.fn('COUNT', sequelize.literal('"PatrolRecords"."id"')), 'patrolRecordCount'],
|
|
[sequelize.fn('COUNT', sequelize.literal('"PatrolRecords->patrolRecordIssueHandles"."id"')), 'issueHandleCount'],
|
|
],
|
|
include: [
|
|
{
|
|
model: models.PatrolRecord,
|
|
// as: 'PatrolRecords',
|
|
attributes: [],
|
|
include: [
|
|
{
|
|
model: models.PatrolRecordIssueHandle,
|
|
attributes: [],
|
|
// as: 'PatrolRecordIssueHandles',
|
|
},
|
|
],
|
|
},
|
|
],
|
|
where: {
|
|
id: { $in: projectId.split(',') },
|
|
},
|
|
group: ['project.id', 'project.name'],
|
|
order: [
|
|
[sequelize.fn('COUNT', sequelize.literal('"PatrolRecords"."id"')), 'DESC'],
|
|
],
|
|
});
|
|
ctx.body = res
|
|
ctx.status = 200
|
|
} catch (error) {
|
|
ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
|
|
ctx.status = 400;
|
|
ctx.body = { message: '根据结构物汇集失败' }
|
|
}
|
|
}
|
|
|
|
async function devicesGuarantee(ctx) {
|
|
try {
|
|
let rslt = {}
|
|
const models = ctx.fs.dc.models
|
|
const sequelize = ctx.fs.dc.orm;
|
|
const { projectId, } = ctx.query
|
|
let option = {
|
|
// where: searchWhere,
|
|
order: [["id", "desc"]],
|
|
include: [{
|
|
model: models.PointDevice,
|
|
include: {
|
|
model: models.Point,
|
|
where: { projectId: { $in: projectId.split(',') } }
|
|
}
|
|
}]
|
|
}
|
|
const res = await models.Device.findAll(option);
|
|
rslt.count = res.length
|
|
let underGuarantee = 0
|
|
for (let { dataValues: c } of res) {
|
|
if (moment(c.dateGuarantee).isAfter(moment())) {
|
|
underGuarantee += 1
|
|
}
|
|
}
|
|
rslt.underGuarantee = underGuarantee
|
|
const rs = await sequelize.query(`
|
|
SELECT d.type, COUNT(d.id) as count
|
|
FROM device d
|
|
LEFT JOIN point_device pd
|
|
ON d.id = pd.device_id
|
|
LEFT JOIN point p
|
|
ON pd.point_id = p.id
|
|
WHERE p.project_id IN (${projectId})
|
|
GROUP by d.type`)
|
|
rslt.rs = rs[0]
|
|
ctx.body = rslt
|
|
ctx.status = 200
|
|
} catch (error) {
|
|
ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
|
|
ctx.status = 400;
|
|
ctx.body = { message: '查询设备失败' }
|
|
}
|
|
}
|
|
|
|
|
|
|
|
async function getHistoricalFaults(ctx) {
|
|
try {
|
|
const models = ctx.fs.dc.models
|
|
const sequelize = ctx.fs.dc.orm;
|
|
const { projectId, startTime, endTime } = ctx.query
|
|
const rslt = await sequelize.query(`
|
|
select p.name,
|
|
count(1) as count,
|
|
count(case when prih.state=6 then 1 end) as bCount
|
|
from project p
|
|
left join patrol_record pr
|
|
on p.id = pr.project_id
|
|
left join patrol_record_issue_handle prih
|
|
on pr.id = prih.patrol_record_id
|
|
and prih.create_time
|
|
between '${startTime}'
|
|
and '${endTime}'
|
|
where p.id in (${projectId})
|
|
group by p.name
|
|
|
|
`)
|
|
ctx.body = rslt[0]
|
|
ctx.status = 200
|
|
} catch (error) {
|
|
ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
|
|
ctx.status = 400;
|
|
ctx.body = { message: '查询历史故障失败' }
|
|
}
|
|
}
|
|
|
|
|
|
async function getFaultsRank(ctx) {
|
|
try {
|
|
let rslt = []
|
|
const models = ctx.fs.dc.models
|
|
const sequelize = ctx.fs.dc.orm;
|
|
const { projectId, } = ctx.query
|
|
const rs = await models.PatrolRecord.findAll(
|
|
{
|
|
where:
|
|
{ projectId: { $in: projectId.split(',') } }
|
|
}
|
|
)
|
|
for (let { dataValues: c } of rs) {
|
|
if (c.points.inspectContent && c.points.inspectContent.length) {
|
|
for (let p of c.points.inspectContent) {
|
|
if (p.deviceId) {
|
|
if(p.alarm){
|
|
const isExist = rslt.find(item => item.id === p.deviceId)
|
|
if (!isExist) {
|
|
rslt.push({ id: p.deviceId, name: p.deviceName, count: 1 })
|
|
} else {
|
|
isExist.count += 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
rslt.sort((a, b) => b.count - a.count)
|
|
ctx.body = rslt
|
|
ctx.status = 200
|
|
} catch (error) {
|
|
ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
|
|
ctx.status = 400;
|
|
ctx.body = { message: '查询故障排名失败' }
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
async function getCenterData(ctx) {
|
|
try{
|
|
let rslt = {}
|
|
const models = ctx.fs.dc.models
|
|
const sequelize = ctx.fs.dc.orm;
|
|
const { projectId, } = ctx.query
|
|
let option = {
|
|
// where: searchWhere,
|
|
order: [["id", "desc"]],
|
|
include: [{
|
|
model: models.PointDevice,
|
|
include: {
|
|
model: models.Point,
|
|
where: { projectId: { $in: projectId.split(',') } }
|
|
}
|
|
}]
|
|
}
|
|
const res = await models.Device.findAll(option)
|
|
const rs = await sequelize.query(`
|
|
select
|
|
count(1) as count,
|
|
count(case when prih.state=6 then 1 end) as bCount
|
|
from project p
|
|
left join patrol_record pr
|
|
on p.id = pr.project_id
|
|
left join patrol_record_issue_handle prih
|
|
on pr.id = prih.patrol_record_id
|
|
where p.id in (${projectId})
|
|
`)
|
|
const record=await models.PatrolRecord.count({where:{projectId:{$in:projectId.split(',')}}})
|
|
const reportCount=await models.ReportInfo.count({
|
|
where:{
|
|
$or:[ {projectId:{$in:projectId.split(',') }},
|
|
|
|
{
|
|
structureIds:{$contains:projectId.split(',').map(item=>parseInt(item))}
|
|
}
|
|
|
|
]
|
|
|
|
}
|
|
})
|
|
|
|
rslt.deviceCount=res.length
|
|
rslt.questions=rs[0][0]?Number(rs[0][0].count):0
|
|
rslt.handleCount=rs[0][0]?Number(rs[0][0].count):0
|
|
rslt.records=record
|
|
rslt.reportCount=reportCount
|
|
ctx.body = rslt
|
|
ctx.status = 200
|
|
}catch(error){
|
|
ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
|
|
ctx.status = 400;
|
|
ctx.body = { message: '领导驾驶舱中间数据查询失败' }
|
|
}
|
|
}
|
|
|
|
|
|
|
|
module.exports = {
|
|
findPatrolRecords,
|
|
findPatrolRate,
|
|
countByProject,
|
|
devicesGuarantee,
|
|
getHistoricalFaults,
|
|
getFaultsRank,
|
|
getCenterData
|
|
}
|