2025.11.14 新增值域的增删改接口

feiyu02

2025-11-14 c03e1d823eb86c856ecbe40d8d2180ffce7c7b0f

 src/main/kotlin/cn/flightfeather/supervision/lightshare/service/impl/DataProdBaseServiceImpl.kt

@@ -7,6 +7,10 @@
import cn.flightfeather.supervision.lightshare.service.DataProdBaseService
import cn.flightfeather.supervision.lightshare.vo.ProblemListVo
import cn.flightfeather.supervision.lightshare.vo.dataprod.*
import cn.flightfeather.supervision.lightshare.vo.dataprod.base.DPEvaluateInfo
import cn.flightfeather.supervision.lightshare.vo.dataprod.base.DPInspectionInfo
import cn.flightfeather.supervision.lightshare.vo.dataprod.base.DPMonitorDataInfo
import cn.flightfeather.supervision.lightshare.vo.dataprod.base.DPSceneInfo
import org.springframework.beans.BeanUtils
import org.springframework.stereotype.Service
import tk.mybatis.mapper.entity.Example
@@ -105,8 +109,7 @@
                    }
                }
                return@queryCache res
            },
            save = {  }
            }
        )
    }

@@ -120,25 +123,37 @@
                })
                if (subtaskList.isEmpty()) return@queryCache emptyList<DPEvaluateInfo>()

                val sceneList = aopDbMapper.scenseMapper.selectByExample(Example(Scense::class.java).apply {
                    createCriteria().andIn("guid", subtaskList.map { it.scenseid })
                        .andEqualTo("typeid", queryOpt.sceneTypeId)
                })

                val validSubtaskList = subtaskList.filter { sceneList.find { scene -> scene.guid == it.scenseid } != null }

                aopDbMapper.evaluationMapper.selectByExample(Example(Evaluation::class.java).apply {
                    createCriteria().andIn("stguid", subtaskList.map { it.stguid })
                    createCriteria().andIn("stguid", validSubtaskList.map { it.stguid })
                }).forEach {
                    res.add(DPEvaluateInfo().apply {
                        subTask = subtaskList.find { sub-> sub.stguid == it.stguid }
                        val scene = sceneList.find { sce-> sce.guid == it.sguid }
                        index = scene?.index
                        subTask = validSubtaskList.find { sub-> sub.stguid == it.stguid }?.apply {
                            towncode = scene?.towncode
                            townname = scene?.townname
                        }
                        evaluate = it
                        val score = it.resultscorebef?.toIntOrNull() ?: -1
                        scoreLevel = when {
                            score in 0..39 -> Constant.EvaluationLevel.D.text
                            score in 40..89 -> Constant.EvaluationLevel.C.text
                            score in 90..99 -> Constant.EvaluationLevel.B.text
                            score >= 100 -> Constant.EvaluationLevel.A.text
                            score in 0..49 -> Constant.EvaluationLevel.D.text
                            score in 50..89 -> Constant.EvaluationLevel.C.text
                            score in 90..94 -> Constant.EvaluationLevel.B.text
                            score >= 95 -> Constant.EvaluationLevel.A.text
                            else -> ""
                        }
                    })
                }
                res.sortBy { it.index }
                return@queryCache res
            },
            save = {  }
        )
    }

@@ -149,19 +164,44 @@
                val res = mutableListOf<DPInspectionInfo>()
                val subtaskList = aopDbMapper.subtaskMapper.selectByExample(Example(Subtask::class.java).apply {
                    createCriteria().andEqualTo("tguid", queryOpt.topTaskId)
                        .andEqualTo("provincecode", queryOpt.provinceCode)
                        .andEqualTo("citycode", queryOpt.cityCode)
                        .andEqualTo("districtcode", queryOpt.districtCode)
                        .apply {
//                            queryOpt.topTaskId?.let { topTaskId ->
//                                andEqualTo("tguid", topTaskId)
//                            }
                            queryOpt.startTime?.let { startTime ->
                                andGreaterThanOrEqualTo("planstarttime", startTime)
                            }
                            queryOpt.endTime?.let { endTime ->
                                andLessThanOrEqualTo("planstarttime", endTime)
                            }
                        }
                })
                if (subtaskList.isEmpty()) return@queryCache emptyList<DPInspectionInfo>()

                val sceneList = aopDbMapper.scenseMapper.selectByExample(Example(Scense::class.java).apply {
                    createCriteria().andIn("guid", subtaskList.map { it.scenseid })
                        .andEqualTo("typeid", queryOpt.sceneTypeId)
                })
                val validSubtaskList = subtaskList.filter { sceneList.find { scene -> scene.guid == it.scenseid } != null }

                val problemList = aopDbMapper.problemlistMapper.selectByExample(Example(Problemlist::class.java).apply {
                    createCriteria().andIn("stguid", subtaskList.map { it.stguid })
                    createCriteria().andIn("stguid", validSubtaskList.map { it.stguid })
                })

                val problemTypeList = aopDbMapper.problemtypeMapper.selectByExample(Example(Problemtype::class.java)
                    .apply { createCriteria().andIn("guid", problemList.map { it.ptguid }) })

                subtaskList.forEach {
                validSubtaskList.forEach {
                    res.add(DPInspectionInfo().apply {
                        subTask = it
                        val scene = sceneList.find { sce-> sce.guid == it.scenseid }
                        index = scene?.index
                        subTask = it.apply {
                            towncode = scene?.towncode
                            townname = scene?.townname
                        }
                        problems = problemList.filter { problem-> problem.stguid == it.stguid }.map { problem->
                            val problemListVo = ProblemListVo()
                            BeanUtils.copyProperties(problem, problemListVo)
@@ -175,10 +215,9 @@
                        }
                    })
                }

                res.sortBy { it.index }
                return@queryCache res
            },
            save = {  }
        )
    }

@@ -187,23 +226,28 @@
            cache = { return@queryCache null },
            calculate = {
                val res = mutableListOf<DPMonitorDataInfo>()
                val objList = aopDbMapper.monitorobjectversionMapper.selectByExample(Example(Monitorobjectversion::class.java).apply {
                val sceneIdList = aopDbMapper.monitorobjectversionMapper.selectByExample(Example(Monitorobjectversion::class.java).apply {
                    createCriteria().andEqualTo("tid", queryOpt.topTaskId)
                }).map { it.sguid }
                if (sceneIdList.isEmpty()) return@queryCache res

                val sceneList = aopDbMapper.scenseMapper.selectByExample(Example(Scense::class.java).apply {
                    createCriteria().andIn("guid", sceneIdList)
                        .andEqualTo("typeid", queryOpt.sceneTypeId)
                })
                if (objList.isEmpty()) return@queryCache res

                aopDbMapper.dustDataResultMapper.selectByExample(Example(DustDataResult::class.java).apply {
                    createCriteria().andBetween("drTime", queryOpt.startTime, queryOpt.endTime)
                        .andIn("objectId", objList.map { it.sguid })
                        .andIn("drSceneId", sceneList.map { it.guid })
                }).forEach {
                    res.add(DPMonitorDataInfo().apply {
                        scene = sceneList.find { scene -> scene.guid == it?.drSceneId }
                        data = it
                    })
                }

                return@queryCache res
            },
            save = {  }
        )
    }
}