1. 新增问题更新接口

feiyu02

2024-09-10 6c7f45871b93ef26d353a5a3596701ac2f39ed9c

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

@@ -6,24 +6,28 @@
import cn.flightfeather.supervision.business.report.file.ReportThree
import cn.flightfeather.supervision.business.report.file.ReportTwo
import cn.flightfeather.supervision.business.report.template.*
import cn.flightfeather.supervision.common.exception.BizException
import cn.flightfeather.supervision.common.utils.*
import cn.flightfeather.supervision.domain.ds1.entity.*
import cn.flightfeather.supervision.domain.ds1.mapper.*
import cn.flightfeather.supervision.domain.ds1.repository.EvaluationRep
import cn.flightfeather.supervision.domain.ds1.repository.EvaluationRuleRep
import cn.flightfeather.supervision.domain.ds1.repository.SceneRep
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.service.SearchService
import cn.flightfeather.supervision.lightshare.service.TaskService
import cn.flightfeather.supervision.lightshare.vo.*
import com.github.pagehelper.PageHelper
import org.springframework.beans.BeanUtils
import org.springframework.beans.factory.annotation.Value
import org.springframework.stereotype.Service
import tk.mybatis.mapper.entity.Example
import java.io.File
import java.io.FileInputStream
import java.io.FileOutputStream
import java.io.OutputStream
import java.net.URLEncoder
import java.nio.charset.Charset
import java.nio.charset.StandardCharsets
import java.util.*
import javax.servlet.http.HttpServletResponse
@@ -34,33 +38,37 @@
 */
