package cn.flightfeather.supervision.business.fume
|
|
import cn.flightfeather.supervision.business.Info
|
import cn.flightfeather.supervision.business.ScoreItem
|
import cn.flightfeather.supervision.business.fume.item.*
|
import cn.flightfeather.supervision.common.utils.Constant
|
import cn.flightfeather.supervision.common.utils.DateUtil
|
import cn.flightfeather.supervision.common.utils.ExcelUtil
|
import cn.flightfeather.supervision.common.utils.UUIDGenerator
|
import cn.flightfeather.supervision.domain.ds1.entity.*
|
import cn.flightfeather.supervision.domain.ds1.mapper.*
|
import cn.flightfeather.supervision.domain.ds2.entity.UserMap
|
import cn.flightfeather.supervision.domain.ds2.mapper.UserMapMapper
|
import org.apache.poi.hssf.usermodel.HSSFWorkbook
|
import org.apache.poi.hssf.util.HSSFColor
|
import org.springframework.beans.factory.annotation.Autowired
|
import org.springframework.stereotype.Component
|
import tk.mybatis.mapper.entity.Example
|
import java.io.File
|
import java.io.FileOutputStream
|
import java.time.*
|
import java.util.*
|
import javax.annotation.PostConstruct
|
import kotlin.math.abs
|
|
/**
|
* 自动评分
|
*/
|
@Component
|
class AutoScore3(
|
val scoreItem_1: ScoreItem_1, val scoreItem_2: ScoreItem_2, val scoreItem_3: ScoreItem_3,
|
val scoreItem_4: ScoreItem_4, val scoreItem_5: ScoreItem_5, val scoreItem_6: ScoreItem_6,
|
val scoreItem_7: ScoreItem_7, val scoreItem_8: ScoreItem_8, val scoreItem_9: ScoreItem_9,
|
val scoreItem_10: ScoreItem_10, val scoreItem_11: ScoreItem_11,
|
) {
|
companion object {
|
private lateinit var instance: AutoScore3
|
//特殊评分项，计算总分时，若此评分项得分，当加上此评分项后的总分不超过得分上限，则计算，否则舍去
|
private const val SPECIAL_RULE = "监测设备"
|
// 餐饮
|
private val SCENE_TYPE = Constant.ScenseType.TYPE5
|
}
|
|
@PostConstruct
|
fun init() {
|
instance = this
|
}
|
|
@Autowired
|
lateinit var userinfoMapper: UserinfoMapper
|
|
@Autowired
|
lateinit var userMapMapper: UserMapMapper
|
|
@Autowired
|
lateinit var scenseMapper: ScenseMapper
|
|
@Autowired
|
lateinit var evaluationruleMapper: EvaluationruleMapper
|
|
@Autowired
|
lateinit var evaluationsubruleMapper: EvaluationsubruleMapper2
|
|
@Autowired
|
lateinit var evaluationMapper: EvaluationMapper
|
|
@Autowired
|
lateinit var itemevaluationMapper: ItemevaluationMapper
|
|
@Autowired
|
lateinit var problemlistMapper: ProblemlistMapper
|
|
//决定是否写h3
|
private val hasHead3 = true
|
|
private var totalScore = 100//满分
|
|
private val itemList = mutableListOf<ScoreItem>()
|
|
private val baseRules = mutableListOf<Evaluationrule>()
|
|
private val rules = mutableListOf<Pair<Evaluationsubrule2, MutableList<Evaluationsubrule2>>>()
|
|
private val topItems = mutableListOf<Evaluationsubrule2>()
|
|
private var workbook = HSSFWorkbook()
|
|
init {
|
itemList.apply {
|
add(scoreItem_1)
|
add(scoreItem_2)
|
add(scoreItem_3)
|
add(scoreItem_4)
|
add(scoreItem_5)
|
add(scoreItem_6)
|
add(scoreItem_7)
|
add(scoreItem_9)
|
add(scoreItem_10)
|
add(scoreItem_11)
|
add(scoreItem_8)
|
}
|
}
|
|
fun go(_year: Int? = null, _month: Int? = null, _period: Int = 1) {
|
/** 1.excel文件准备*************************************************************************/
|
val fileName = "${SCENE_TYPE.text}自动评分-${DateUtil().DateToString(Date(), "yyyy-MM-ddhhmmss")}.xls"
|
val filePath = "E:\\工作\\开发\\第三方监管app\\自动评分\\餐饮\\$fileName"
|
// val filePath = "C:\\work\\工作\\第三方监管\\自动评分\\餐饮\\$fileName"
|
val out = FileOutputStream(File(filePath))
|
|
getScoreItem()
|
|
|
|
val contents = mutableListOf<Array<Any>>()
|
|
val h1 = mutableListOf<ExcelUtil.MyCell>()
|
h1.add(ExcelUtil.MyCell(""))
|
val h2 = mutableListOf<ExcelUtil.MyCell>()
|
h2.add(ExcelUtil.MyCell(""))
|
val h3 = mutableListOf<String>()
|
h3.add("")
|
topItems.forEach {
|
h1.add(ExcelUtil.MyCell(it.itemname ?: "", 1, 0))
|
for (r in rules) {
|
if (r.first.fatherid == it.guid || r.first.guid == it.guid) {
|
h2.add(ExcelUtil.MyCell(r.first.itemname ?: "", 1, 0))
|
// FIXME: 2021/4/25 决定是否写h3
|
if (hasHead3) {
|
r.second.forEach { s ->
|
h3.add(s.itemname ?: "")
|
h2.last().colSpan++
|
h1.last().colSpan++
|
}
|
} else {
|
h2.last().colSpan++
|
h1.last().colSpan++
|
}
|
}
|
}
|
}
|
// FIXME: 2021/4/25 决定是否写h3
|
if (hasHead3) {
|
h1.add(ExcelUtil.MyCell("总分", 3, 1))
|
h1.add(ExcelUtil.MyCell("环信码", 3, 1))
|
} else {
|
h1.add(ExcelUtil.MyCell("总分", 2, 1))
|
h1.add(ExcelUtil.MyCell("环信码", 2, 1))
|
}
|
|
contents.add(h1.toTypedArray())
|
contents.add(h2.toTypedArray())
|
// FIXME: 2021/4/25 决定是否写h3
|
if (hasHead3) {
|
contents.add(h3.toTypedArray())
|
}
|
|
/** 2. 筛选打分场景*************************************************************************/
|
val sceneList = scenseMapper.selectByExample(Example(Scense::class.java).apply {
|
createCriteria().andEqualTo("typeid", SCENE_TYPE.value.toByte())
|
.andNotEqualTo("extension1", '0')
|
// createCriteria().andEqualTo("guid", "eKIUnqn4RB64UNM0")
|
})
|
|
val now = LocalDate.now()
|
val year = _year ?: now.year
|
val month = _month ?: now.monthValue
|
val sMonth = DateUtil().getStartMonthByPeriod(month, _period) ?: 1
|
val eMonth = sMonth + _period - 1
|
val sTime = LocalDateTime.of(year, sMonth, 1, 0, 0)
|
val eTime = sTime.plusMonths(_period.toLong())
|
val period = "${year}/$sMonth-$eMonth"
|
|
/** 3. 循环处理每个场景，给每个场景打分*************************************************************************/
|
sceneList.forEach {
|
// 每个场景的评分豁免项都不一定相同，首先初始化是否豁免标志
|
itemList.forEach { s->
|
s.exemption = false
|
}
|
// 台账管理为必豁免项
|
// scoreItem_7.exemption = true
|
// 对应的豁免问题清空
|
scoreItem_8.clear()
|
|
topItems.forEach { s -> s.extension1 = null }
|
rules.forEach { p ->
|
p.first.extension1 = null
|
p.second.forEach { e -> e.extension1 = null }
|
}
|
|
val userInfo = userinfoMapper.selectByExample(Example(Userinfo::class.java).apply {
|
createCriteria().andEqualTo("dGuid", it.guid)
|
})?.takeIf { l -> l.isNotEmpty() }?.get(0)
|
|
val tzUserId = userMapMapper.selectByExample(Example(UserMap::class.java).apply {
|
createCriteria().andEqualTo("svUserId", userInfo?.guid)
|
})?.takeIf { m-> m.isNotEmpty() }?.get(0)?.tzUserId
|
|
val info = Info(
|
userInfo?.guid,
|
tzUserId,
|
it.guid,
|
it.name,
|
SCENE_TYPE,
|
year,
|
month,
|
_period,
|
sTime, eTime
|
)
|
|
var score = 0
|
|
/** 3. 根据系统记录的问题及外部来源，计算具体评分子项*************************************************************************/
|
val itemEvaluations = mutableListOf<Itemevaluation>()
|
rules.forEach {r ->
|
// 评分条目
|
val rule = r.first
|
// 具体评分选项
|
val subRule = r.second
|
subRule.forEach {sr ->
|
sr.problemlist?.let {pId ->
|
problemlistMapper.selectByExample(Example(Problemlist::class.java).apply {
|
createCriteria().andEqualTo("sguid", info.sceneId)
|
.andEqualTo("ptguid", pId)
|
.andGreaterThanOrEqualTo("time", info.sTime)
|
.andLessThan("time", info.eTime)
|
})?.takeIf { p-> p.isNotEmpty() }?.run {
|
sr.extension1 = (0 - (sr.maxscore ?: 0)).toString()
|
|
// 当规则扣分时，根据对应豁免的规则id，将对应的规则设置为豁免状态，同时清空其扣分
|
sr.gitlist?.split(";")?.forEach {g->
|
findRule(g) {r,p ->
|
// 清空关联规则的扣分
|
p.first.extension1 = "0"
|
p.second.forEach { it.extension1 = "0" }
|
// 找到对应的评估scoreItem，将其设置为豁免状态
|
for (i in itemList) {
|
if (i.id == p.first.guid) {
|
i.exemption = true
|
scoreItem_8.setExemptionProblem(p.second)
|
break
|
}
|
}
|
}
|
}
|
|
// 当规则扣分时，根据对应的联动扣分规则id，将对应规则进行联动扣分
|
sr.devicelist?.split(";")?.forEach {d ->
|
findRule(d) {r,p ->
|
// 扣除联动规则得分
|
r.extension1 = (0 - (r.maxscore ?: 0)).toString()
|
}
|
}
|
}
|
}
|
}
|
var total: Int? = null
|
subRule.forEach {sr ->
|
if (!sr.extension1.isNullOrBlank()) {
|
total = (total ?: 0) + sr.extension1!!.toInt()
|
}
|
}
|
if (total == null) {
|
rule.extension1 = "0"
|
} else {
|
val s = if (abs(total!!) > rule.maxscore!!) {
|
0 - rule.maxscore!!
|
} else {
|
total
|
}
|
rule.extension1 = s.toString()
|
}
|
}
|
itemList.forEach { si ->
|
si.execute2(info, rules)
|
}
|
|
/** 4. 补全各上级评分项的计分*************************************************************************/
|
this.rules.forEach { r ->
|
val fatherId = r.first.fatherid
|
for (t in topItems) {
|
if (t.guid == fatherId) {
|
var s = t.extension1?.toIntOrNull() ?: 0
|
s += r.first.extension1?.toIntOrNull() ?: 0
|
t.extension1 = s.toString()
|
break
|
}
|
}
|
}
|
|
/** 4. 计算总分*************************************************************************/
|
var total = 0//总扣除的分数
|
topItems.forEach top@{ top ->
|
total += top.extension1?.toIntOrNull() ?: 0
|
}
|
val evaluationList = mutableListOf<Evaluation>()
|
var evaluationId: String? = null
|
baseRules.forEach {
|
val evaluation = Evaluation().apply {
|
guid = UUIDGenerator.generate16ShortUUID()
|
iguid = info.userId
|
stguid = it.guid
|
scensetypeid = info.sceneType.value.toByte()
|
ertype = it.ruletype?.toByte()
|
scensename = period
|
evaluatorguid = "system"
|
evaluatorusername = "system"
|
evaluatorrealname = "2"
|
resultscorebef = (totalScore - abs(total)).toString()
|
createdate = Date()
|
updatedate = Date()
|
}
|
if (evaluation.ertype?.toInt() == 1) {
|
evaluationId = evaluation.guid
|
}
|
evaluationList.add(evaluation)
|
}
|
//子项具体得分
|
val itemevaluationList = mutableListOf<Itemevaluation>()
|
topItems.forEach { subRule ->
|
val item = newItemEvaluation(info, subRule, evaluationId)
|
itemevaluationList.add(item)
|
}
|
rules.forEach { p ->
|
if (p.first.ertype != 2) {
|
val item = newItemEvaluation(info, p.first, evaluationId)
|
itemevaluationList.add(item)
|
}
|
p.second.forEach { r ->
|
val item1 = newItemEvaluation(info, r, evaluationId)
|
itemevaluationList.add(item1)
|
}
|
}
|
// 添加至文档
|
addToFile(contents, info, evaluationList, topItems, this.rules)
|
// val r = evaluationMapper.selectByExample(Example(Evaluation::class.java).apply {
|
// createCriteria().andEqualTo("scensename", period)
|
// .andEqualTo("evaluatorguid", "system")
|
// .andEqualTo("iguid", info.userId)
|
//// .andEqualTo("ertype", 1)
|
// }).let { eList ->
|
// var guid: String? = null
|
// for (e in eList) {
|
// if (e.ertype?.toInt() == 1) {
|
// guid = e.guid
|
// break
|
// }
|
// }
|
// guid?.let {
|
// eList.forEach { e ->
|
// evaluationMapper.delete(e)
|
// }
|
// itemevaluationMapper.deleteByExample(Example(Itemevaluation::class.java).apply {
|
// createCriteria().andEqualTo("sguid", guid)
|
// })
|
// }
|
// } ?: 0
|
// 写入数据库
|
// if (r > 0) {
|
// evaluationList.forEach { el -> evaluationMapper.insert(el) }
|
// itemevaluationList.forEach { il -> itemevaluationMapper.insert(il) }
|
// for (e in evaluationList) {
|
// if (e.ertype?.toInt()?.equals(0) == true) {
|
// finalScore(e, year, eMonth, period)
|
// break
|
// }
|
// }
|
// }
|
}
|
|
// 写入文档
|
ExcelUtil.write(emptyList(), contents, workbook)
|
workbook.write(out)
|
workbook.close()
|
out.flush()
|
out.close()
|
}
|
|
/**
|
* 获取评分规则
|
*/
|
private fun getScoreItem() {
|
this.rules.clear()
|
baseRules.clear()
|
|
val rule = evaluationruleMapper.selectByExample(Example(Evaluationrule::class.java).apply {
|
createCriteria()
|
.andEqualTo("tasktypeid", 99)
|
.andEqualTo("scensetypeid", SCENE_TYPE.value.toByte())
|
.andEqualTo("districtcode", "310104")
|
})
|
if (rule.isNotEmpty()) {
|
baseRules.addAll(rule)
|
|
val ruleId = rule[0].guid
|
val rules = evaluationsubruleMapper.selectByExample(Example(Evaluationsubrule2::class.java).apply {
|
createCriteria().andEqualTo("erguid", ruleId)
|
})
|
rules.forEach {
|
if (it.ertype == 2) {
|
topItems.add(it)
|
}
|
}
|
topItems.sortBy { it.displayid }
|
|
var t = 0
|
topItems.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 }
|
this.rules.add(Pair(temp, tempSubRules))
|
}
|
}
|
// this.totalScore = t
|
}
|
}
|
|
/**
|
* 生成新的一条评分记录
|
*/
|
private fun newItemEvaluation(info: Info, itemRule: Evaluationsubrule2, evaluationId: String?) = cn.flightfeather.supervision.domain.ds1.entity.Itemevaluation()
|
.apply {
|
var rule: Evaluationrule? = null
|
for (r in baseRules) {
|
if (r.guid == itemRule.erguid) {
|
rule = r
|
break
|
}
|
}
|
ieguid = UUIDGenerator.generate16ShortUUID()
|
iguid = info.userId
|
sguid = evaluationId
|
erguid = rule?.guid
|
rulename = rule?.rulename
|
ruletype = rule?.ruletype?.toInt()
|
ertype = itemRule.ertype
|
esrguid = itemRule.guid
|
name = itemRule.itemname
|
value = itemRule.extension1 ?: "0"
|
extension1 = (itemRule.extension1 != null).toString()
|
}
|
|
private fun addToFile(contents: MutableList<Array<Any>>, info: Info, evaluations: List<Evaluation>, topItems: MutableList<Evaluationsubrule2>,
|
rules: MutableList<Pair<Evaluationsubrule2, MutableList<Evaluationsubrule2>>>) {
|
val cList = mutableListOf<Any>()
|
// FIXME: 2021/4/28 用户名是否添加账号
|
// cList.add("${info.userName}\t${info.userId}")
|
cList.add("${info.sceneName}")
|
//每一项具体得分
|
topItems.forEach {
|
for (r in rules) {
|
if (r.first.fatherid == it.guid || r.first.guid == it.guid) {
|
// FIXME: 2021/4/25 决定是否写h3
|
if (hasHead3) {
|
r.second.forEach {s ->
|
cList.add(s.extension1 ?: .0)
|
}
|
} else {
|
cList.add(.0 - (r.first.extension1?.toDoubleOrNull() ?: .0))
|
}
|
}
|
}
|
}
|
//总分和环信码
|
evaluations.forEach {
|
if ((it.ertype?.toInt() == 2)) {
|
cList.add(it.resultscorebef?.toDoubleOrNull() ?: .0)
|
val code = when (it.resultscorebef?.toIntOrNull() ?: 0) {
|
in 0..59 -> ExcelUtil.MyCell("红码", fontColor = HSSFColor.HSSFColorPredefined.RED.index)
|
in 60..89 -> ExcelUtil.MyCell("黄码", fontColor = HSSFColor.HSSFColorPredefined.GOLD.index)
|
in 90..100 -> ExcelUtil.MyCell("绿码", fontColor = HSSFColor.HSSFColorPredefined.BRIGHT_GREEN.index)
|
else -> ExcelUtil.MyCell("超出范围：${it.resultscoreaft}", fontColor = HSSFColor.HSSFColorPredefined.BLACK.index)
|
}
|
cList.add(code)
|
}
|
}
|
contents.add(cList.toTypedArray())
|
}
|
|
/**
|
* 根据规则id查找规则及其所在组
|
*/
|
private fun findRule(
|
ruleId: String,
|
onFound: (r: Evaluationsubrule2, p: Pair<Evaluationsubrule2, MutableList<Evaluationsubrule2>>) -> Unit
|
) {
|
with(rules)breaking@ {
|
forEach {
|
if (it.first.guid == ruleId) {
|
onFound(it.first, it)
|
return@breaking
|
} else {
|
for (r in it.second) {
|
if (r.guid == ruleId) {
|
onFound(r, it)
|
return@breaking
|
}
|
}
|
}
|
}
|
}
|
}
|
|
}
|
