2025.12.22 巡查任务统计相关功能修改

feiyu02

2025-12-22 2302c9f0336f7ae4acae0583412ddc396645a0ed

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
package cn.flightfeather.supervision.lightshare.service.impl
 
import cn.flightfeather.supervision.common.utils.UUIDGenerator
import cn.flightfeather.supervision.domain.ds1.entity.*
import cn.flightfeather.supervision.domain.ds1.mapper.MonitorobjectversionMapper
import cn.flightfeather.supervision.domain.ds1.mapper.TaskMapper
import cn.flightfeather.supervision.domain.ds1.repository.SceneRep
import cn.flightfeather.supervision.lightshare.service.MonitorobjectversionService
import cn.flightfeather.supervision.lightshare.service.ScenseService
import cn.flightfeather.supervision.lightshare.vo.MonitorObjectVersionVo
import org.springframework.beans.BeanUtils
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional
 
@Service
class MonitorobjectversionServiceImpl(
    private val monitorobjectversionMapper: MonitorobjectversionMapper,
    private val sceneRep: SceneRep,
) : MonitorobjectversionService {
 
    @Autowired
    lateinit var taskMapper: TaskMapper
 
    @Autowired
    lateinit var scenseService: ScenseService
 
    //批量修改监管版本
    @Transactional
    override fun updatelist(monitorobjectversionlist: List<Monitorobjectversion>): Int {
        monitorobjectversionlist.forEach {
            monitorobjectversionMapper.updateByPrimaryKeySelective(it)
        }
        return monitorobjectversionlist.size
    }
 
    //获取可用的监管版本,用于定制子任务
    override fun findCanuserlist(toptaskid: String): List<Monitorobjectversion> {
        val monitorobjectversion = Monitorobjectversion()
        monitorobjectversion.tid = toptaskid
        val monitorobjectversionlist = monitorobjectversionMapper.select(monitorobjectversion)
 
        return monitorobjectversionlist.filter {
            val usedCount = it.extension1 ?: "0"
            it.monitornum.toString().toInt() - usedCount.toInt() > 0
        }.sortedBy { it.displayid }
    }
 
    //批量保存监管版本
    @Transactional
    override fun saveList(monitorobjectversionlist: List<Monitorobjectversion>): Int {
        monitorobjectversionlist.forEach {
            if (it.movid == null) it.movid = UUIDGenerator.generate16ShortUUID()
            monitorobjectversionMapper.insert(it)
        }
        return monitorobjectversionlist.size
    }
 
    //根据顶层任务ID获取监管版本
    override fun findByTaskId(id: String): List<MonitorObjectVersionVo> {
        val task = taskMapper.selectByPrimaryKey(id)
        val s = Scense().apply {
            provincecode = task.provincecode
            citycode = task.citycode
            districtcode = task.districtcode
        }
        val sceneList = scenseService.search(s)
        val subSceneList = sceneRep.findSubSceneList(sceneList)
 
        val monitorobjectversion = Monitorobjectversion()
        monitorobjectversion.tid = id
        val monitorobjectversionlist = monitorobjectversionMapper.select(monitorobjectversion).sortedBy { it.displayid }
 
        val resultList = mutableListOf<MonitorObjectVersionVo>()
        monitorobjectversionlist.forEach {
            val vo = MonitorObjectVersionVo()
            BeanUtils.copyProperties(it, vo)
            sceneList.find {s-> s.guid == vo.sguid }?.let { s->
                vo.sceneTypeId = s.typeid?.toInt() ?: 0
                vo.sceneType = s.type
                vo.scene = s
            }
            subSceneList.find { s ->
                val sGuid = when(s){
                    is SceneConstructionSite-> s.getsGuid()
                    is SceneWharf -> s.getsGuid()
                    is SceneMixingPlant -> s.getsGuid()
                    is SceneStorageYard-> s.getsGuid()
                    else -> null
                }
                sGuid == vo.sguid
            }?.let { s-> vo.subScene = s }
            resultList.add(vo)
        }
 
        return resultList
 
    }
 
    override fun findOne(id: String): Monitorobjectversion = monitorobjectversionMapper.selectByPrimaryKey(id)
 
    override fun findAll(): MutableList<Monitorobjectversion> = monitorobjectversionMapper.selectAll()
 
    //保存单个监管版本
    override fun save(monitorobjectversion: Monitorobjectversion): Int =
        monitorobjectversionMapper.insert(monitorobjectversion)
 
    //更新单个监管版本
    override fun update(monitorobjectversion: Monitorobjectversion): Int =
        monitorobjectversionMapper.updateByPrimaryKey(monitorobjectversion)
 
    override fun delete(id: String): Int = monitorobjectversionMapper.deleteByPrimaryKey(id)
 
    @Transactional
    override fun deleteList(monitorobjectversionlist: List<Monitorobjectversion>): Int {
        var result = 0
        monitorobjectversionlist.forEach {
            result += monitorobjectversionMapper.deleteByPrimaryKey(it.movid)
        }
        return result
    }
}