supervision-spring.git

			@@ -10,7 +10,6 @@
			import cn.flightfeather.supervision.lightshare.vo.dataprod.DPChangeInfo
			import cn.flightfeather.supervision.lightshare.vo.dataprod.DPProblemRecurrence
			import cn.flightfeather.supervision.lightshare.vo.dataprod.QueryOptSingle
			import cn.flightfeather.supervision.lightshare.vo.dataprod.base.DPInspectionInfo
			import org.springframework.beans.BeanUtils
			import org.springframework.stereotype.Service
			import tk.mybatis.mapper.entity.Example
			@@ -24,7 +23,7 @@
			class DataProdSingleSceneServiceImpl(private val aopDbMapper: AopDbMapper) : DataProdSingleSceneService {

			// 整改要求最大耗时（天）
			private val maxChangeTime = 3
			private val MAX_CHANGE_TIME = 3

			override fun getChangeInfo(option: QueryOptSingle): DPChangeInfo {
			return QueryByCache.queryCache(
			@@ -41,21 +40,44 @@
			})
			return@queryCache DPChangeInfo().apply {
			subTasks = subtaskList
			problems = problemList.map {problem ->
			problems = problemList.map { problem ->
			val problemListVo = ProblemListVo()
			BeanUtils.copyProperties(problem, problemListVo)
			problemListVo
			}
			proCount = problemList.size
			changeCount = problemList.count { it.ischanged == true }
			changePer = if (proCount == 0) 0.0 else changeCount.toDouble() / proCount
			changeTime = problemList
			.filter { it.ischanged == true }
			.maxOf { (it.changedtime?.time?:0L) - (it?.time?.time?:0L) }.toInt()
			.div(1000 * 60 * 60 * 24)

			val eff = if (changeTime == 0) 1.0 else maxChangeTime.toDouble() / changeTime
			changeEfficiency = if (eff > 1.0) 1.0 else eff
			val changeTimeList = mutableListOf<Long>()
			problemList.forEach { p ->
			if (p.ischanged != true) return@forEach
			// 整改耗时（天）
			val day = ((p.changedtime?.time ?: 0L) - (p?.time?.time ?: 0L)).div(1000 * 60 * 60 * 24)
			changeTimeList.add(day)

			// 及时现场整改
			if (day <= 1) {
			immeChangeCount++
			}
			// 常态/规范整改（48小时内整改）
			else if (day < MAX_CHANGE_TIME) {
			normalChangeCount++
			}
			// 最终整改
			changeCount++
			}
			immeChangePer = if (proCount == 0) 0.0 else immeChangeCount.toDouble() / proCount
			normalChangePer = if (proCount == 0) 0.0 else normalChangeCount.toDouble() / proCount
			changePer = if (proCount == 0) 0.0 else changeCount.toDouble() / proCount

			if (changeTimeList.isNotEmpty()) {
			changeTime = changeTimeList.maxOrNull()?.toInt() ?: 0
			val eff = if (changeTime == 0) 1.0 else MAX_CHANGE_TIME.toDouble() / changeTime
			changeEfficiency = if (eff > 1.0) 1.0 else eff

			avgChangeTime = changeTimeList.average().toInt()
			val effAvg = if (avgChangeTime == 0) 1.0 else MAX_CHANGE_TIME.toDouble() / avgChangeTime
			avgChangeEfficiency = if (effAvg > 1.0) 1.0 else effAvg
			}
			}
			}
			)
			@@ -70,35 +92,38 @@
			cache = { return@queryCache null },
			calculate = {
			val problemList = aopDbMapper.problemlistMapper.selectByExample(Example(Problemlist::class.java).apply {
			createCriteria().andEqualTo("scenseid", option.sceneId)
			.andBetween("planstarttime", option.startTime, option.endTime)
			orderBy("planstarttime").desc()
			createCriteria().andEqualTo("sguid", option.sceneId)
			.andBetween("time", option.startTime, option.endTime)
			orderBy("time").desc()
			})
			if (problemList.isEmpty()) return@queryCache emptyList()
			val problemTypeList = aopDbMapper.problemtypeMapper.selectByExample(Example(Problemtype::class.java)
			.apply { createCriteria().andIn("guid", problemList.map { it.ptguid }) })
			val problemTypeList = aopDbMapper.problemtypeMapper.selectByExample(
			Example(Problemtype::class.java)
			.apply { createCriteria().andIn("guid", problemList.map { it.ptguid }) })

			val problemMap = problemList
			.filter {
			val type = problemTypeList.find { type-> type.guid == it.ptguid }
			val type = problemTypeList.find { type -> type.guid == it.ptguid }
			type?.typename != "道路扬尘" \|\| type.description == "工地内多条道路明显泥痕/泥泞/积尘/遗撒"
			}.groupBy { problem ->
			val type = problemTypeList.find { type-> type.guid == problem.ptguid } ?: return@groupBy null
			/**
			* 2025.10.30 目前根据业务要求，在工地类型中，“道路扬尘”问题出现概率非常高，
			* 因此该问题在做重复性统计时，只统计用其子类型"工地内多条道路明显泥痕/泥泞/积尘/遗撒"为分类类型
			*/
			if (type.typename == "道路扬尘") {
			val type = problemTypeList.find { type -> type.guid == problem.ptguid } ?: return@groupBy null
			// /**
			// * 2025.10.30 目前根据业务要求，在工地类型中，“道路扬尘”问题出现概率非常高，
			// * 因此该问题在做重复性统计时，只统计用其子类型"工地内多条道路明显泥痕/泥泞/积尘/遗撒"为分类类型
			// */
			// if (type.typename == "道路扬尘") {
			// type.description
			// } else {
			// type.typename
			// }
			type.description
			} else {
			type.typename
			}
			}
			return@queryCache problemMap.map { (key, value) ->
			val type = problemTypeList.find { type-> type.guid == value.first().ptguid }
			val type = problemTypeList.find { type -> type.guid == value.first().ptguid }
			DPProblemRecurrence().apply {
			problemTag = key
			problemType = type
			this.problemList = value
			count = value.size
			changeCount = value.count { it.ischanged == true }
			changePer = if (count == 0) 0.0 else changeCount.toDouble() / count