2024.8.15 各项修正

feiyu02

2024-08-15 196bb14112448857a885e32dc4149e308e00b01a

 src/main/kotlin/cn/flightfeather/supervision/lightshare/service/Impl/EvaluationServiceImpl.kt

@@ -5,31 +5,33 @@
import cn.flightfeather.supervision.domain.enumeration.AssessmentRuleType
import cn.flightfeather.supervision.domain.enumeration.SceneType
import cn.flightfeather.supervision.domain.mapper.*
import cn.flightfeather.supervision.domain.repository.EvaluationRep
import cn.flightfeather.supervision.infrastructure.utils.DateUtil
import cn.flightfeather.supervision.infrastructure.utils.UUIDGenerator
import cn.flightfeather.supervision.domain.repository.UserConfigRep
import cn.flightfeather.supervision.lightshare.service.EvaluationService
import cn.flightfeather.supervision.lightshare.service.ItemevaluationService
import cn.flightfeather.supervision.lightshare.vo.AssessmentGradeVo
import cn.flightfeather.supervision.lightshare.vo.AssessmentSearchCondition
import cn.flightfeather.supervision.lightshare.vo.CreditInfoVo
import cn.flightfeather.supervision.lightshare.vo.GradeDetailVo
import cn.flightfeather.supervision.lightshare.vo.*
import com.github.pagehelper.PageHelper
import org.springframework.stereotype.Service
import tk.mybatis.mapper.entity.Example
import java.time.LocalDateTime
import java.util.*
import javax.servlet.http.HttpServletResponse

