1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
package cn.flightfeather.thirdappmodule.databinding
 
import android.arch.lifecycle.MutableLiveData
import cn.flightfeather.thirdappmodule.bean.vo.DPChangeInfo
import cn.flightfeather.thirdappmodule.bean.vo.DPProblemRecurrence
import cn.flightfeather.thirdappmodule.bean.vo.QueryOptSingle
import cn.flightfeather.thirdappmodule.common.net.ResultCallBack
import cn.flightfeather.thirdappmodule.module.base.BaseViewModel
import cn.flightfeather.thirdappmodule.repository.DataProdSingleSceneRepository
import cn.flightfeather.thirdappmodule.util.DateUtil
import org.jetbrains.anko.toast
import java.util.*
import kotlin.math.round
 
/**
 * 场景历史情况
 * @author riku
 * Date: 2025/10/30
 */
class SceneHistoryViewModel : BaseViewModel() {
 
    companion object {
        // 整改率阈值
        const val CHANGE_PER = 0.8
 
        // 整改效率阈值
        const val CHANGE_EFFICIENCY_PER = 0.5
    }
 
    private val dataProdSingleSceneRepository = DataProdSingleSceneRepository.instance
 
    // 整改情况
    val changeInfoTxt = MutableLiveData<String>()
 
    // 整改效率
    val changeEfficiencyTxt = MutableLiveData<String>()
 
    // 问题复发情况
    val problemRecurrenceTxt = MutableLiveData<String>()
 
    // 巡查要点
    val inspectionKeyPointTxt = MutableLiveData<String>()
 
    // 应急巡查
    val tempInspectionTxt = MutableLiveData<String>()
 
 
    // 上个月整改率最差的情况
    val changeInfoList = MutableLiveData<List<DPChangeInfo>>()
 
    // 问题复发情况
    val problemRecurrenceList = MutableLiveData<List<DPProblemRecurrence>>()
 
    fun fetchChangeInfoList(sceneId: String) {
        val queryOpts = getQueryOptSingleList(sceneId)
        dataProdSingleSceneRepository.getChangeInfoList(queryOpts, object : ResultCallBack<List<DPChangeInfo>> {
            override fun onSuccess(result: List<DPChangeInfo>?) {
                if (!result.isNullOrEmpty()) {
                    changeInfoTxt.value = result.mapIndexed { i, info ->
                        // 筛选存在问题,并且整改率小于80%的月份
                        if (info.subTasks.isNullOrEmpty() || info.proCount == 0 || info.changePer >= CHANGE_PER) {
                            ""
                        } else {
                            val time = DateUtil.parseYearMonth(queryOpts[i].startTime) ?: return@mapIndexed ""
                            val cal = Calendar.getInstance().apply { setTime(time) }
                            "${cal.get(Calendar.MONTH) + 1}月整改率为${round(info.changePer * 100)}%"
                        }
                    }.filter { it.isNotBlank() }.run {
                        if (this.isEmpty()) {
//                            "近期整改率都高于${round(CHANGE_PER * 100)}%,该工地表现良好。"
                            null
                        } else {
                            joinToString(",") + ",整改率较低。"
                        }
                    }
                    changeEfficiencyTxt.value = result.maxByOrNull { it.changeTime }
                        ?.takeIf { it.proCount > 0 && it.changeEfficiency < CHANGE_EFFICIENCY_PER }
                        .run {
                            this?.subTasks?.takeIf { s -> s.isNotEmpty() }?.get(0)?.let { s ->
                                val time = DateUtil.getMonthStr(s.planstarttime)
                                "前三个月中, ${time}月份整改效率仅为${round(this.changeEfficiency * 100)}%(实际整改耗时${this.changeTime}天)。"
                            }
                        }
 
                    changeInfoList.value = result
                }
            }
 
            override fun onFailure() {
                application.toast("获取整改率情况失败")
            }
        })
    }
 
    fun fetchProblemRecurrence(sceneId: String) {
        // 获取前三个月的内的记录
        val queryOpt = QueryOptSingle().apply {
            this.sceneId = sceneId
            val now = Calendar.getInstance().apply {
                set(Calendar.DAY_OF_MONTH, 1)
                set(Calendar.HOUR_OF_DAY, 0)
                set(Calendar.MINUTE, 0)
                set(Calendar.SECOND, 0)
            }
            // 得到上月最后一天
            now.add(Calendar.SECOND, -1)
            endTime = DateUtil.getDateStr(now.time)
            // 得到前4个月第一天
            now.apply {
                set(Calendar.DAY_OF_MONTH, 1)
                set(Calendar.HOUR_OF_DAY, 0)
                set(Calendar.MINUTE, 0)
                set(Calendar.SECOND, 0)
            }
            now.add(Calendar.MONTH, -2)
            startTime = DateUtil.getDateStr(now.time)
        }
        dataProdSingleSceneRepository.getProblemRecurrence(queryOpt, object : ResultCallBack<List<DPProblemRecurrence>> {
            override fun onSuccess(result: List<DPProblemRecurrence>?) {
                if (!result.isNullOrEmpty()) {
                    problemRecurrenceTxt.value = result
//                        .filter { it.changePer < CHANGE_PER }
                        .filter { it.count > 1 }
                        .mapIndexed { i, p ->
                            "${i + 1}. ${p.problemTag}(出现${p.count}次)"
                        }.joinToString(";\r\n").run {
                            if (this.isBlank()) {
                                null
                            } else {
                                "前三个月存在如下复发问题:\r\n$this"
                            }
                        }
 
                    problemRecurrenceList.value = result
                }
            }
 
            override fun onFailure() {
                application.toast("获取问题复发情况失败")
            }
        })
    }
 
    fun fetchInspectionKeyPoint(sceneId: String) {
        inspectionKeyPointTxt.value = "出入口内、外路面;车辆冲洗;\r\n围墙喷淋;扬尘在线监测设备;技防设施;\r\n干粉砂浆机;渣土垃圾堆放区;纸质台账"
    }
 
 
    private fun getQueryOptSingleList(sceneId: String): List<QueryOptSingle> {
        val queryOpts = mutableListOf<QueryOptSingle>()
 
        // 获取前三个月的月头和月末时间
        val now = Calendar.getInstance().apply {
            set(Calendar.DAY_OF_MONTH, 1)
            set(Calendar.HOUR_OF_DAY, 0)
            set(Calendar.MINUTE, 0)
            set(Calendar.SECOND, 0)
        }
        repeat(3) {
            val queryOptSingle = QueryOptSingle().apply { this.sceneId = sceneId }
            // 得到上月最后一天
            now.add(Calendar.SECOND, -1)
            queryOptSingle.endTime = DateUtil.getDateStr(now.time)
            // 得到上月第一天
            now.apply {
                set(Calendar.DAY_OF_MONTH, 1)
                set(Calendar.HOUR_OF_DAY, 0)
                set(Calendar.MINUTE, 0)
                set(Calendar.SECOND, 0)
            }
            queryOptSingle.startTime = DateUtil.getDateStr(now.time)
 
            queryOpts.add(queryOptSingle)
        }
 
        return queryOpts
    }
}