@Service
class SearchServiceImpl(
        val userinfoMapper: UserinfoMapper,
        val subtaskMapper: SubtaskMapper,
        val scenseMapper: ScenseMapper,
        val sceneConstructionSiteMapper: SceneConstructionSiteMapper,
        val sceneMixingPlantMapper: SceneMixingPlantMapper,
        val sceneStorageYardMapper: SceneStorageYardMapper,
        val sceneWharfMapper: SceneWharfMapper,
        val problemlistMapper: ProblemlistMapper,
        val problemtypeMapper: ProblemtypeMapper,
        val townMapper: TownMapper,
        val mediafileMapper: MediafileMapper,
        val scoreMapper: ScoreMapper,
        val inspectionMapper: InspectionMapper,
        val taskMapper: TaskMapper,
        val monitorobjectversionMapper: MonitorobjectversionMapper,
        val evaluationruleMapper: EvaluationruleMapper,
        val evaluationsubruleMapper: EvaluationsubruleMapper2,
        val evaluationMapper: EvaluationMapper,
        val itemevaluationMapper: ItemevaluationMapper,
        val ledgerSubTypeMapper: LedgerSubTypeMapper,
        val ledgerRecordMapper: LedgerRecordMapper,
        val userMapMapper: UserMapMapper,
    val userinfoMapper: UserinfoMapper,
    val subtaskMapper: SubtaskMapper,
    val scenseMapper: ScenseMapper,
    val sceneConstructionSiteMapper: SceneConstructionSiteMapper,
    val sceneMixingPlantMapper: SceneMixingPlantMapper,
    val sceneStorageYardMapper: SceneStorageYardMapper,
    val sceneWharfMapper: SceneWharfMapper,
    val problemlistMapper: ProblemlistMapper,
    val problemtypeMapper: ProblemtypeMapper,
    val townMapper: TownMapper,
    val mediafileMapper: MediafileMapper,
    val scoreMapper: ScoreMapper,
    val inspectionMapper: InspectionMapper,
    val taskMapper: TaskMapper,
    val monitorobjectversionMapper: MonitorobjectversionMapper,
    val evaluationruleMapper: EvaluationruleMapper,
    val evaluationsubruleMapper: EvaluationsubruleMapper2,
    val evaluationMapper: EvaluationMapper,
    val itemevaluationMapper: ItemevaluationMapper,
    val ledgerSubTypeMapper: LedgerSubTypeMapper,
    val ledgerRecordMapper: LedgerRecordMapper,
    val userMapMapper: UserMapMapper,
    val taskService: TaskService,
    private val evaluationRep: EvaluationRep,
    private val evaluationRuleRep: EvaluationRuleRep,
    private val sceneRep: SceneRep,
    @Value("\${filePath}") var filePath: String,
    @Value("\${imgPath}") var imgPath: String,
) : SearchService {

    private val dateUtil = DateUtil()

    override fun writeToFile(config: ExcelConfigVo, mode:Int) {
    override fun writeToFile(config: ExcelConfigVo, mode: Int) {
        val dbMapper = DbMapper(
            scenseMapper,
            problemlistMapper,
@@ -73,29 +81,10 @@
            sceneWharfMapper,
            taskMapper,
            evaluationruleMapper, evaluationsubruleMapper, evaluationMapper, itemevaluationMapper,
                ledgerSubTypeMapper, ledgerRecordMapper, userinfoMapper, userMapMapper, townMapper
            ledgerSubTypeMapper, ledgerRecordMapper, userinfoMapper, userMapMapper, townMapper
        )
        val dataSource = DataSource(config, dbMapper)
        val t = when (mode) {
//            //问题与整改跟踪汇总表
//            0 -> ProDetailSummary(dataSource)
//            //分街镇问题整改分析汇总表
//            1 -> ProAnalysisSummary(dataSource)
//
//            //规范性评估详情表
//            2 -> ScoreDetailSummary(dataSource)
//            //分街镇规范性分析表
//            3 -> ScoreAnalysisSummary(dataSource)
//
//            //问题与整改分类统计表
//            4 -> ProTypeDetailSummary(dataSource)
//            //问题与整改分类排名
//            5 -> ProTypeRankSummary(dataSource)
//            //月度主要或典型问题分析表
//            6 -> ProTypeRankMainSummary(dataSource)
//            //工地施工阶段问题分类分析表
//            7 -> ProTypeStatusSummary(dataSource)

            8 -> ReportOne(dataSource)
            9 -> ReportTwo(dataSource)
            10 -> ReportThree(dataSource)
@@ -141,7 +130,7 @@
            setDateHeader("Expires", 0)
        }

        val p = Constant.DEFAULT_FILE_PATH + "/files/autoscore/"
        val p = "$filePath/autoscore/"
        val file = File(p + fileName)
        if (config.forceUpdate || !file.exists()) {
            t.toFile(p)
@@ -152,10 +141,38 @@
    }

    override fun getSubTaskDetail(config: ExcelConfigVo): SubTaskTableVo {
        val titles = getTableTitles(config.sceneType, config.districtCode)
        val content = getTableContents(config, titles.size)
        val dbMapper = DbMapper(
            scenseMapper,
            problemlistMapper,
            problemtypeMapper,
            subtaskMapper,
            monitorobjectversionMapper,
            sceneConstructionSiteMapper,
            sceneMixingPlantMapper,
            sceneStorageYardMapper,
            sceneWharfMapper,
            taskMapper,
            evaluationruleMapper, evaluationsubruleMapper, evaluationMapper, itemevaluationMapper,
            ledgerSubTypeMapper, ledgerRecordMapper, userinfoMapper, userMapMapper, townMapper
        )
//        val dataSource = DataSource(config, dbMapper)
//        val t = when (config.mode) {
////            1 -> ReportOne(dataSource)
////            2 -> ReportTwo(dataSource)
////            3 -> ReportThree(dataSource)
//            4->DailyReportSummary()
//            else -> ReportOne(dataSource)
//        }
//        val fileName = t.getReportName()
//        val fName = URLEncoder.encode(fileName, "UTF-8")
//
//        val p = Constant.DEFAULT_FILE_PATH + "/files/autoscore/"
//        val file = File(p + fileName)
//        if (config.forceUpdate || !file.exists()) {
//            t.toFile(p)
//        }

        return SubTaskTableVo(titles, content)
        return SubTaskTableVo(emptyList(), emptyList())
    }

    override fun downloadPic(config: ExcelConfigVo, response: HttpServletResponse): HttpServletResponse {
@@ -204,7 +221,7 @@

            //根据场景条件筛选
            val need = if (config.sceneType != null) {
                scene.typeid == config.sceneType.toByte()
                scene.typeid == config.sceneType?.toByte()
            } else {
                true
            }
@@ -239,8 +256,9 @@
        }

        //建立第一层目录，包含所有的任务
        val time = dateUtil.DateToString(Date(), "yyyy-MM-dd_HH-mm-ss")
        var basePath = Constant.DEFAULT_FILE_PATH + File.separator + "images" + File.separator + "temp" + File.separator + time
        val time = DateUtil.DateToString(Date(), "yyyy-MM-dd_HH-mm-ss")
        var basePath =
            imgPath + File.separator + "temp" + File.separator + time
        var file = File(basePath)
        var i = 1
        while (file.exists() && i <= 100) {
@@ -291,7 +309,8 @@
                mediafileMapper.selectByExample(Example(Mediafile::class.java).apply {
                    createCriteria().andEqualTo("businessguid", p.guid)
                }).forEach { m ->
                    val picPath = Constant.DEFAULT_FILE_PATH + File.separator + "images" + File.separator + m.extension1 + m.guid + ".jpg"
                    val picPath =
                        imgPath + File.separator + m.extension1 + m.guid + ".jpg"
                    val fromFile = File(picPath)
                    val picName = p.problemname + "_" + p.location + "($y).jpg"
                    val toFile = File(pPath + File.separator + picName)
@@ -330,8 +349,9 @@
    override fun downloadPic2(sceneType: Int, topTaskId: String, response: HttpServletResponse): HttpServletResponse {
        //建立第一层目录，包含所有的任务
        val topTask = taskMapper.selectByPrimaryKey(topTaskId)
        val time = dateUtil.DateToString(Date(), "yyyy-MM-dd_HH-mm-ss")
        val basePath = Constant.DEFAULT_FILE_PATH + File.separator + "images" + File.separator + "temp" + File.separator + topTask.name
        val time = DateUtil.DateToString(Date(), "yyyy-MM-dd_HH-mm-ss")
        val basePath =
            imgPath + File.separator + "temp" + File.separator + topTask.name
        val file = File(basePath)
        if (!file.exists()) {
            file.mkdirs()
@@ -350,7 +370,7 @@

                //建立一个子任务文件夹
                var subTaskFilePath = "${basePath}${File.separator}(${
                    dateUtil.DateToString(
                    DateUtil.DateToString(
                        it.planstarttime,
                        DateUtil.DateStyle.YYYY_MM_DD_CN
                    )
@@ -400,7 +420,7 @@

                        u.forEach { f ->
                            val picPath =
                                Constant.DEFAULT_FILE_PATH + File.separator + "images" + File.separator + f.extension1 + f.guid + ".jpg"
                                imgPath + File.separator + f.extension1 + f.guid + ".jpg"
                            val fromFile = File(picPath)
                            val picName = f.description
                            val toFile = File(pPath + File.separator + picName)
@@ -440,7 +460,13 @@
        return response
    }

    override fun searchScore4JingAn(token: String, year: Int, month: Int, page: Int?, perPage: Int?): BaseResponse<List<ScoreVo>> {
    override fun searchScore4JingAn(
        token: String,
        year: Int,
        month: Int,
        page: Int?,
        perPage: Int?,
    ): BaseResponse<List<ScoreVo>> {
        if (token != "jingan") {
            return BaseResponse(false)
        }
@@ -463,7 +489,12 @@
        return BaseResponse(true, head = DataHead(p.pageNum, p.pages), data = result)
    }

    override fun searchSubTaskByKeyword(userId: String, keyword: String, page: Int, perPage: Int): BaseResponse<List<SubtaskVo>> {
    override fun searchSubTaskByKeyword(
        userId: String,
        keyword: String,
        page: Int,
        perPage: Int,
    ): BaseResponse<List<SubtaskVo>> {
        val userInfo = userinfoMapper.selectByPrimaryKey(userId)
        if (userInfo.usertypeid?.toInt() == 3) return BaseResponse(false, "企业用户无查询权限")//企业用户无法查询
        val result = mutableListOf<SubtaskVo>()
@@ -488,501 +519,69 @@
        return BaseResponse(true, head = DataHead(pageInfo.pageNum, pageInfo.pages), data = result)
    }

    override fun getDailyReport(config: ExcelConfigVo): BaseTableVo {
        if (config.districtCode == null || config.startTime == null) return BaseTableVo(emptyList(), emptyList())

    private fun getTable(mode: Int, config: ExcelConfigVo): Pair<MutableList<Array<Any>>, MutableList<Array<Any>>> {
        //数据源
        val dataList = getTableDataSource(config)
        //生成表格
        val head = mutableListOf<MutableList<Any>>()
        val contents = mutableListOf<MutableList<Any>>()
        val dbMapper = DbMapper(
            scenseMapper,
            problemlistMapper,
            problemtypeMapper,
            subtaskMapper,
            monitorobjectversionMapper,
            sceneConstructionSiteMapper,
            sceneMixingPlantMapper,
            sceneStorageYardMapper,
            sceneWharfMapper,
            taskMapper,
            evaluationruleMapper, evaluationsubruleMapper, evaluationMapper, itemevaluationMapper,
            ledgerSubTypeMapper, ledgerRecordMapper, userinfoMapper, userMapMapper, townMapper
        )
        val task =
            taskService.getByDistrictCode(config.districtCode, config.startTime)?.takeIf { it.isNotEmpty() }?.get(0)
        config.topTaskGuid = task?.tguid ?: ""
        val dataSource = mutableListOf<DataSource>()
        config.sceneType = Constant.SceneType.TYPE1.value.toInt()
        dataSource.add(DataSource(config, dbMapper))

        getSceneName(head, contents, dataList)
//        val config2 = config.copy(sceneType = Constant.ScenseType.TYPE2.value.toInt())
//        dataSource.add(DataSource(config2, dbMapper))
//
//        val config3 = config.copy(sceneType = Constant.ScenseType.TYPE3.value.toInt())
//        dataSource.add(DataSource(config3, dbMapper))
//
//        val config4 = config.copy(sceneType = Constant.ScenseType.TYPE14.value.toInt())
//        dataSource.add(DataSource(config4, dbMapper))

        when (mode) {
            // 问题分布
            1 -> {
                getProblemDistribution(head, contents, dataList, config)
            }
            2 -> {
                getInspectionInfo(head, contents, dataList, config)
            }
            3 -> {
        val t = DailyReportSummary(dataSource)
        t.execute()
        val result = t.toTableRows()

            }
        }
        val h = mutableListOf<Array<Any>>()
        val c = mutableListOf<Array<Any>>()
        head.forEach { h.add(it.toTypedArray()) }
        contents.forEach { c.add(it.toTypedArray()) }
        c.sortBy {
            it[0] as Int
        }

        return Pair(h, c)
        return BaseTableVo(result.first, result.second)
    }

    // 表头：场景名
    private fun getSceneName(head: MutableList<MutableList<Any>>, contents: MutableList<MutableList<Any>>, dataList: List<Subtask>) {
        head.add(mutableListOf(ExcelUtil.MyCell("表单编号"), ExcelUtil.MyCell("唯一序号"), ExcelUtil.MyCell("场景名称")))
        dataList.forEach {subtask ->
            val row = mutableListOf<Any>()
            //查询该任务对应的场景
            val scene = scenseMapper.selectByPrimaryKey(subtask.scenseid)
            row.apply {
                add(scene.index ?: -99)
                add(scene.extension2 ?: "")
                add(scene.name ?: "")
            }
            contents.add(row)
    override fun getScoreDetail(subTaskId: String): ScoreDetail {
        //场景信息
        val scene = sceneRep.findBySubTask(subTaskId)
        //总分
        val evaluation = evaluationRep.findBySubtask(subTaskId)
        //子规则逐条得分
        val subRuleScores = evaluationRep.findItemEvaluation(subTaskId)
        if (subRuleScores.isEmpty()) throw BizException("无评估记录")
        //评分总规则
        val rule = evaluationRuleRep.findAutoEvaluationRule(subTaskId) ?: throw BizException("未找到相关自动评估规则")
        //总规则对应的评分子规则
        val subRules = evaluationRuleRep.findSubRule(rule.guid)
        //查询结果
        val result = ScoreDetail()
        result.status = if (scene?.extension1.equals("1")) "在建" else "完工"

        result.updateTime = evaluation?.updatedate
        subRules.forEach {
            it.ertype ?: return@forEach
            result.addDetail(result.details, it, it.ertype!! - 1, subRuleScores, true)
        }
    }

    // 表头：具体问题分布
    private fun getProblemDistribution(head: MutableList<MutableList<Any>>, contents: MutableList<MutableList<Any>>,
                                       dataList: List<Subtask>, config: ExcelConfigVo) {
        val h1 = mutableListOf<ExcelUtil.MyCell>()
        val h2 = mutableListOf<Any>()
        currentProblemType.clear()
        currentProblemHead.clear()

        // 问题分为两层，新增一行表头
        problemtypeMapper.selectByExample(Example(Problemtype::class.java).apply {
            createCriteria().andEqualTo("scensetypeid", config.sceneType)
                .andEqualTo("districtcode", config.districtCode)
            orderBy("extension1")
        }).forEach {
            if (!currentProblemHead.contains(it.typename)) {
                currentProblemHead.add(it.typename ?: "")
                h1.add(ExcelUtil.MyCell(it.typename ?: "", colSpan = 0))
            }
            currentProblemType[it.guid ?: ""] = it.description ?: ""
            if (currentProblemHead.contains(it.typename)) {
                h2.add(it.description ?: "")
                h1.last().colSpan++

                h2.add("是否整改")
                h1.last().colSpan++
            }
        }

        //问题分布
        for (i in dataList.indices) {
            val subtask = dataList[i]

            val pDis = mutableListOf<Any>()//具体问题分布及整改情况
            repeat(h2.size) { pDis.add("")}
            if (subtask.stguid != null) {
                problemlistMapper.selectByExample(Example(Problemlist::class.java).apply {
                    createCriteria().andEqualTo("stguid", subtask.stguid)
                }).forEach problemType@{ p ->
                    val des = currentProblemType[p.ptguid]

                    //具体问题分布
                    for (t in h2.indices) {
                        if (des == h2[t]) {
                            //具体问题这一列添加文本，表示问题存在
                            pDis[t] = 1
                            //问题列的下一列是该问题的整改情况
                            pDis[t + 1] = if (p.ischanged == true) 1 else 0
                            break
                        }
                    }
                }
            }

            contents[i].addAll(pDis)
        }

        //原有的第一行表头增加1行行跨度,同时新的第二行表头添加空位
        head[0].forEach {
            (it as ExcelUtil.MyCell).rowSpan++
//            h2.add(0, "")
        }
        //合并表头
        head[0].addAll(h1)
        head.add(h2)
    }

    // 表头：巡查情况及问题、整改统计
    private fun getInspectionInfo(head: MutableList<MutableList<Any>>, contents: MutableList<MutableList<Any>>, dataList: List<Subtask>, config: ExcelConfigVo) {
        val h1 = listOf("监管时间", "问题类型", "问题描述", "问题位置", "问题数", "整改情况", "整改问题", "整改数", "未整改问题", "未整改数", "审核情况")

        for (i in dataList.indices) {
            val subtask = dataList[i]

            val row = mutableListOf<Any>()
            if (subtask.stguid == null) {
                repeat(h1.size) { row.add("")}
            } else {
                row.apply {
                    // 表头：巡查情况及问题、整改统计
                    add(dateUtil.DateToString(subtask.planstarttime, DateUtil.DateStyle.MM_DD) ?: "")//监管时间
                    //查询子任务对应的问题，并且根据条件进行筛选
                    var y = 1
                    var pType = ""//问题类型
                    var pDes = ""//问题描述
                    var pLoc = ""//问题位置
                    var pNum = 0//问题数
                    var pChanged = ""//整改情况
                    var changedProblem = ""//整改问题
                    var cNum = 0//整改数
                    var unChangedProblem = ""//未整改问题
                    var unChangeNum = 0//未整改数
                    var checkStatus = ""//审核情况
                    problemlistMapper.selectByExample(Example(Problemlist::class.java).apply {
                        createCriteria().andEqualTo("stguid", subtask.stguid)
                    }).forEach problemType@{ p ->
                        val problemType = problemtypeMapper.selectByPrimaryKey(p.ptguid)
                        val typeName = if (problemType == null) {
                            val a = ""
                            a
                        } else {
                            problemType.typename
                        }
                        val lr = if (y > 1) "\n" else ""
                        //巡查情况及问题、整改统计
                        pType += "${lr}$y、${typeName}"
                        pDes += "${lr}$y、${p.problemname}"
                        pLoc += "${lr}$y、${p.location}"
                        pNum++
                        pChanged += "${lr}$y、${if (p.ischanged == true) "✓" else "×"}"
                        if (p.ischanged == true) {
                            if (changedProblem.isNotBlank()) {
                                changedProblem += "\n"
                            }
                            changedProblem += "$y、${p.problemname}"
                            cNum++
                        } else {
                            if (unChangedProblem.isNotBlank()) {
                                unChangedProblem += "\n"
                            }
                            unChangedProblem += "$y、${p.problemname}"
                            unChangeNum++
                        }
                        val status = when (p.extension3) {
                            Constant.PROBLEM_CHECK_PASS -> "问题审核通过"//
                            Constant.PROBLEM_CHECK_FAIL -> "问题审核未通过"//
                            Constant.PROBLEM_UNCHECKED -> "问题未审核"//
                            Constant.CHANGE_UNCHECKED -> "整改未审核"//
                            Constant.CHANGE_CHECK_PASS -> "整改审核通过"//
                            Constant.CHANGE_CHECK_FAIL -> "整改审核未通过"//
                            else -> "问题未审核"
                        }
                        checkStatus += "${lr}$y、${status}"
                        y++
                    }
                    addAll(listOf(pType, pDes, pLoc, pNum, pChanged, changedProblem, cNum, unChangedProblem, unChangeNum, checkStatus))
                }
            }

            contents[i].addAll(row)
        }

        head[0].addAll(h1)
    }



    private fun getTableTitles(sceneType: Int?, districtCode: String?): List<String> {
        if (sceneType == null || districtCode == null) return emptyList()
        val heads = mutableListOf<String>()
        heads.run {
            addAll(getSceneName())
            addAll(getLocation())
            addAll(getBaseInfo(sceneType))
            addAll(getContactInfo(sceneType))
            addAll(getRealTimeStatus(sceneType))
            addAll(getInspectionInfo(sceneType))
            addAll(getProblemDistribution(sceneType, districtCode))
        }

        return heads
    }

    // 表头：场景名
    private fun getSceneName() = listOf("表单编号", "唯一序号", "场景名称")

    // 表头：场景地理位置
    private fun getLocation(): List<String> = listOf(
        "街镇", "地址"
    )

    // 表头：场景专属基础信息
    private fun getBaseInfo(sceneType: Int): List<String> = when (sceneType.toString()) {
        Constant.ScenseType.TYPE1.value -> listOf("业主单位", "施工单位", "建筑面积(m²)", "施工起始时间", "施工结束时间", "施工阶段", "工程类型")
        Constant.ScenseType.TYPE2.value -> listOf("业主单位", "租赁单位", "占地面积(m²)", "营运状态", "类型")
        Constant.ScenseType.TYPE3.value -> listOf("业主单位", "文明场站", "绿色环保站厂", "占地面积(m²)", "营运状态")
        Constant.ScenseType.TYPE14.value -> listOf("业主单位", "租赁单位", "占地面积(m²)", "营运状态", "类型")
        else -> listOf()
    }

    // 表头：场景联系方式
    private fun getContactInfo(sceneType: Int): List<String> = when (sceneType) {
        else -> listOf("联系人", "联系方式")
    }

    // 表头：场景现场情况
    private fun getRealTimeStatus(sceneType: Int): List<String> = when (sceneType) {
        else -> listOf()
    }

    // 表头：巡查情况及问题、整改统计
    private fun getInspectionInfo(sceneType: Int): List<String> = when (sceneType) {
        else -> listOf("监管时间", "防治考核评分", "防治规范性", "扣分项","问题类型", "问题描述", "问题位置", "问题数", "整改情况", "整改数", "审核情况")
    }

    // 表头：具体问题分布
    private val currentProblemType = mutableMapOf<String, String>()
    private val currentProblemHead = mutableListOf<String>()
    private fun getProblemDistribution(sceneType: Int, districtCode: String): List<String> {
        val heads = mutableListOf<String>()
        currentProblemType.clear()
        currentProblemHead.clear()

        problemtypeMapper.selectByExample(Example(Problemtype::class.java).apply {
            createCriteria().andEqualTo("scensetypeid", sceneType)
                .andEqualTo("districtcode", districtCode)
            orderBy("typeid")
        }).forEach {
            if (!heads.contains(it.typename)) {
                heads.add(it.typename ?: "")
            }
            currentProblemType[it.guid ?: ""] = it.typename ?: ""
        }
        currentProblemHead.addAll(heads)
        return heads
    }


    /**
     * 获取表格数据源
     */
    private fun getTableDataSource(config: ExcelConfigVo): List<Subtask> {
        if (config.sceneType == null) return emptyList()

        val result = mutableListOf<Subtask>()

        //1. 查找特定的巡查任务或者所有的计划巡查任务
        var taskSceneIdList = listOf<String>()
        val subTaskList = if (config.subTaskIdList?.isNotEmpty() == true ||
            (config.startTime != null || config.endTime != null)
        ) {
            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) }
                }
            })
        } else {
            taskSceneIdList = monitorobjectversionMapper.getSceneByType(config.topTaskGuid, config.sceneType)
            subtaskMapper.selectByExample(Example(Subtask::class.java).apply {
                createCriteria().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
                        break
                    }
                }
                if (subtask == null) subtask = Subtask().apply { scenseid = it }
                result.add(subtask)
            }
        } else {
            result.addAll(subTaskList)
        }
        result.calScore()

        return result
    }

    private fun getTableContents(config: ExcelConfigVo, colCounts: Int = 0): List<Array<Any>> {
        if (config.sceneType == null) return emptyList()

        //1. 查找特定的巡查任务或者所有的计划巡查任务
        var taskSceneIdList = listOf<String>()
        val subTaskList = if (config.subTaskIdList?.isNotEmpty() == true ||
            (config.startTime != null || config.endTime != null)
        ) {
            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) }
                }
            })
        } else {
            taskSceneIdList = monitorobjectversionMapper.getSceneByType(config.topTaskGuid, config.sceneType)
            subtaskMapper.selectByExample(Example(Subtask::class.java).apply {
                createCriteria().andIn("scenseid", taskSceneIdList)
                    .andEqualTo("tguid", config.topTaskGuid)
            })
        }

        val contents = mutableListOf<Array<Any>>()
        val subTasks = mutableListOf<Subtask>()

        if (taskSceneIdList.isNotEmpty()) {
            taskSceneIdList.forEach {
                val rowContent = mutableListOf<Any>()

                var subtask: Subtask? = null
                for (s in subTaskList) {
                    if (s.scenseid == it) {
                        subtask = s
                        break
                    }
                }
                //该场景未巡查
                if (subtask == null) {
                    val scene = scenseMapper.selectByPrimaryKey(it)
                    rowContent.apply {
                        add(scene.index?.toString() ?: "")
                        add(scene.extension2 ?: "")
                        add(scene.name ?: "")
                    }
                    val left = colCounts - getSceneName().size
                    repeat(left) {
                        rowContent.add("")
                    }
                } else {
                    rowContent.addAll(tableContent(subtask))
                }

                contents.add(rowContent.toTypedArray())
            }
        } else {
            subTaskList.forEach {
                val c = tableContent(it)
                contents.add(c)
            }
        }

        return contents
    }

    private fun tableContent(subtask: Subtask): Array<Any> {

        val row = mutableListOf<Any>()
        //查询该任务对应的场景
        val scene = scenseMapper.selectByPrimaryKey(subtask.scenseid)

        row.apply {
            // 表头：场景名
            add(scene.index?.toString() ?: "")
            add(scene.extension2 ?: "")
            add(scene.name ?: "")
            // 表头：场景地理位置
            add(scene.townname ?: "")
            add(scene.location ?: "")
            // 表头：场景专属基础信息
            addAll(when (scene.typeid.toString()) {
                Constant.ScenseType.TYPE1.value -> {
//                    listOf("业主单位", "施工单位", "建筑面积(m²)", "施工起始时间", "施工结束时间", "施工阶段", "工程类型")
                    var r = listOf("-", "-", "-", "-", "-", "-", "-")
                    sceneConstructionSiteMapper.selectByPrimaryKey(scene.guid)?.let {
                        r = listOf(it.csEmployerUnit?:"", it.csConstructionUnit?:"", it.csFloorSpace?:"",
                            it.csStartTime?:"", it.csEndTime?:"", it.csStatus?:"", it.csProjectType?:"")
                    }
                    r
                }
                Constant.ScenseType.TYPE2.value -> {
//                    listOf("业主单位", "租赁单位", "占地面积(m²)", "营运状态", "类型")
                    var r = listOf("-", "-", "-", "-", "-")
                    sceneWharfMapper.selectByPrimaryKey(scene.guid)?.let {
                        r = listOf(it.getwEmployerUnit()?:"", it.getwRentUnit()?:"", it.getwFloorSpace()?:"", it.getwStatus()?:"",
                            it.getwProjectType()?:"")
                    }
                    r
                }
                Constant.ScenseType.TYPE3.value -> {
//                    listOf("业主单位", "文明场站", "绿色环保站厂", "占地面积(m²)", "营运状态")
                    var r = listOf("-", "-", "-", "-", "-")
                    sceneMixingPlantMapper.selectByPrimaryKey(scene.guid)?.let {
                        r = listOf(
                            it.mpEmployerUnit?:"", if (it.mpCivillyPlant == true) "是" else "否", if (it.mpGreenPlant == true) "是" else "否",
                            it.mpFloorSpace?:"", it.mpStatus?:""
                        )
                    }
                    r
                }
                Constant.ScenseType.TYPE14.value -> {
//                    listOf("业主单位", "租赁单位", "占地面积(m²)", "营运状态", "类型")
                    var r = listOf("-", "-", "-", "-", "-")
                    sceneStorageYardMapper.selectByPrimaryKey(scene.guid)?.let {
                        r = listOf(it.syEmployerUnit?:"", it.syRentUnit?:"", it.syFloorSpace?:"", it.syStatus?:"", it.syProjectType?:"")
                    }
                    r
                }
                else -> listOf()
            })
            // 表头：场景联系方式
            add(scene.contacts ?: "")
            add(scene.contactst ?: "")
            // 表头：场景现场情况
            // TODO: 2022/7/10 暂无
            // 表头：巡查情况及问题、整改统计 和 表头：具体问题分布
            listOf("监管时间", "防治考核评分", "防治规范性", "扣分项","问题类型", "问题描述", "问题位置", "问题数", "整改情况", "整改数", "审核情况")
            add(dateUtil.DateToString(subtask.planstarttime, DateUtil.DateStyle.MM_DD) ?: "")
            add("")
            add("")
            add("")
            //查询子任务对应的问题，并且根据条件进行筛选
            var y = 1
            var pType = ""//问题类型
            var pDes = ""//问题描述
            var pLoc = ""//问题位置
            var pNum = 0//问题数
            var pChanged = ""//整改情况
            var cNum = 0//整改数
            var checkStatus = ""//审核情况
            var pDis = mutableListOf<String>()//具体问题分布
            repeat(currentProblemHead.size) { pDis.add("")}
            problemlistMapper.selectByExample(Example(Problemlist::class.java).apply {
                createCriteria().andEqualTo("stguid", subtask.stguid)
            }).forEach problemType@{ p ->
                val typeName = currentProblemType[p.ptguid]
                val lr = if (y > 1) "\n" else ""
                //巡查情况及问题、整改统计
                pType += "${lr}$y、${typeName}"
                pDes += "${lr}$y、${p.problemname}"
                pLoc += "${lr}$y、${p.location}"
                pNum++
                pChanged += "${lr}$y、${if (p.ischanged == true) "✓" else "×"}"
                if (p.ischanged == true) cNum++
                val status = when (p.extension3) {
                    Constant.PROBLEM_CHECK_PASS -> "问题审核通过"//
                    Constant.PROBLEM_CHECK_FAIL -> "问题审核未通过"//
                    Constant.PROBLEM_UNCHECKED -> "问题未审核"//
                    Constant.CHANGE_UNCHECKED -> "整改未审核"//
                    Constant.CHANGE_CHECK_PASS -> "整改审核通过"//
                    Constant.CHANGE_CHECK_FAIL -> "整改审核未通过"//
                    else -> "问题未审核"
                }
                checkStatus += "${lr}$y、${status}"
                y++

                //具体问题分布
                for (t in currentProblemHead.indices) {
                    if (typeName == currentProblemHead[t]) {
                        pDis[t] = if (p.ischanged == true) "1" else "0"
                        break
                    }
                }
            }
            addAll(listOf(pType, pDes, pLoc, pNum, pChanged, cNum, checkStatus))
            addAll(pDis)
        }

        return row.toTypedArray()
    }
}