import { Inject, Provide } from '@midwayjs/core';
|
import { BaseService } from '@cool-midway/core';
|
import { InjectEntityModel } from '@midwayjs/typeorm';
|
import { Repository, SelectQueryBuilder } from 'typeorm';
|
import { Context } from '@midwayjs/koa';
|
import { BasicdataSiteEntity } from '../../basicdata/entity/site';
|
import { BasicdataSorterEntity } from '../../basicdata/entity/sorter';
|
import { BasicdataVehicleEntity } from '../../basicdata/entity/vehicle';
|
import { BasicdataWastetypeEntity } from '../../basicdata/entity/wastetype';
|
import { BasicdataIotEntity } from '../../basicdata/entity/iot';
|
import { PushSorterGpsEntity } from '../../push/entity/sortergps';
|
import { PushSorterHealthEntity } from '../../push/entity/sorterhealth';
|
import { PushSorterAlarmEntity } from '../../push/entity/sorteralarm';
|
import { PushVehicleGpsEntity } from '../../push/entity/vehiclegps';
|
import { PushSiteweightEntity } from '../../push/entity/siteweight';
|
import { PushDevicealarmEntity } from '../../push/entity/devicealarm';
|
|
function n(v: any, d = 0) {
|
const x = Number(v);
|
return Number.isFinite(x) ? x : d;
|
}
|
|
@Provide()
|
export class MapsLiveService extends BaseService {
|
@Inject()
|
ctx: Context;
|
|
@InjectEntityModel(BasicdataSiteEntity)
|
siteRepo: Repository<BasicdataSiteEntity>;
|
|
@InjectEntityModel(BasicdataSorterEntity)
|
sorterRepo: Repository<BasicdataSorterEntity>;
|
|
@InjectEntityModel(BasicdataVehicleEntity)
|
vehicleRepo: Repository<BasicdataVehicleEntity>;
|
|
@InjectEntityModel(PushSorterGpsEntity)
|
sorterGps: Repository<PushSorterGpsEntity>;
|
|
@InjectEntityModel(PushSorterHealthEntity)
|
sorterHealthRepo: Repository<PushSorterHealthEntity>;
|
|
@InjectEntityModel(PushSorterAlarmEntity)
|
sorterAlarm: Repository<PushSorterAlarmEntity>;
|
|
@InjectEntityModel(PushVehicleGpsEntity)
|
vehicleGps: Repository<PushVehicleGpsEntity>;
|
|
@InjectEntityModel(PushSiteweightEntity)
|
siteWeightRepo: Repository<PushSiteweightEntity>;
|
|
@InjectEntityModel(PushDevicealarmEntity)
|
deviceAlarm: Repository<PushDevicealarmEntity>;
|
|
@InjectEntityModel(BasicdataIotEntity)
|
iotRepo: Repository<BasicdataIotEntity>;
|
|
private deptIds(): number[] | null {
|
const admin = this.ctx.admin;
|
if (!admin || admin.username === 'admin') return null;
|
return Array.isArray(admin.departmentIds) ? admin.departmentIds.map(Number) : [];
|
}
|
|
private applyDept(qb: SelectQueryBuilder<any>, alias: string) {
|
const ids = this.deptIds();
|
if (ids === null) return qb;
|
if (!ids.length) {
|
qb.andWhere('1 = 0');
|
return qb;
|
}
|
qb.andWhere(`${alias}.departmentId IN (:...deptIds)`, { deptIds: ids });
|
return qb;
|
}
|
|
async sites() {
|
const qb = this.siteRepo
|
.createQueryBuilder('a')
|
.select([
|
'a.id',
|
'a.businessId',
|
'a.businessName',
|
'a.departmentId',
|
'a.siteType',
|
'a.address',
|
'a.leader',
|
'a.longitude',
|
'a.latitude',
|
'a.photo',
|
'a.status',
|
'a.remark',
|
])
|
.where('a.status = :status', { status: 1 })
|
.andWhere('a.longitude IS NOT NULL')
|
.andWhere('a.latitude IS NOT NULL');
|
this.applyDept(qb, 'a');
|
const rows = await qb.getMany();
|
return rows.filter(e => n(e.longitude) && n(e.latitude));
|
}
|
|
async siteWeight(businessId: string, startTime: string, endTime: string) {
|
if (!businessId) return [];
|
const qb = this.siteWeightRepo
|
.createQueryBuilder('a')
|
.leftJoin(BasicdataWastetypeEntity, 'c', 'a.garbageType = c.code')
|
.select('a.id', 'id')
|
.addSelect('a.businessId', 'businessId')
|
.addSelect('a.deviceNo', 'deviceNo')
|
.addSelect('a.uploadTime', 'uploadTime')
|
.addSelect('a.garbageType', 'garbageType')
|
.addSelect('c.name', 'garbageName')
|
.addSelect('a.weight', 'weight')
|
.where('a.businessId = :businessId', { businessId })
|
.andWhere('a.uploadTime BETWEEN :startTime AND :endTime', { startTime, endTime })
|
.orderBy('a.uploadTime', 'DESC')
|
.limit(200);
|
this.applyDept(qb, 'a');
|
return qb.getRawMany();
|
}
|
|
async sorterOnline() {
|
const since = new Date(Date.now() - 15 * 60 * 1000);
|
const qb = this.sorterGps
|
.createQueryBuilder('a')
|
.where('a.uploadTime >= :since', { since })
|
.orderBy('a.uploadTime', 'DESC')
|
.take(4000);
|
this.applyDept(qb, 'a');
|
const rows = await qb.getMany();
|
const latest = new Map<string, PushSorterGpsEntity>();
|
rows.forEach(r => {
|
if (r.idCard && !latest.has(r.idCard)) latest.set(r.idCard, r);
|
});
|
const cards = [...latest.keys()];
|
const sorters = cards.length
|
? await this.sorterRepo
|
.createQueryBuilder('s')
|
.where('s.businessId IN (:...cards)', { cards })
|
.getMany()
|
: [];
|
const sorterMap = new Map(sorters.map(s => [s.businessId, s]));
|
return [...latest.values()].map(g => {
|
const s = sorterMap.get(g.idCard);
|
return {
|
idCard: g.idCard,
|
name: s?.businessName || g.name,
|
phone: s?.phone || '',
|
sex: s?.sex,
|
workSiteId: s?.workSiteId,
|
departmentId: s?.departmentId || g.departmentId,
|
departmentName: g.departmentName,
|
longitude: n(g.longitude),
|
latitude: n(g.latitude),
|
speed: n(g.speed),
|
uploadTime: g.uploadTime,
|
status: s?.status,
|
};
|
});
|
}
|
|
async sorterTrack(idCard: string, startTime: string, endTime: string) {
|
if (!idCard) return [];
|
const qb = this.sorterGps
|
.createQueryBuilder('a')
|
.where('a.idCard = :idCard', { idCard })
|
.andWhere('a.uploadTime BETWEEN :startTime AND :endTime', { startTime, endTime })
|
.andWhere('a.longitude IS NOT NULL')
|
.andWhere('a.latitude IS NOT NULL')
|
.orderBy('a.uploadTime', 'ASC')
|
.take(5000);
|
this.applyDept(qb, 'a');
|
const rows = await qb.getMany();
|
return rows.map(r => ({
|
longitude: n(r.longitude),
|
latitude: n(r.latitude),
|
speed: n(r.speed),
|
time: r.uploadTime,
|
}));
|
}
|
|
async sorterHealth(idCard: string) {
|
if (!idCard) return { recent: [], abnormal: [], alarms: [] };
|
const recentQb = this.sorterHealthRepo
|
.createQueryBuilder('a')
|
.where('a.idCard = :idCard', { idCard })
|
.orderBy('a.uploadTime', 'DESC')
|
.take(20);
|
this.applyDept(recentQb, 'a');
|
const recent = await recentQb.getMany();
|
|
const abQb = this.sorterHealthRepo
|
.createQueryBuilder('a')
|
.where('a.idCard = :idCard', { idCard })
|
.andWhere("a.dataType = '异常'")
|
.orderBy('a.uploadTime', 'DESC')
|
.take(20);
|
this.applyDept(abQb, 'a');
|
const abnormal = await abQb.getMany();
|
|
const alarmQb = this.sorterAlarm
|
.createQueryBuilder('a')
|
.where('a.idCard = :idCard', { idCard })
|
.orderBy('a.uploadTime', 'DESC')
|
.take(20);
|
this.applyDept(alarmQb, 'a');
|
const alarms = await alarmQb.getMany();
|
|
return { recent, abnormal, alarms };
|
}
|
|
async vehicleOnline() {
|
const since = new Date(Date.now() - 15 * 60 * 1000);
|
const qb = this.vehicleGps
|
.createQueryBuilder('a')
|
.where('a.gpsTime >= :since', { since })
|
.andWhere("a.vehicleNo IS NOT NULL AND a.vehicleNo <> ''")
|
.orderBy('a.gpsTime', 'DESC')
|
.take(4000);
|
this.applyDept(qb, 'a');
|
const rows = await qb.getMany();
|
const latest = new Map<string, PushVehicleGpsEntity>();
|
rows.forEach(r => {
|
if (r.vehicleNo && !latest.has(r.vehicleNo)) latest.set(r.vehicleNo, r);
|
});
|
const plates = [...latest.keys()];
|
const vehicles = plates.length
|
? await this.vehicleRepo
|
.createQueryBuilder('v')
|
.where('v.businessId IN (:...plates)', { plates })
|
.getMany()
|
: [];
|
const vehicleMap = new Map(vehicles.map(v => [v.businessId, v]));
|
return [...latest.values()].map(g => {
|
const v = vehicleMap.get(g.vehicleNo);
|
return {
|
vehicleNo: g.vehicleNo,
|
sn: g.sn,
|
vehicleType: v?.vehicleType,
|
capacityTon: v?.capacityTon,
|
departmentId: v?.departmentId || g.departmentId,
|
departmentName: g.departmentName,
|
longitude: n(g.longitude),
|
latitude: n(g.latitude),
|
speed: n(g.speed),
|
direction: g.direction,
|
gpsTime: g.gpsTime,
|
status: v?.status,
|
gpsStatus: g.status,
|
};
|
});
|
}
|
|
async vehicleTrack(vehicleNo: string, startTime: string, endTime: string) {
|
if (!vehicleNo) return [];
|
const qb = this.vehicleGps
|
.createQueryBuilder('a')
|
.where('a.vehicleNo = :vehicleNo', { vehicleNo })
|
.andWhere('a.gpsTime BETWEEN :startTime AND :endTime', { startTime, endTime })
|
.andWhere('a.longitude IS NOT NULL')
|
.andWhere('a.latitude IS NOT NULL')
|
.orderBy('a.gpsTime', 'ASC')
|
.take(5000);
|
this.applyDept(qb, 'a');
|
const rows = await qb.getMany();
|
return rows.map(r => ({
|
longitude: n(r.longitude),
|
latitude: n(r.latitude),
|
speed: n(r.speed),
|
direction: r.direction,
|
time: r.gpsTime,
|
}));
|
}
|
|
async vehicleEvents(vehicleNo: string) {
|
if (!vehicleNo) return [];
|
const iots = await this.iotRepo.find({
|
where: { businessId: vehicleNo },
|
select: ['iotCode', 'iotName', 'iotTypeCode'],
|
});
|
const codes = iots.map(e => e.iotCode).filter(Boolean);
|
if (!codes.length) return [];
|
const nameMap = new Map(iots.map(e => [e.iotCode, e.iotName]));
|
const qb = this.deviceAlarm
|
.createQueryBuilder('a')
|
.where('a.devSerial IN (:...codes)', { codes })
|
.orderBy('a.createTime', 'DESC')
|
.take(30);
|
const rows = await qb.getMany();
|
return rows.map(r => ({
|
...r,
|
deviceName: nameMap.get(r.devSerial) || r.devSerial,
|
}));
|
}
|
}
|
