feiyu02
2025-09-01 29383149f7040d89ae00ad48dc48bbcf46587946
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
package com.flightfeather.uav.lightshare.service.impl
 
import com.flightfeather.uav.common.utils.TimeUtil
import com.flightfeather.uav.domain.entity.GridData
import com.flightfeather.uav.domain.entity.GridDataDetail
import com.flightfeather.uav.domain.mapper.GridDataDetailMapper
import com.flightfeather.uav.domain.mapper.GridDataMapper
import com.flightfeather.uav.domain.mapper.MissionMapper
import com.flightfeather.uav.lightshare.eunm.SatelliteDataType
import com.flightfeather.uav.lightshare.service.SatelliteDataCalculateService
import org.junit.Test
import org.junit.runner.RunWith
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.test.context.junit4.SpringRunner
import tk.mybatis.mapper.entity.Example
 
 
@RunWith(SpringRunner::class)
@SpringBootTest
class SatelliteDataCalculateServiceImplTest {
 
    @Autowired
    lateinit var satelliteDataCalculateService: SatelliteDataCalculateService
 
    @Autowired
    lateinit var gridDataMapper: GridDataMapper
 
    @Autowired
    lateinit var gridDataDetailMapper: GridDataDetailMapper
 
    @Autowired
    lateinit var missionMapper: MissionMapper
 
    /**
     * 刷新每组数据的数据排名
     */
    @Test
    fun refreshDataRank() {
        for (i in 64..69) {
            val dataDetailList = gridDataDetailMapper.selectByExample(Example(GridDataDetail::class.java).apply {
                createCriteria().andEqualTo("dataId", i)
                orderBy("pm25").desc()
            })
            dataDetailList.forEachIndexed { index, d ->
                d?.rank = index + 1
                gridDataDetailMapper.updateByPrimaryKey(d)
            }
            println("finish --${i}")
        }
    }
 
    @Test
    fun calGridVertex() {
        satelliteDataCalculateService.calGridVertex(5)
    }
 
    @Test
    fun splitGrid() {
        val res = satelliteDataCalculateService.splitGrid(1, 10)
//        println(res)
    }
 
    @Test
    fun splitData() {
        val groupIdList = listOf(2, 4)
        val dataId = listOf(34, 29, 25, 18, 8)
 
        groupIdList.forEach { g ->
            dataId.forEach { d ->
                satelliteDataCalculateService.splitData(g, d)
            }
        }
//        val res = satelliteDataCalculateService.splitData(2, 25)
    }
 
    @Test
    fun dataFusion() {
        val missionList =
            listOf(
//                "SH-CN-20241216",
//                "SH-CN-20241202",
//                "SH-CN-20241127",
//                "SH-CN-20241126-1",
//                "SH-CN-20241126-2",
//                "SH-CN-20241108",
//                "SH-CN-20240823"
                "SH-CN-20240723-01",
                "SH-CN-20240723-02",
                "SH-CN-20240830",
                "SH-CN-20240906",
                "SH-CN-20241204",
                "SH-CN-20241210",
                "SH-CN-20241213",
                "SH-CN-20241218",
                "SH-CN-20241220",
                "SH-CN-20241224",
                "SH-CN-20241226",
                "SH-CN-20241227",
                "SH-CN-20241231",
                "SH-CN-20250106",
                "SH-CN-20250108",
                "SH-CN-20250113",
                "SH-CN-20250116",
                "SH-CN-20250120"
            )
        missionList.forEach { m ->
            satelliteDataCalculateService.dataFusion(GridData().apply {
                missionCode = m
                type = 3
            })
        }
//        val res = satelliteDataCalculateService.dataFusion("SH-CN-20241216", 3)
    }
 
    @Test
    fun refreshDayTimePeriod() {
        gridDataMapper.select(GridData().apply { type = SatelliteDataType.Monitor.value.toByte() }).forEach { gd ->
            missionMapper.selectByPrimaryKey(gd?.missionCode)?.let { m ->
                TimeUtil.getDayTimeTag(m.startTime, m.endTime)?.let { p ->
                    gd?.dayTimePeriod = p.first
                    gd?.dayTimePeriodStart = p.second
                    gd?.dayTimePeriodEnd = p.third
 
                    gridDataMapper.updateByPrimaryKey(gd)
                }
            }
        }
    }
}