1. 巡查汇总报告功能编写基本完成

feiyu02

2022-07-19 b041775dae4438e428d2b70d2b22cfe8c49844fe

 src/main/kotlin/cn/flightfeather/supervision/business/storage/StAutoScore.kt

@@ -2,7 +2,6 @@

import cn.flightfeather.supervision.business.Info
import cn.flightfeather.supervision.business.ScoreItem
import cn.flightfeather.supervision.business.fume.AutoScore3
import cn.flightfeather.supervision.common.utils.Constant
import cn.flightfeather.supervision.common.utils.DateUtil
import cn.flightfeather.supervision.common.utils.ExcelUtil
@@ -30,16 +29,12 @@
 * 工地自动评分
 */
@Component
class StAutoScore(val stScoreItem_1: ScoreItem) {
class StAutoScore(
    stScoreItem_1: ScoreItem,
    var sceneType: Constant.ScenseType = Constant.ScenseType.TYPE1, )
{
    companion object {
        private lateinit var instance: StAutoScore
        private val SCENE_TYPE = Constant.ScenseType.TYPE1
        private const val DISTRICT = "金山区"
    }

    @PostConstruct
    fun init() {
     instance = this
    }

    @Autowired
@@ -72,8 +67,14 @@
    @Autowired
    lateinit var taskMapper: TaskMapper

    @Autowired
    lateinit var inspectionMapper: InspectionMapper

    @Autowired
    lateinit var subtaskMapper: SubtaskMapper

    //决定是否写h3
    private val hasHead3 = false
    private val hasHead3 = true

    private var totalScore = 100//满分

@@ -85,31 +86,279 @@

    private val topItems = mutableListOf<Evaluationsubrule2>()

    // excel文档
    private var workbook = HSSFWorkbook()
    // 文档行数据
    private val rows = mutableListOf<Array<Any>>()

    init {
        itemList.add(stScoreItem_1)
    }

    fun go(_year: Int? = null, _month: Int? = null, _period: Int = 1) {
        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"
    @PostConstruct
    fun init() {
        instance = this
    }



    /**
     * 总任务打分
     * 根据总任务，对下属所有的巡查任务挨个打分
     * @param topTaskId 总任务id
     */
    fun topTaskGrade(topTaskId:String) {
        rows.clear()
        subtaskMapper.selectByTopTask2(topTaskId, sceneType.value.toInt()).forEach {
            sceneGrade(it)
//            sceneGradeToFile(it)
        }
//        toFile()
    }

    /**
     * 单场景打分
     * @param subtask 巡查任务
     */
    fun sceneGrade(subtask: Subtask) {
        // 获取评分规则
        getScoreItem()

        val info = itemGrade(subtask)
        val result = totalGrade(info) ?: return
        toDb(info, result)
//        addToFile(rows, info, result.first)
//        toFile()
    }

    fun sceneGradeToFile(subtask: Subtask) {
        // 获取评分规则
        getScoreItem()

        val info = itemGrade(subtask)
        val result = totalGrade(info) ?: return
        addToFile(rows, info, result.first)

    }

    /**
     * 条目打分
     */
    private fun itemGrade(subtask: Subtask): Info {
        // 规则条目得分初始化
        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", subtask.scenseid)
        })?.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 scene = scenseMapper.selectByPrimaryKey(subtask.scenseid)

        val info =
            Info(userInfo?.guid, tzUserId, subtask.scenseid, subtask.scensename, sceneType, subTask = subtask, sceneIndex = scene.index)

        /** 1. 根据评分规则对应的问题自动判断是否扣分***************************************************************/
        // 获取该次巡查任务下的所有问题
        val pList = problemlistMapper.selectByExample(Example(Problemlist::class.java).apply {
            createCriteria().andEqualTo("stguid", info.subTask?.stguid)
        }).map { it.ptguid }
        // 计算每条评分规则的得分
        rules.forEach { r ->
            // 评分条目
            val rule = r.first
            // 具体评分选项
            val subRule = r.second
            subRule.forEach { sr ->
                sr.problemlist?.split(",")?.forEach { pId ->
                    if (pList.contains(pId)) {
                        sr.extension1 = (0 - (sr.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()
            }
        }
        /** 2.部分有特殊评分逻辑的规则进行计算*************************************************************************/
        itemList.forEach { item -> item.execute2(info, rules) }

        /** 3. 补全各上级评分项的计分*************************************************************************/
        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
                    // 限制最高扣分
                    if (abs(s) > (t.maxscore ?: 0)) {
                        s = 0 - (t.maxscore ?: 0)
                    }
                    t.extension1 = s.toString()
                    break
                }
            }
        }
        return info
    }

    /**
     * 计算总分
     */
    private fun totalGrade(info: Info): Pair<Evaluation, List<Itemevaluation>>? {
        /** 4. 计算总分*************************************************************************/
        val scene = scenseMapper.selectByPrimaryKey(info.subTask?.scenseid) ?: return null
        val inspection = inspectionMapper.selectByExample(Example(Inspection::class.java).apply {
            createCriteria().andEqualTo("stguid", info.subTask?.stguid)
        })?.takeIf { it.isNotEmpty() }?.let { it[0] }
        var total = 0//总扣除的分数
        topItems.forEach top@{ top ->
            total += top.extension1?.toIntOrNull() ?: 0
        }
        val evaluation = Evaluation()
        baseRules.forEach {
            evaluation.apply {
                guid = UUIDGenerator.generate16ShortUUID()
                iguid = inspection?.guid
                stguid = info.subTask?.stguid
                sguid = info.subTask?.scenseid
                scensetypeid = scene.typeid
                scensetype = scene.type
                subscensetypeid = scene.scensesubtypeid
                subscensetype = scene.scensesubtype
                ertype = it.ruletype?.toByte()
                provincecode = scene.provincecode
                provincename = scene.provincename
                citycode = scene.citycode
                cityname = scene.cityname
                districtcode = scene.districtcode
                districtname = scene.districtname
                towncode = scene.towncode
                townname = scene.townname
                scensename = scene.name
                scenseaddress = scene.location
                evaluatetime = Date()
                evaluatorguid = "admin"
                evaluatorusername = "admin"
                evaluatorrealname = "admin"
                resultscorebef = (totalScore - abs(total)).toString()
                createdate = Date()
                updatedate = Date()
            }
        }
        //子项具体得分
        val itemevaluationList = mutableListOf<Itemevaluation>()
        topItems.forEach { subRule ->
            val item = newItemEvaluation(info, subRule, inspection)
            itemevaluationList.add(item)
        }
        rules.forEach { p ->
            if (p.first.ertype != 2) {
                val item = newItemEvaluation(info, p.first, inspection)
                itemevaluationList.add(item)
            }
            p.second.forEach { r ->
                val item1 = newItemEvaluation(info, r, inspection)
                itemevaluationList.add(item1)
            }
        }
        return Pair(evaluation, itemevaluationList)
    }

    /**
     * 将评分记录输出至数据库
     */
    private fun toDb(info: Info, p: Pair<Evaluation, List<Itemevaluation>>) {
        //去除已有记录
        evaluationMapper.deleteByExample(Example(Evaluation::class.java).apply {
            createCriteria().andEqualTo("stguid", info.subTask?.stguid)
        })
        itemevaluationMapper.deleteByExample(Example(Itemevaluation::class.java).apply {
            createCriteria().andEqualTo("stguid", info.subTask?.stguid)
        })

        //写入数据库
        evaluationMapper.insert(p.first)
        p.second.forEach { il -> itemevaluationMapper.insert(il) }
    }

    /**
     * 转换一条评分至excel中的一行
     */
    private fun addToFile(contents: MutableList<Array<Any>>, info: Info, evaluations: Evaluation) {
        val cList = mutableListOf<Any>()
        // FIXME: 2021/4/28 用户名是否添加账号
//        cList.add("${info.userName}\t${info.userId}")
        cList.add(info.sceneIndex ?: -99)
        cList.add("")
        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?.toInt() ?: "")
                        }
                    } else {
                        cList.add(r.first.extension1?.toInt() ?: "")
                    }
                }
            }
        }
        //总分和环信码
        evaluations.let {
            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())
    }

    /**
     * 将评分记录输出为excel
     */
    private fun toFile() {
        val contents = mutableListOf<Array<Any>>()

        val h1 = mutableListOf<ExcelUtil.MyCell>()
        h1.add(ExcelUtil.MyCell(""))
        h1.add(ExcelUtil.MyCell("表单编号", if (hasHead3) 3 else 2))
        h1.add(ExcelUtil.MyCell("唯一序号", if (hasHead3) 3 else 2))
        h1.add(ExcelUtil.MyCell("场景名称", if (hasHead3) 3 else 2))
        val h2 = mutableListOf<ExcelUtil.MyCell>()
        h2.add(ExcelUtil.MyCell(""))
        h2.add(ExcelUtil.MyCell(""))
        h2.add(ExcelUtil.MyCell(""))
        val h3 = mutableListOf<String>()
        h3.add("")
        h3.add("")
        h3.add("")
        topItems.forEach {
            h1.add(ExcelUtil.MyCell(it.itemname ?: "", 1, 0))
@@ -130,220 +379,32 @@
                }
            }
        }
        // FIXME: 2021/4/25 决定是否写h3
        // 决定是否写h3
        if (hasHead3) {
            h1.add(ExcelUtil.MyCell("总分", 3, 1))
            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))
            h1.add(ExcelUtil.MyCell("防治规范性", 2, 1))
        }

        contents.add(h1.toTypedArray())
        contents.add(h2.toTypedArray())
        // FIXME: 2021/4/25 决定是否写h3
        // 决定是否写h3
        if (hasHead3) {
            contents.add(h3.toTypedArray())
        }

        /** 2. 筛选打分场景*************************************************************************/
        val tasks = taskMapper.selectByExample(Example(Task::class.java).apply {
            createCriteria().andEqualTo("levelnum", 2)
                .andEqualTo("districtname", DISTRICT)
                .andGreaterThanOrEqualTo("starttime", sTime)
                .andLessThanOrEqualTo("endtime", eTime)
        })
        val mList = if (tasks.isNotEmpty()) {
            val taskId = tasks[0].tguid
            monitorobjectversionMapper.selectByExample(Example(Monitorobjectversion::class.java).apply {
                createCriteria().andEqualTo("tid", taskId)
            })
        } else {
            emptyList()
        }
