riku
2025-10-31 1897c4ad5fa73b3f0a36e1aa0e1e9000302a6ace
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
package cn.flightfeather.thirdappmodule.databinding
 
import android.arch.lifecycle.MutableLiveData
import android.view.View
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
    }
 
    private val dataProdSingleSceneRepository = DataProdSingleSceneRepository.instance
 
    // 上个月整改率最差的情况
    var worstChangeInfo = MutableLiveData<DPChangeInfo>()
 
    var changeInfoTxt = MutableLiveData<String>()
    var changeEfficiencyTxt = MutableLiveData<String>()
 
    // 问题复发情况
//    var problemRecurrenceList = MutableLiveData<List<DPProblemRecurrence>>()
    var worstProblemRecurrence = MutableLiveData<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.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() }.joinToString(",") + ",整改率较低,需加强监管。"
 
                    worstChangeInfo.value = result[0]
                }
            }
 
            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()) {
                    worstProblemRecurrence.value = result[0]
                }
            }
 
            override fun onFailure() {
                application.toast("获取问题复发情况失败")
            }
        })
    }
 
 
 
    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
    }
}