@Service
class EvaluationServiceImpl(
        val evaluationMapper: EvaluationMapper,
        val evaluationruleMapper: EvaluationruleMapper,
        val evaluationsubruleMapper: EvaluationsubruleMapper,
        val userinfoMapper: UserinfoMapper,
        val baseInfoMapper: BaseInfoMapper,
        val companyMapper: CompanyMapper,
        val overallEvaluationMapper: OverallEvaluationMapper,
        val autoScore: AutoScore,
        val itemevaluationService: ItemevaluationService
    val evaluationMapper: EvaluationMapper,
    val evaluationruleMapper: EvaluationruleMapper,
    val evaluationsubruleMapper: EvaluationsubruleMapper,
    val userinfoMapper: UserinfoMapper,
    val baseInfoMapper: BaseInfoMapper,
    val companyMapper: CompanyMapper,
    val overallEvaluationMapper: OverallEvaluationMapper,
    val autoScore: AutoScore,
    val itemevaluationService: ItemevaluationService,
    private val userConfigRep: UserConfigRep,
    private val evaluationRep: EvaluationRep,
) : EvaluationService {

    override fun findOne(id: String): Evaluation = evaluationMapper.selectByPrimaryKey(id)
@@ -38,7 +40,7 @@

    override fun save(evaluation: Evaluation): Int {
        updateRank(evaluation, true)
        return  evaluationMapper.insert(evaluation)
        return evaluationMapper.insert(evaluation)
    }

    override fun update(evaluation: Evaluation): Int {
@@ -48,17 +50,25 @@

    override fun delete(id: String): Int = evaluationMapper.deleteByPrimaryKey(id)

    override fun getTotalPoints(userId: String, evaluatorType: Int, startTime: String, endTime: String, sceneTypeId: Int?, erGuid: String?, eId: String?): List<Evaluation> {
    override fun getTotalPoints(
        userId: String,
        evaluatorType: Int,
        startTime: String,
        endTime: String,
        sceneTypeId: Int?,
        erGuid: String?,
        eId: String?,
    ): List<Evaluation> {
        val example = Example(Evaluation::class.java)
        val criteria = example.createCriteria()
        val startDate = DateUtil.StringToDate(startTime)
        val endDate = DateUtil.StringToDate(endTime)
        criteria.andEqualTo("iguid", userId)
                .andBetween("createdate", startDate, endDate)
            .andBetween("createdate", startDate, endDate)
        example.and(example.createCriteria().apply {
            if (evaluatorType == 0) {
                orEqualTo("evaluatorrealname", evaluatorType.toString())
                        .orIsNull("evaluatorrealname")
                    .orIsNull("evaluatorrealname")
            } else {
                andEqualTo("evaluatorrealname", evaluatorType.toString())
            }
@@ -67,24 +77,35 @@
        eId?.let { criteria.andEqualTo("guid", eId) }
        sceneTypeId?.let {
            example.and(example.createCriteria()
                    .orEqualTo("scensetypeid", sceneTypeId.toByte())
                    .orIsNull("scensetypeid")
                .orEqualTo("scensetypeid", sceneTypeId.toByte())
                .orIsNull("scensetypeid")
            )
        }

        return evaluationMapper.selectByExample(example)
    }

    override fun getHistoryPoint(userId: String, page: Int, per_page: Int, response: HttpServletResponse): List<AssessmentGradeVo> {
    override fun getHistoryPoint(
        userId: String,
        page: Int,
        per_page: Int,
        platform: String?,
        period: String?,
        response: HttpServletResponse,
    ): List<AssessmentGradeVo> {
        val userInfo = userinfoMapper.selectByPrimaryKey(userId) ?: return emptyList()

        // FIXME: 2022/11/8 临时添加过度功能，提供微信小程序前端汽修类型的场景单独的评估清单 ，场景类型为 -7
        var sceneType = userInfo.extension2
        if (platform == "weixin" && sceneType == SceneType.VehicleRepair.value.toString()) {
            sceneType = "-7"
        }
        //评分规则下的分级、等级颜色及等级评语
        val pointLevel = mutableListOf<Pair<Int, Int>>()
        val evaluateLevel = mutableListOf<String>()
        val creditTexts = mutableListOf<String>()
        val levelColors = mutableListOf<String>()
        val rule = evaluationruleMapper.selectByExample(Example(Evaluationrule::class.java).apply {
            createCriteria().andEqualTo("scensetypeid", userInfo.extension2)
            createCriteria().andEqualTo("scensetypeid", sceneType)
                .andEqualTo("ruletype", "0")
        })
        if (rule.isNotEmpty()) {
@@ -105,10 +126,15 @@
        }
        val example = Example(Evaluation::class.java).apply {
            createCriteria().andEqualTo("iguid", userId)
                    .andEqualTo("ertype", AssessmentRuleType.Total.value.toByte())
                .andEqualTo("ertype", AssessmentRuleType.Total.value.toByte())
                .apply {
                    period?.let { andEqualTo("scensename", it) }
                }
            //根据评估人的类型进行筛选，自评和官方评分分开排名
            and(createCriteria().orIsNull("evaluatorrealname")
                    .orEqualTo("evaluatorrealname", 0))
            and(
                createCriteria().orIsNull("evaluatorrealname")
                    .orEqualTo("evaluatorrealname", 0)
            )
            orderBy("createdate").desc()
        }
        val counts = evaluationMapper.selectCountByExample(example)
@@ -124,7 +150,7 @@
            resultList.add(AssessmentGradeVo().apply {
                this.userId = userId
                userRealName = userInfo.realname
                sceneType = userInfo.extension2?.toIntOrNull() ?: SceneType.NoType.value
                this.sceneType = userInfo.extension2?.toIntOrNull() ?: SceneType.NoType.value
                tPGuid = it.guid
                tPRuleGuid = it.stguid
                totalPoint = it.resultscorebef?.toInt() ?: 0
@@ -134,47 +160,52 @@
                creditText = l["creditText"]
                rank = it.promissednum ?: 1
                updateDate = it.createdate
                period = it.scensename
                this.period = it.scensename
            })
        }

        return resultList
    }

    override fun getCreditInfo(userId: String): CreditInfoVo {
        val userinfo = userinfoMapper.selectByPrimaryKey(userId)
    override fun getCreditInfo(userId: String, period: String?): CreditInfoVo {
        val userinfo = userinfoMapper.selectByPrimaryKey(userId) ?: return CreditInfoVo()
        val baseInfo = baseInfoMapper.selectByPrimaryKey(userId)
        val company = companyMapper.selectByPrimaryKey(baseInfo.ciGuid)

        val company = baseInfo?.let { companyMapper.selectByPrimaryKey(it.ciGuid) }

        val result = CreditInfoVo(
                userId,
                baseInfo.biName,
                userinfo.extension2?.toIntOrNull() ?: SceneType.NoType.value,
                baseInfo.ciName,
                baseInfo.biManagementCompany,
                baseInfo.biContact,
                baseInfo.biTelephone,
                baseInfo.biAddress,
                district = company.ciDistrictName,
                town = company.ciTownName
            userId,
            baseInfo?.biName,
            userinfo?.extension2?.toIntOrNull() ?: SceneType.NoType.value,
            baseInfo?.ciName,
            baseInfo?.biManagementCompany,
            baseInfo?.biContact,
            baseInfo?.biTelephone,
            baseInfo?.biAddress,
            district = company?.ciDistrictName,
            town = company?.ciTownName
        )

        val rule = evaluationruleMapper.selectByExample(Example(Evaluationrule::class.java).apply {
            val c = createCriteria()
            userinfo.extension2?.toByteOrNull()?.let {
            userinfo?.extension2?.toByteOrNull()?.let {
                c.andEqualTo("scensetypeid", it)
                        .andEqualTo("ruletype", "0")
                    .andEqualTo("ruletype", "0")
            }
        }).takeIf { it.isNotEmpty() }?.get(0) ?: return result

        val periodList = DateUtil.getSuitablePeriod(period)
        val overallEvaluation = overallEvaluationMapper.selectByExample(Example(OverallEvaluation::class.java).apply {
            createCriteria().andEqualTo("biGuid", baseInfo.biGuid)
            createCriteria().andEqualTo("biGuid", userinfo?.guid)
                .apply {
                    if (periodList.isNotEmpty()) {
                        andIn("oePeriod", periodList)
                    }
                }
            orderBy("oePublishTime").desc()
        }).takeIf { it.isNotEmpty() }?.get(0) ?: return result

        //评分记录对应 的打分周期 ，格式为 YYYY/M-M，某年某月至某月
        val period = overallEvaluation.oePeriod
//        val period = overallEvaluation.oePeriod
        //评分等级分数界限，格式为  0,59#60,89#90,100，表示有三个分数段
        val levels = rule.extension1?.split("#")?.asReversed()
        //评分等级对应的描述，格式为 较差#一般#优秀，对应三个分数段的描述
@@ -216,15 +247,51 @@
        return result
    }

    override fun getCreditCount(userId: String, condition: UserSearchCondition): BaseResponse<CountVo> {
        if (condition.sceneTypes.size != 1) return BaseResponse(false, "只支持单个场景类型的查询")

    override fun getAssessments(userId: String, condition: AssessmentSearchCondition, page: Int, perPage: Int, response: HttpServletResponse): List<AssessmentGradeVo> {
        val config = userConfigRep.getUserConfigBySubType(userId)
        val condition2 = UserSearchCondition.fromUserConfig(config, condition)

        // 绿码
        var level0 = 0
        // 黄码
        var level1 = 0
        // 红码
        var level2 = 0
        condition2.period = condition2.period
            ?: overallEvaluationMapper.getLatestPeriod(condition2)
                    ?: return BaseResponse(false, "无记录")

        overallEvaluationMapper.getCreditCount(condition2).forEach {
            when (it.oeCodeLevel?.toInt()) {
                0 -> level0++
                1 -> level1++
                2 -> level2++
            }
        }
        val result = CountVo().apply {
            tag = condition2.period
            countList.addAll(listOf(level0, level1, level2))
        }

        return BaseResponse(true, data = result)
    }

    override fun getAssessments(
        userId: String,
        condition: AssessmentSearchCondition,
        page: Int,
        perPage: Int,
        response: HttpServletResponse,
    ): List<AssessmentGradeVo> {
        val user = userinfoMapper.selectByPrimaryKey(userId)
        val districtName = user.extension1
        val districtName = user?.extension1

        val p = PageHelper.startPage<Evaluation>(page, perPage)

        val result = mutableListOf<AssessmentGradeVo>()
        evaluationMapper.getAssessments(districtName?:"", condition.searchText, "", condition.sceneTypes).forEach {
        evaluationMapper.getAssessments(districtName ?: "", condition.searchText, "", condition.sceneTypes).forEach {
            //此处由于 PageHelper 的分页操作，会导致结果的数量强制为 perPage的值，包括null
            if (it != null) {
                result.add(AssessmentGradeVo().apply {
@@ -252,12 +319,23 @@
        return response
    }

    override fun uploadScore(userId: String, period: String, ruleId: String?, itemList: List<Pair<String, String>>): Boolean {
    override fun uploadScore(
        userId: String,
        period: String,
        ruleId: String?,
        itemList: List<Pair<String, String>>,
    ): Boolean {
        val userinfo = userinfoMapper.selectByPrimaryKey(userId) ?: return false
        var sceneType = userinfo.extension2

        // FIXME: 2022/11/8 临时添加过度功能，提供微信小程序前端汽修类型的场景单独的评估清单 ，场景类型为 -7
        if (sceneType == SceneType.VehicleRepair.value.toString()) {
            sceneType = "-7"
        }

        //该场景类型下的总得分规则
        val tRule = evaluationruleMapper.selectByExample(Example(Evaluationrule::class.java).apply {
            createCriteria().andEqualTo("scensetypeid", userinfo.extension2)
            createCriteria().andEqualTo("scensetypeid", sceneType)
                .andEqualTo("ruletype", AssessmentRuleType.Total.value)
                .andIsNull("tasktypeid")
        }).takeIf { it.isNotEmpty() }?.get(0)
@@ -265,20 +343,11 @@
        var totalPoint = 0
        var tEvaluation = Evaluation()

        //上传的得分规则
//        var rule = Evaluationrule()
//        val subRules:List<Evaluationsubrule> = if (ruleId != null) {
//            rule = evaluationruleMapper.selectByPrimaryKey(ruleId)
//            evaluationsubruleMapper.selectByExample(Example(Evaluationsubrule::class.java).apply {
//                createCriteria().andEqualTo("erguid", ruleId)
//            })
//        }

        val ruleList = evaluationruleMapper.selectByExample(Example(Evaluationrule::class.java).apply {
            createCriteria().andEqualTo("scensetypeid", userinfo.extension2)
                    .andNotEqualTo("ruletype", AssessmentRuleType.Total.value)
        evaluationruleMapper.selectByExample(Example(Evaluationrule::class.java).apply {
            createCriteria().andEqualTo("scensetypeid", sceneType)
                .andNotEqualTo("ruletype", AssessmentRuleType.Total.value)
                .andIsNull("tasktypeid")
        }).forEach {rule->
        }).forEach { rule ->
            val subRules = evaluationsubruleMapper.selectByExample(Example(Evaluationsubrule::class.java).apply {
                createCriteria().andEqualTo("erguid", rule.guid)
            })
@@ -290,43 +359,49 @@
            //总得分
            var totalScore = 0

            //根据上传的选择的条目，生成对应的评分记录
            itemList.forEach {
                for (s in subRules) {
                    if (s.guid == it.first) {
                        var fatherId: String?
                        var subRule = s
                        var score = it.second
                        // 根据上传的条目生成对应的该条目得分记录以及其所有的父项条目的得分记录
                        do {
                            val result = calculateScore(rule, evaluation.guid!!, userId, subRule, score, itemEvaluationList)
                            val result =
                                calculateScore(rule, evaluation.guid!!, userId, subRule, score, itemEvaluationList)
                            fatherId = result.first
                            for (s in subRules) {
                                if (s.guid == fatherId) {
                                    subRule = s
                            for (s1 in subRules) {
                                if (s1.guid == fatherId) {
                                    subRule = s1
                                    score = result.second ?: "0"
                                    break
                                }
                            }
                        } while (fatherId?.isNotBlank() == true)

                        totalScore += it.second.toInt()
                        break
                    }
                }
            }

            //总分
            //规则设定的最大分值
            var maxScore = 0
            subRules.forEach subRules@{s ->
                if (s.ertype == 2) {
            subRules.forEach subRules@{ s ->
                //计算应得总分，basic_score：表示基础分，计算在应得总分内；addition_score表示加分，不计算在内
                if (s.ertype == 2 && s.extension1 != "addition_score") {
                    maxScore += s.maxscore ?: 0
                }
                //规则已经打分完毕，则跳过
                itemEvaluationList.forEach {i ->
                itemEvaluationList.forEach { i ->
                    if (i.esrguid == s.guid) {
                        //如果是最大的2级评估规则，计算已获得的总分
                        if (s.ertype == 2) {
                            totalScore += i.value?.toInt() ?: 0
                        }
                        return@subRules
                    }
                }
                //否则新增一条未扣分的记录
                //否则如果前端允许不用全部评分，新增一条未评分的记录
                itemEvaluationList.add(Itemevaluation().apply {
                    ieguid = UUIDGenerator.generate16ShortUUID()
                    iguid = userId
@@ -375,128 +450,163 @@
        return true
    }

    override fun updateScore(
        userId: String,
        period: String,
        ruleId: String?,
        itemList: List<Pair<String, String>>,
    ): Boolean {
        TODO("Not yet implemented")
    }

    override fun getDetail(userId: String, period: String): GradeDetailVo {
        val list = period.split("-")
        var endM = list[1].toInt()
        val list2 = list[0].split("/")
        val year = list2[0].toInt()
        var startM = list2[1].toInt()
        var st = LocalDateTime.of(year, startM, 1, 0, 0, 0, 0)
        var et = LocalDateTime.of(year, endM, 1, 0, 0, 0, 0).plusMonths(1)

        val result = GradeDetailVo()

        val userinfo = userinfoMapper.selectByPrimaryKey(userId) ?: return result
        var sceneType = SceneType.getByValue(userinfo.extension2?.toIntOrNull())
        // FIXME: 2022/11/8 临时添加过度功能，提供微信小程序前端汽修类型的场景单独的评估清单 ，场景类型为 -7
        if (sceneType == SceneType.VehicleRepair) {
            sceneType = SceneType.VehicleRepair
        }

        //该场景类型下的所有得分规则
        var rule0: Evaluationrule? = null
        val rule1List = mutableListOf<Evaluationrule>()
        evaluationruleMapper.selectByExample(Example(Evaluationrule::class.java).apply {
            createCriteria().andEqualTo("scensetypeid", userinfo.extension2)
                and(createCriteria().orIsNull("tasktypeid").orNotEqualTo("tasktypeid", 1))
        }).forEach {
            if (it.ruletype == AssessmentRuleType.Total.value.toString()) {
                rule0 = it
            } else {
                rule1List.add(it)
            }
        val rule0 = evaluationRep.findRule(sceneType) ?: return result
        //获得得分规则中定义的评估周期（单位：月）
        val rulePeriod = rule0.scensesubtypeid?.toInt() ?: 1
        DateUtil.getStartMonthByPeriod(startM, rulePeriod)?.let {
            startM = it
            endM = startM + rulePeriod - 1
            st = LocalDateTime.of(year, startM, 1, 0, 0, 0, 0)
            et = LocalDateTime.of(year, endM, 1, 0, 0, 0, 0).plusMonths(1)
        }
        if (rule0 == null) return result
        //得分解读和得分详情
        evaluationMapper.selectByExample(Example(Evaluation::class.java).apply {
        //获取最新一期的总分
        val latestEva = evaluationRep.findLatest(rule0.guid, userId, period, st, et)
        //根据总分周期获取相同周期内的子评分
        val latestSubEva = evaluationMapper.selectByExample(Example(Evaluation::class.java).apply {
            createCriteria().andEqualTo("iguid", userId)
                    .andEqualTo("ertype", AssessmentRuleType.Total.value.toByte())
                    .andEqualTo("scensename", period)
        }).takeIf { it.isNotEmpty() }?.get(0)?.let {
            rule0?.apply {
                val pointLevel = mutableListOf<Pair<Int, Int>>()
                val evaluateLevel = mutableListOf<String>()
                val creditTexts = mutableListOf<String>()
                val levelColors = mutableListOf<String>()
                extension1?.split("#")?.forEach {
                    val pStr = it.split(",")
                    pointLevel.add(Pair(pStr[0].toInt(), pStr[1].toInt()))
                }
                extension2?.split("#")?.forEach {
                    evaluateLevel.add(it)
                }
                extension3?.split("#")?.forEach {
                    creditTexts.add(it)
                }
                remark?.split(";")?.forEach {
                    levelColors.add(it)
                }
                .andEqualTo("scensename", latestEva?.scensename)
                .andNotEqualTo("ertype", AssessmentRuleType.Total.value.toByte())
        })
        latestEva?.let {
            latestSubEva.add(it)
        }
        latestSubEva.forEach { e ->
            val rule = evaluationruleMapper.selectByPrimaryKey(e.stguid)
            //总分规则，生成总体评价
            if (rule.ruletype == AssessmentRuleType.Total.value.toString()) {
                rule?.apply {
                    val pointLevel = mutableListOf<Pair<Int, Int>>()
                    val evaluateLevel = mutableListOf<String>()
                    val creditTexts = mutableListOf<String>()
                    val levelColors = mutableListOf<String>()
                    extension1?.split("#")?.forEach {
                        val pStr = it.split(",")
                        pointLevel.add(Pair(pStr[0].toInt(), pStr[1].toInt()))
                    }
                    extension2?.split("#")?.forEach {
                        evaluateLevel.add(it)
                    }
                    extension3?.split("#")?.forEach {
                        creditTexts.add(it)
                    }
                    remark?.split(";")?.forEach {
                        levelColors.add(it)
                    }

                val l = getEvaluationLevel(it.resultscorebef?.toInt()
                    val l = getEvaluationLevel(e.resultscorebef?.toInt()
                        ?: 0, pointLevel, evaluateLevel, creditTexts, levelColors)
                result.apply {
                    creditText = l["creditText"]

                    score = it.resultscorebef?.toInt() ?: 0
                    rank = it.promissednum
                    level = l["evaluateLevel"]
                    this.period = it.scensename
                    time = it.createdate
                    result.apply {
                        creditText = l["creditText"]
                        score = e.resultscorebef?.toInt() ?: 0
                        rank = e.promissednum
                        level = l["evaluateLevel"]
                        this.period = latestEva?.scensename
                        time = e.createdate
//                    color = l["color"]
                    }
                }
            }
        }

        //分类别的得分(每个评分表的评分大项的得分)和失分条目
        val ruleMap = result.loseScore
        rule1List.forEach {
            val evaluation = evaluationMapper.selectByExample(Example(Evaluation::class.java).apply {
                createCriteria().andEqualTo("iguid", userId)
                        .andEqualTo("ertype", it.ruletype)
                        .andEqualTo("scensename", period)
            }).takeIf { it.isNotEmpty() }?.get(0)?.let {e ->
            //具体评估表
            else {
                val subRules = evaluationsubruleMapper.selectByExample(Example(Evaluationsubrule::class.java).apply {
                    createCriteria().andEqualTo("erguid", it.guid)
                    createCriteria().andEqualTo("erguid", rule.guid)
                })
                val itemEvaluations = itemevaluationService.getItemEvaluationList(e.guid!!)

                itemEvaluations.sortedBy { it.ertype }.forEach {item ->
                val ruleMap = result.loseScore
                val ruleMap2 = result.scoring
                //分类别的得分(每个评分表的评分大项的得分)和失分条目
                itemEvaluations.sortedBy { it.ertype }.forEach { item ->
                    val value = item.value?.toInt() ?: 0
                    when (item.ertype) {
                        //分类别的得分
                        2 -> {
                            ruleMap[item.name] = mutableMapOf()
                            ruleMap2[item.name] = mutableMapOf()
                            for (s in subRules) {
                                if (s.guid == item.esrguid) {
                                    val score = if ((item.value?.toInt() ?: 0) <= 0) {
                                        s.maxscore?.plus(item.value?.toInt() ?: 0)
                                    val score = if (value <= 0) {
                                        s.maxscore?.plus(value)
                                    } else {
                                        item.value?.toInt() ?: 0
                                        value
                                    }
                                    result.classScore.add(Triple(item.name ?: "", s.maxscore?.toString()?:"0", score.toString()))
                                    result.classScore.add(Triple(item.name ?: "",
                                        s.maxscore?.toString() ?: "0",
                                        score.toString()))
                                    break
                                }
                            }
                        }
                        3 -> {
                            if ((item.value?.toInt() ?: 0) != 0 && item.extension1 == "true") {
                            if (value != 0 && item.extension1 == "true") {
                                val map = if (value > 0) ruleMap2 else ruleMap
                                for (s in subRules) {
                                    if (s.guid == item.esrguid) {
                                        if (!ruleMap.containsKey(s.fathername)) {
                                            ruleMap[s.fathername] = mutableMapOf()
                                        if (!map.containsKey(s.fathername)) {
                                            map[s.fathername] = mutableMapOf()
                                        }
                                        ruleMap[s.fathername]?.put(item.name, mutableListOf())
                                        map[s.fathername]?.put(item.name, mutableListOf())
                                        break
                                    }
                                }
                            }
                        }
                        //失分条目
                        //失分或得分条目
                        4 -> {
                            if ((item.value?.toInt() ?: 0) != 0 && item.extension1 == "true") {
                            if (value != 0 && item.extension1 == "true") {
                                val map = if (value > 0) ruleMap2 else ruleMap
                                for (s in subRules) {
                                    if (s.guid == item.esrguid) {
                                        val d =
                                            Triple(
                                                item.name ?: "",
                                                if ((item.value?.toInt() ?: 0) < 0) {
                                                    item . value ?: "0"
                                                } else {
                                                    (item.value?.toInt() ?: 0).minus(s.maxscore ?: 0).toString()
                                                },
//                                                if ((item.value?.toInt() ?: 0) < 0) {
//                                                    item.value ?: "0"
//                                                } else {
//                                                    (item.value?.toInt() ?: 0).minus(s.maxscore ?: 0).toString()
//                                                },
                                                item.value ?: "0",
                                                s.remark ?: ""
                                            )
                                        val rule3Name = s.fathername
                                        for (s1 in subRules) {
                                            if (s1.itemname == rule3Name) {
                                                val rule2Name = s1.fathername
                                                ruleMap[rule2Name]?.get(rule3Name)?.add(d)
                                                val rule2Name =
                                                    //父id为空，说明此4级评估项直接附属于2级评估项
                                                    if (s1.fathername.isNullOrBlank()) {
                                                        map[rule3Name]?.put(rule3Name, mutableListOf())
                                                        rule3Name
                                                    } else {
                                                        s1.fathername
                                                    }
                                                map[rule2Name]?.get(rule3Name)?.add(d)
                                                break
                                            }
                                        }
@@ -509,13 +619,43 @@
                    }
                }
            }

        }


        return result
    }

    override fun searchGradeList(
        userId: String,
        condition: UserSearchCondition,
        page: Int,
        perPage: Int,
    ): BaseResponse<List<CreditInfoVo>> {
        if (condition.period == null) return BaseResponse(false, "必须选择周期")
        if (condition.sceneTypes.size > 2) return BaseResponse(false, "场景类型只支持一种")

        val config = userConfigRep.getUserConfigBySubType(userId)
        val condition2 = UserSearchCondition.fromUserConfig(config, condition)

//        val period = condition.period!!
//        val sceneType = condition.sceneTypes[0]
//        var district = condition.districtName
//        val sort = condition.sorts
//
//        if (district == null) {
//            val userInfo = userinfoMapper.selectByPrimaryKey(userId)
//            district = userInfo?.extension1
//        }
        val p = PageHelper.startPage<Evaluation>(page, perPage)
        val result = evaluationMapper.searchGradeList(condition2).onEach {
                if (it.score == null) it.score = "/"
            }
        return BaseResponse(true, head = DataHead(p.pageNum, p.pages, p.total), data = result)
    }

    /**
     * 根据上传的子规则扣分情况，生产子项得分记录
     * 根据上传的子规则扣分情况，生成子项得分记录
     * @param rule 总规则
     * @param eGuid 总分记录id
     * @param userId 用户id
@@ -524,13 +664,38 @@
     * @param itemEvaluationList 得分记录表
     * @return 评分项的父id和得分
     */
    private fun calculateScore(rule:Evaluationrule, eGuid: String, userId: String, subRule: Evaluationsubrule, score: String, itemEvaluationList: MutableList<Itemevaluation>): Pair<String?, String?> {
    private fun calculateScore(
        rule: Evaluationrule,
        eGuid: String,
        userId: String,
        subRule: Evaluationsubrule,
        score: String,
        itemEvaluationList: MutableList<Itemevaluation>,
    ): Pair<String?, String?> {
        var result: Pair<String?, String?> = Pair(null, null)
        var exist = false
        for (i in itemEvaluationList) {
            //记录已存在，说明是父项的评分规则下的某个子项的一部分扣分，扣分累加
            //记录已存在，说明是父项的评分规则下的某个子项的一部分扣分，扣分累加,并且不能超过父项的上限
            if (subRule.guid == i.esrguid) {
                i.value = i.value?.toInt()?.plus(score.toInt())?.toString()
                val s = i.value?.toInt()?.plus(score.toInt()) ?: 0
                //加分模式
                if (subRule.extension2 == "add_mode") {
                    if (s > (subRule.maxscore ?: 0)) {
                        i.value = subRule.maxscore?.toString() ?: "0"
                    } else {
                        i.value = s.toString()
                    }
                }
                //默认情况为减分模式
                else {
                    //允许扣除的分数最小值（负数）
                    val min = subRule.minscore?.minus(subRule.maxscore ?: 0) ?: 0
                    if (s < min) {
                        i.value = min.toString()
                    } else {
                        i.value = s.toString()
                    }
                }
                result = Pair(subRule.fatherid, i.value)
                exist = true
                break
@@ -564,11 +729,11 @@
        pointLevel: MutableList<Pair<Int, Int>> = mutableListOf(),
        evaluateLevel: MutableList<String> = mutableListOf(),
        creditTexts: MutableList<String> = mutableListOf(),
        levelColors: MutableList<String> = mutableListOf()
        levelColors: MutableList<String> = mutableListOf(),
    ): Map<String, String> {
        val result = mutableMapOf<String, String>()
        if (pointLevel.isEmpty() || evaluateLevel.isEmpty() || creditTexts.isEmpty() || levelColors.isEmpty()) {
            result["evaluateLevel"] =  when (score) {
            result["evaluateLevel"] = when (score) {
                in 0..40 -> "极差"
                in 41..64 -> "较差"
                in 65..79 -> "一般"
@@ -578,7 +743,9 @@
            }
        } else {
            for (i in pointLevel.indices) {
                if (score in pointLevel[i].first..pointLevel[i].second) {
                if (score in pointLevel[i].first..pointLevel[i].second ||
                    (i == pointLevel.size - 1 && score > pointLevel[i].second)
                ) {
                    result["color"] = levelColors[i % levelColors.size]
                    result["creditText"] = creditTexts[i % creditTexts.size]
                    result["evaluateLevel"] = evaluateLevel[i % evaluateLevel.size]
@@ -593,12 +760,12 @@
        if (evaluation.ertype == AssessmentRuleType.Total.value.toByte()) {
            val eList = evaluationMapper.selectByExample(Example(Evaluation::class.java).apply {
                createCriteria().andEqualTo("scensename", evaluation.scensename)
                        .andIsNotNull("scensename")
                    .andIsNotNull("scensename")
                    .andEqualTo("ertype", AssessmentRuleType.Total.value)
                //根据评估人的类型进行筛选，自评和官方评分封面开排名
                if (evaluation.evaluatorrealname == null || evaluation.evaluatorrealname == "0") {
                    and(createCriteria().orIsNull("evaluatorrealname")
                            .orEqualTo("evaluatorrealname", evaluation.evaluatorrealname))
                        .orEqualTo("evaluatorrealname", evaluation.evaluatorrealname))
                } else {
                    and(createCriteria().andEqualTo("evaluatorrealname", evaluation.evaluatorrealname))
                }
@@ -618,10 +785,9 @@
            }
            val updateList = mutableListOf<Evaluation>()
            for (i in eList.indices) {
                if (eList[i].guid == evaluation.guid){
                if (eList[i].guid == evaluation.guid) {
                    evaluation.promissednum = i + 1
                }
                else if (eList[i].promissednum != i + 1) {
                } else if (eList[i].promissednum != i + 1) {
                    eList[i].promissednum = i + 1
                    updateList.add(eList[i])
                }