//        val sceneList = scenseMapper.selectByExample(Example(Scense::class.java).apply {
//            createCriteria().andEqualTo("typeid", SCENE_TYPE.value.toByte())
//                .andEqualTo("districtname", DISTRICT)
//                .andNotEqualTo("extension1", '0')
////            createCriteria().andEqualTo("guid", "XcRAQtiD4tTU90sA")
//        })

        /** 3. 循环处理每个场景，给每个场景打分*************************************************************************/
        val sceneList = listOf(
            "q4qOX4kU0aa8J6W2",
            "Syu177gGk1dkiFD1",
            "7GQ53boTPxIPKFv5",
            "zIAoNkridReTEFs9",
            "q4qOX4kU0aa8J6W2",
            "7vz7deflv1bXfVLq",
            "F1f4FXrQ8Knd9UuS",
            "5wufBlqzNPy5z9hs",
            "y0t0XulzkNILtEr3",
            "F7oulQiTCyVZAoJY"
        )
        mList.forEach {
            if (!sceneList.contains(it.sguid)) return@forEach

            //筛选所需要的场景类型
            val scene = scenseMapper.selectByPrimaryKey(it.sguid)
            if (scene.type != SCENE_TYPE.text) return@forEach

            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.sguid)
            })?.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.sguid, it.sensename, SCENE_TYPE, year, sMonth, _period, sTime, eTime)

            /** 1. 根据评分规则对应的问题自动判断是否扣分***************************************************************/
            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()
                        }
                    }
                }
                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()
                }
            }
            /** 2.部分有特殊评分逻辑的规则进行计算*************************************************************************/
            itemList.forEach { item-> item.execute2(info, rules) }

            /** 3. 补全各上级评分项的计分*************************************************************************/
            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
                        // 限制最高扣分
                        if (abs(s) > (t.maxscore ?: 0)) {
                            s = 0 - (t.maxscore ?: 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
//                    }
//                }
//            }
        }
        rows.sortBy { it[0] as Int }
        contents.addAll(rows)

        // 写入文档
        val fileName = "${year}年${if (_period == 1) "${sMonth}月" else "${sMonth}-${eMonth}月"}${SCENE_TYPE.text}自动评分-${DateUtil().DateToString(Date(), "yyyy-MM-ddhhmmss")}.xls"
//        val filePath = "E:\\工作\\开发\\第三方监管app\\自动评分\\工地\\$fileName"
        val filePath = "C:\\work\\工作\\第三方监管\\自动评分\\${SCENE_TYPE.text}\\$fileName"
        val fileName = "${sceneType.text}自动评分-${DateUtil().DateToString(Date(), "yyyy-MM-ddhhmmss")}.xls"
        val filePath = "C:\\work\\工作\\第三方监管\\自动评分\\${sceneType.text}\\$fileName"
        val file = File(filePath)
        if (!file.parentFile.exists()) {
            file.parentFile.mkdirs()
        }
        val out = FileOutputStream(File(filePath))
        ExcelUtil.write(emptyList(), contents, workbook)
        workbook.write(out)
@@ -358,11 +419,12 @@
    private fun getScoreItem() {
        this.rules.clear()
        baseRules.clear()
        topItems.clear()

        val rule = evaluationruleMapper.selectByExample(Example(Evaluationrule::class.java).apply {
            createCriteria()
                .andEqualTo("tasktypeid", 99)
                .andEqualTo("scensetypeid", SCENE_TYPE.value.toByte())
                .andEqualTo("scensetypeid", sceneType.value.toByte())
        })
        if (rule.isNotEmpty()) {
            baseRules.addAll(rule)
@@ -403,14 +465,14 @@
                    this.rules.add(Pair(temp, tempSubRules))
                }
            }
//            this.totalScore = t
            this.totalScore = t
        }
    }

    /**
     * 生成新的一条评分记录
     */
    private fun newItemEvaluation(info: Info, itemRule: Evaluationsubrule2, evaluationId: String?) = cn.flightfeather.supervision.domain.ds1.entity.Itemevaluation()
    private fun newItemEvaluation(info: Info, itemRule: Evaluationsubrule2, inspection: Inspection?) = Itemevaluation()
        .apply {
            var rule: Evaluationrule? = null
            for (r in baseRules) {
@@ -420,8 +482,10 @@
                }
            }
            ieguid = UUIDGenerator.generate16ShortUUID()
            iguid = info.userId
            sguid = evaluationId
            iguid = inspection?.guid
            stguid = info.subTask?.stguid
            sguid = info.subTask?.scenseid
            sensename = info.subTask?.scensename
            erguid = rule?.guid
            rulename = rule?.rulename
            ruletype = rule?.ruletype?.toInt()
@@ -431,41 +495,4 @@
            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 ?: "")
                        }
                    } else {
                        cList.add(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())
    }
}