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
package com.flightfeather.obd.repository.impl
 
import com.flightfeather.obd.domain.entity.ObdData
import com.flightfeather.obd.domain.mapper.ObdDataMapper
import com.flightfeather.obd.lightshare.bean.ObdDataVo
import com.flightfeather.obd.repository.ObdDataRepository
import com.flightfeather.obd.socket.bean.*
import com.flightfeather.obd.socket.eunm.ObdCommandUnit
import com.github.pagehelper.PageHelper
import org.springframework.beans.BeanUtils
import org.springframework.stereotype.Repository
import tk.mybatis.mapper.entity.Example
 
/**
 * obd数据相关数据库操作实现
 * @author riku
 * Date: 2019/8/27
 */
@Repository
class ObdDataDaoImpl(val obdDataMapper: ObdDataMapper) : ObdDataRepository {
 
    override fun saveObdData(data: ObdDataVo): Boolean {
        val obdData = ObdData()
        BeanUtils.copyProperties(data, obdData)
        return obdDataMapper.insert(obdData) == 1
    }
 
    override fun getDataByVinCode(vinCode: String, pageNum: Int?, pageSize: Int?): MutableList<ObdDataVo> {
        val example = Example(ObdData::class.java).apply {
            createCriteria().andEqualTo("obdVin", vinCode)
            orderBy("obdTime").desc()
        }
 
        //分页
        val offset = (pageSize?.times(pageNum?.minus(1) ?: 0)) ?: 0
        PageHelper.offsetPage<ObdData>(offset, pageSize ?: 10)
        val result = obdDataMapper.selectByExample(example)
 
        val resultList = mutableListOf<ObdDataVo>()
        result.forEach {
            val vo = ObdDataVo()
            BeanUtils.copyProperties(it, vo)
            resultList.add(vo)
        }
 
        return resultList
    }
 
    override fun saveObdData(packageData: ObdPackageData): Boolean {
        val obdData = ObdData().apply {
            obdVin = packageData.deviceCode
        }
        when (packageData.commandUnit) {
            ObdCommandUnit.CarRegister.value -> {
                packageData.dataUnit.forEach {
                    when (it) {
                        is CarRegisterData -> {
                            obdData.apply {
                                obdTime = it.time
                            }
                        }
                    }
                }
            }
            ObdCommandUnit.RealTimeData.value,
            ObdCommandUnit.ReplacementData.value -> {
                packageData.dataUnit.forEach {
                    when (it) {
                        is com.flightfeather.obd.socket.bean.ObdInfo -> {
                            obdData.apply {
                                obdTime = it.time
                                obdProtocol = it.obdProtocol
                                obdMil = it.obdMil
                                obdIdCode = it.obdCrn
                                obdVerificationCode = it.obdCvn
                                obdFaultCodeNum = it.obdFaultCodeNum
                                obdFaultCode = it.obdFaultCode
                            }
                        }
                        is EngineDataStream -> {
                            obdData.apply {
                                obdTime = it.time
                                obdLng = it.obdLong
                                obdLat = it.obdLat
                                obdSpeed = it.obdSpeed?.toInt()
                                obdAirPressure = it.obdAirPressure
                                obdEngineTorque = it.obdEngineTorque
                                obdFrictionTorque = it.obdFrictionTorque
                                obdEngineRpm = it.obdEngineRpm?.toInt()
                                obdStartFuelFlow = it.obdEngineFuelFlow
                                obdScrUpstreamNo = it.obdScrUpstreamNox
                                obdScrDownstreamNo = it.obdScrDownstreamNox
                                obdRemainReactant = it.obdRemainReactant
                                obdAirInput = it.obdAirInput
                                obdScrInputTemp = it.obdScrInputTemp
                                obdScrOutputTemp = it.obdScrOutputTemp
                                obdDpf = it.obdDpf
                                obdEngineCoolantTemp = it.obdEngineCoolantTemp
                                obdFuelLevel = it.obdFuelLevel
                                obdLocationStatus = it.obdLocationStatus
                                obdTotalMileage = it.obdTotalMileage
                            }
                        }
                        is SupplementDataStream -> {
                            obdData.apply {
                                obdTime = it.time
                                obdEngineTorqueMode = it.obdEngineTorqueMode?.toString()
                                obdAcceleratorPedal = it.obdAcceleratorPedal
                                obdTotalOilConsumption = it.obdTotalOilConsumption
                                obdUreaBoxTemp = it.obdUreaBoxTemp
                                obdUreaVolume = it.obdUreaVolume?.toInt()
                                obdTotalUreaConsume = it.obdTotalUreaConsume
                                obdDpfTemp = it.obdDpfTemp
//                                obdFirmwareVersion =
                            }
                        }
                    }
                }
 
            }
            ObdCommandUnit.CarLogOut.value -> {
                packageData.dataUnit.forEach {
                    when (it) {
                        is CarLogOutData -> {
                            obdData.apply {
                                obdTime = it.time
                            }
                        }
                    }
                }
            }
            ObdCommandUnit.TimeCalibration.value -> {
                packageData.dataUnit.forEach {
                    when (it) {
                        is TimeCalibrationData -> {
                            obdData.apply {
                                obdTime = it.time
                            }
                        }
                    }
                }
            }
        }
 
        return obdDataMapper.insert(obdData) == 1
    }
}