package cn.flightfeather.supervision.business.report
|
|
import cn.flightfeather.supervision.common.utils.Constant
|
import cn.flightfeather.supervision.common.utils.DateUtil
|
import cn.flightfeather.supervision.domain.ds1.entity.*
|
import cn.flightfeather.supervision.domain.ds1.mapper.*
|
import cn.flightfeather.supervision.domain.ds2.entity.LedgerRecord
|
import cn.flightfeather.supervision.domain.ds2.entity.LedgerSubType
|
import cn.flightfeather.supervision.domain.ds2.entity.UserMap
|
import cn.flightfeather.supervision.domain.ds2.mapper.LedgerRecordMapper
|
import cn.flightfeather.supervision.domain.ds2.mapper.LedgerSubTypeMapper
|
import cn.flightfeather.supervision.domain.ds2.mapper.UserMapMapper
|
import cn.flightfeather.supervision.lightshare.vo.ExcelConfigVo
|
import org.springframework.stereotype.Component
|
import tk.mybatis.mapper.entity.Example
|
import java.time.LocalDateTime
|
import java.time.ZoneId
|
|
/**
|
* 报告所需源数据
|
* 生成报告时，统一获取各基础数据
|
* @param config 生成报告的参数
|
*/
|
class DataSource(val config: ExcelConfigVo, val dbMapper: DbMapper){
|
|
private val sourceList = mutableListOf<Subtask>()
|
|
var year = 0
|
|
var month = 0
|
|
var area = ""
|
|
val rowData = RowData()
|
|
init {
|
// if (config.districtCode == null) {
|
// throw IllegalStateException("参数缺少区县编码:[districtCode]")
|
// }
|
// if (config.sceneType == null) {
|
// throw IllegalStateException("参数缺少场景类型:[sceneType]")
|
// }
|
getSource(config)
|
}
|
|
fun loop(callback: (index:Int, rowData: RowData) -> Unit) {
|
// reset()
|
for (i in sourceList.indices) {
|
// rowData.recordLastScene()
|
rowData.index = i
|
rowData.subTask = sourceList[i]
|
rowData.clear()
|
callback(i, rowData)
|
}
|
}
|
|
/**
|
* 重置
|
*/
|
fun reset() {
|
rowData.index = 0
|
rowData.subTask = if (sourceList.isEmpty()) null else sourceList.first()
|
rowData.clear()
|
}
|
|
/**
|
* 数据统计的时间和区域名称
|
*/
|
fun areaName(): String {
|
val t = dbMapper.taskMapper.selectByPrimaryKey(config.topTaskGuid)
|
return "${DateUtil.DateToString(t.starttime, DateUtil.DateStyle.YYYY_MM_CN)}${t.districtname}${if (area != t.districtname) area else ""}${Constant.SceneType.getDes(config.sceneType)}"
|
}
|
|
/**
|
* 获取报告数据源（巡查任务）
|
*/
|
private fun getSource(config: ExcelConfigVo) {
|
// if (config.sceneType == null) return
|
|
val result = mutableListOf<Subtask>()
|
|
if (config.townCode != null) {
|
dbMapper.townMapper.selectByExample(Example(Town::class.java).apply {
|
createCriteria().andEqualTo("towncode", config.townCode)
|
})?.takeIf { it.isNotEmpty() }?.get(0)?.let { area = it.townname ?: "" }
|
}
|
|
dbMapper.taskMapper.selectByPrimaryKey(config.topTaskGuid)?.let {
|
val time = LocalDateTime.ofInstant(it.starttime?.toInstant(), ZoneId.systemDefault())
|
this.year = time.year
|
this.month = time.monthValue
|
if (area.isBlank()) area = it.districtname ?: ""
|
}
|
|
//1. 查找特定的巡查任务或者所有的计划巡查任务
|
val taskSceneIdList = dbMapper.scenseMapper.getSceneByType(config.topTaskGuid, config.sceneType,
|
config.townCode).map { it.guid ?: "" }
|
|
// 统计总任务下所有场景
|
if (config.allScene) {
|
val subTaskList = dbMapper.subtaskMapper.selectByExample(Example(Subtask::class.java).apply {
|
createCriteria().apply {
|
if (taskSceneIdList.isNotEmpty()) andIn("scenseid", taskSceneIdList)
|
}.andEqualTo("tguid", config.topTaskGuid)
|
})
|
// 给还未巡查的场景生成空的子任务对象
|
if (taskSceneIdList.isNotEmpty()) {
|
taskSceneIdList.forEach {
|
var subtask: Subtask? = null
|
for (s in subTaskList) {
|
if (s.scenseid == it) {
|
subtask = s
|
result.add(s)
|
}
|
}
|
if (subtask == null) {
|
result.add(Subtask().apply { scenseid = it })
|
}
|
}
|
} else {
|
result.addAll(subTaskList)
|
}
|
}
|
else {
|
val subTaskList = dbMapper.subtaskMapper.selectByExample(Example(Subtask::class.java).apply {
|
createCriteria().apply {
|
if (config.subTaskIdList?.isNotEmpty() == true) andIn("stguid", config.subTaskIdList)
|
config.startTime?.let { andGreaterThanOrEqualTo("planstarttime", it) }
|
config.endTime?.let { andLessThanOrEqualTo("planendtime", it) }
|
config.districtCode?.let { andEqualTo("districtcode", it) }
|
andEqualTo("tguid", config.topTaskGuid)
|
}
|
})
|
result.addAll(subTaskList)
|
}
|
|
sourceList.addAll(result)
|
}
|
|
|
inner class RowData(){
|
var index = 0
|
|
var subTask: Subtask? = null
|
|
private var lastScene: Scense? = null
|
|
//场景基本信息
|
val scene: Scense?
|
get() {
|
if (_scene == null) {
|
_scene = dbMapper.scenseMapper.selectByPrimaryKey(subTask?.scenseid)
|
}
|
return _scene
|
}
|
private var _scene: Scense? = null
|
|
//各场景特有的基本信息
|
val baseScene: BaseScene?
|
get() {
|
if (_baseScene == null) {
|
_baseScene = when (this.scene?.typeid.toString()) {
|
Constant.SceneType.TYPE1.value -> {
|
dbMapper.sceneConstructionSiteMapper.selectByPrimaryKey(scene?.guid)
|
}
|
Constant.SceneType.TYPE2.value -> {
|
dbMapper.sceneWharfMapper.selectByPrimaryKey(scene?.guid)
|
}
|
Constant.SceneType.TYPE3.value -> {
|
dbMapper.sceneMixingPlantMapper.selectByPrimaryKey(scene?.guid)
|
}
|
Constant.SceneType.TYPE14.value -> {
|
dbMapper.sceneStorageYardMapper.selectByPrimaryKey(scene?.guid)
|
}
|
else -> null
|
}
|
}
|
return _baseScene
|
}
|
private var _baseScene: BaseScene? = null
|
|
//具体的问题
|
val problems: List<Problemlist>
|
get() {
|
if (noRecord()) return mutableListOf()
|
|
if (_problems == null) {
|
val r = dbMapper.problemlistMapper.selectByExample(Example(Problemlist::class.java).apply {
|
createCriteria().andEqualTo("stguid", subTask?.stguid)
|
})
|
_problems = r
|
}
|
return _problems ?: emptyList()
|
}
|
private var _problems: List<Problemlist>? = null
|
|
//评估总分
|
val evaluation: Evaluation?
|
get() {
|
if (_evaluation == null) {
|
if (noRecord()) return null
|
|
dbMapper.evaluationMapper.selectByExample(Example(Evaluation::class.java).apply {
|
createCriteria().andEqualTo("stguid", subTask?.stguid)
|
})?.takeIf { it.isNotEmpty() }?.let { _evaluation = it[0] }
|
}
|
return _evaluation
|
}
|
private var _evaluation: Evaluation? = null
|
|
//评估细则得分
|
val itemevaluationList: List<Itemevaluation>
|
get() {
|
if (_itemevaluationList == null) {
|
val r = dbMapper.itemevaluationMapper.selectByExample(Example(Itemevaluation::class.java).apply {
|
createCriteria().andEqualTo("stguid", subTask?.stguid)
|
})
|
_itemevaluationList = r
|
println("-------------------itemevaluationList--------------------------------")
|
}
|
return _itemevaluationList ?: emptyList()
|
}
|
private var _itemevaluationList: List<Itemevaluation>? = null
|
|
//问题类型
|
val problemTypes: List<Problemtype>
|
get() {
|
if (_problemTypes == null) {
|
val r = dbMapper.problemtypeMapper.selectByExample(Example(Problemtype::class.java).apply {
|
createCriteria().andEqualTo("scensetypeid", scene?.typeid)
|
.andEqualTo("districtcode", scene?.districtcode)
|
orderBy("extension1")
|
})
|
_problemTypes = r
|
}
|
return _problemTypes ?: emptyList()
|
}
|
private var _problemTypes: List<Problemtype>? = null
|
|
//自动评分规则一级分类
|
val topItems: List<Evaluationsubrule2>
|
get() {
|
if (_topItems == null) {
|
val tempTopItems = mutableListOf<Evaluationsubrule2>()
|
val secRules = mutableListOf<Pair<Evaluationsubrule2, MutableList<Evaluationsubrule2>>>()
|
val rule = dbMapper.evaluationruleMapper.selectByExample(Example(Evaluationrule::class.java).apply {
|
createCriteria()
|
.andEqualTo("tasktypeid", 99)
|
.andEqualTo("scensetypeid", scene?.typeid)
|
})
|
if (rule.isNotEmpty()) {
|
val ruleId = rule[0].guid
|
val rules = dbMapper.evaluationsubruleMapper.selectByExample(Example(Evaluationsubrule2::class.java).apply {
|
createCriteria().andEqualTo("erguid", ruleId)
|
})
|
rules.forEach {
|
if (it.ertype == 2) {
|
tempTopItems.add(it)
|
}
|
}
|
tempTopItems.sortBy { it.displayid }
|
|
var t = 0
|
tempTopItems.forEach {
|
t += it.maxscore ?: 0
|
val tempRules = mutableListOf<Evaluationsubrule2>()
|
for (i in rules) {
|
if (i.fatherid == it.guid && i.ertype == 3) {
|
tempRules.add(i)
|
}
|
}
|
//评分大项如果没有找到评分小项，则说明其直接对应最小评分项，其本身变成评分项
|
if (tempRules.isEmpty()) {
|
tempRules.add(it)
|
}
|
tempRules.sortBy { t -> t.displayid }
|
tempRules.forEach { temp ->
|
val tempSubRules = mutableListOf<Evaluationsubrule2>()
|
for (i in rules) {
|
if (i.fatherid == temp.guid && i.ertype == 4) {
|
tempSubRules.add(i)
|
}
|
}
|
tempSubRules.sortBy { ts -> ts.displayid }
|
secRules.add(Pair(temp, tempSubRules))
|
}
|
}
|
}
|
this._rules = secRules
|
_topItems = tempTopItems
|
}
|
return _topItems ?: emptyList()
|
}
|
private var _topItems: List<Evaluationsubrule2>? = null
|
|
//自动评分规则二级和三级分类
|
val rules: List<Pair<Evaluationsubrule2, MutableList<Evaluationsubrule2>>>
|
get() {
|
if (_rules == null) {
|
this.topItems
|
}
|
return _rules ?: emptyList()
|
}
|
private var _rules: List<Pair<Evaluationsubrule2, MutableList<Evaluationsubrule2>>>? = null
|
|
//必填台账数量
|
val ledgerCount: Int
|
get() {
|
if (_ledgerCount == -1) {
|
val tzSceneType = Constant.SceneType.typeMap(scene?.typeid)
|
_ledgerCount = dbMapper.ledgerSubTypeMapper.selectCountByExample(Example(LedgerSubType::class.java).apply {
|
createCriteria().andEqualTo("lScenetype", tzSceneType).andEqualTo("lNeedupdate", true)
|
})
|
}
|
return _ledgerCount
|
}
|
private var _ledgerCount = -1
|
|
//用户实际提交台账数量
|
val ledgerRecords: List<LedgerRecord>
|
get() {
|
if (_ledgerRecordNum == null) {
|
val userInfo = dbMapper.userinfoMapper.selectByExample(Example(Userinfo::class.java).apply {
|
createCriteria().andEqualTo("dGuid", subTask?.scenseid)
|
})?.takeIf { l -> l.isNotEmpty() }?.get(0)
|
|
val tzUserId = dbMapper.userMapMapper.selectByExample(Example(UserMap::class.java).apply {
|
createCriteria().andEqualTo("svUserId", userInfo?.guid)
|
})?.takeIf { m-> m.isNotEmpty() }?.get(0)?.tzUserId
|
|
if (tzUserId != null) {
|
_ledgerRecordNum = dbMapper.ledgerRecordMapper.selectByExample(Example(LedgerRecord::class.java).apply {
|
createCriteria().andEqualTo("lrYear", year)
|
.andEqualTo("lrMonth", month)
|
.andEqualTo("lrSubmitid", tzUserId)
|
})
|
}
|
}
|
return _ledgerRecordNum ?: emptyList()
|
}
|
private var _ledgerRecordNum: List<LedgerRecord>? = null
|
|
/**
|
* 获取当前巡查任务的上期巡查记录
|
*/
|
fun lastOne(): RowData {
|
val last = RowData()
|
val r = dbMapper.subtaskMapper.selectByExample(Example(Subtask::class.java).apply {
|
createCriteria().andEqualTo("scenseid", subTask?.scenseid)
|
.andLessThan("planstarttime", subTask?.planstarttime)
|
orderBy("planstarttime").desc()
|
})
|
if (r.isNotEmpty()) {
|
val thisMonth = LocalDateTime.ofInstant(subTask?.planstarttime?.toInstant(), ZoneId.systemDefault()).withDayOfMonth(1).toLocalDate()
|
val lastMonth = LocalDateTime.ofInstant(r[0]?.planstarttime?.toInstant(), ZoneId.systemDefault()).withDayOfMonth(1).toLocalDate()
|
if (lastMonth.plusMonths(1).isEqual(thisMonth)) {
|
last.subTask = r[0]
|
}
|
}
|
return last
|
}
|
|
/**
|
* 记录上一个场景
|
*/
|
fun recordLastScene() {
|
lastScene = scene
|
}
|
|
/**
|
* 清空当前处理的对象的相关数据源
|
*/
|
fun clear() {
|
_scene = null
|
_baseScene = null
|
_problems = null
|
_evaluation = null
|
_itemevaluationList = null
|
_ledgerRecordNum = null
|
if (lastScene != null && lastScene?.typeid != scene?.typeid) {
|
_problemTypes = null
|
_topItems = null
|
_rules = null
|
_ledgerCount = -1
|
}
|
recordLastScene()
|
}
|
|
/**
|
* 判断场景是否巡查监管，有无巡查记录
|
*/
|
fun noRecord() = subTask?.stguid == null
|
}
|
}
|
|
@Component
|
data class DbMapper(
|
val scenseMapper: ScenseMapper,
|
val problemlistMapper: ProblemlistMapper,
|
val problemtypeMapper: ProblemtypeMapper,
|
val subtaskMapper: SubtaskMapper,
|
val monitorobjectversionMapper: MonitorobjectversionMapper,
|
val sceneConstructionSiteMapper: SceneConstructionSiteMapper,
|
val sceneMixingPlantMapper: SceneMixingPlantMapper,
|
val sceneStorageYardMapper: SceneStorageYardMapper,
|
val sceneWharfMapper: SceneWharfMapper,
|
val taskMapper: TaskMapper,
|
val evaluationruleMapper: EvaluationruleMapper,
|
val evaluationsubruleMapper: EvaluationsubruleMapper2,
|
val evaluationMapper: EvaluationMapper,
|
val itemevaluationMapper: ItemevaluationMapper,
|
val ledgerSubTypeMapper: LedgerSubTypeMapper,
|
val ledgerRecordMapper: LedgerRecordMapper,
|
val userinfoMapper: UserinfoMapper,
|
val userMapMapper: UserMapMapper,
|
val townMapper: TownMapper,
|
)
|
