riku
2022-06-17 3a5c011d9509d3bc0367921f463676c81ff2e374
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
package cn.flightfeather.supervision.lightshare.service.impl
 
import cn.flightfeather.supervision.common.utils.PinYin
import cn.flightfeather.supervision.common.utils.UUIDGenerator
import cn.flightfeather.supervision.domain.ds1.entity.Scense
import cn.flightfeather.supervision.domain.ds1.entity.Userinfo
import cn.flightfeather.supervision.domain.ds1.mapper.ScenseMapper
import cn.flightfeather.supervision.domain.ds1.mapper.UserinfoMapper
import cn.flightfeather.supervision.lightshare.service.UserinfoService
import org.springframework.stereotype.Service
import tk.mybatis.mapper.entity.Example
 
@Service
class UserinfoServiceImpl(val userinfoMapper: UserinfoMapper, private val scenseMapper: ScenseMapper) : UserinfoService {
 
    //根据userinfo条件查询
    override fun findOneByName(userinfo: Userinfo): Userinfo? {
        val example = Example(Userinfo::class.java)
        val criteria = example.createCriteria()
        criteria.andEqualTo("acountname", userinfo.acountname)
                .andEqualTo("password", userinfo.password)
        val result = userinfoMapper.selectByExample(example)
        return if (result.isNotEmpty()) {
            result[0]
        } else {
            userinfo.apply {
                guid = "null"
                usertypeid = -1
            }
        }
    }
 
    override fun findByType(typeId: Byte): List<Userinfo> {
        val result = userinfoMapper.selectByExample(Example(Userinfo::class.java).apply {
            createCriteria().andEqualTo("usertypeid", typeId)
        })
 
        return result
    }
 
    override fun findOne(id: String): Userinfo = userinfoMapper.selectByPrimaryKey(id)
 
    override fun findAll(): MutableList<Userinfo> = userinfoMapper.selectAll()
 
    override fun save(userinfo: Userinfo): Int = userinfoMapper.insert(userinfo)
 
    override fun update(userinfo: Userinfo): Int = userinfoMapper.updateByPrimaryKey(userinfo)
 
    override fun delete(id: String): Int = userinfoMapper.deleteByPrimaryKey(id)
 
    override fun createAccount(sceneId: String): Userinfo {
        findByScene(sceneId)?.let { return it }
 
        scenseMapper.selectByPrimaryKey(sceneId)?.let {
            val sceneName = it.name ?: return Userinfo()
            val uName = getUName(sceneName)
 
            val userInfo = Userinfo().apply {
                guid = UUIDGenerator.generate16ShortUUID()
                acountname = uName
                realname = sceneName
                password = "123456"
                usertypeid = 3
                usertype = "企业"
                dGuid = it.guid
                departmentname = sceneName
                isenable = true
                remark = it.districtname
            }
 
            val r = userinfoMapper.insert(userInfo)
            if (r == 1) {
                return userInfo
            }
        }
        return Userinfo()
    }
 
    override fun findByScene(sceneId: String): Userinfo? {
        userinfoMapper.selectByExample(Example(Userinfo::class.java).apply {
            createCriteria().andEqualTo("dGuid", sceneId)
        })?.takeIf { it.isNotEmpty() }?.let { return it[0] }
        return null
    }
 
    private fun getUName(sceneName: String): String {
        var uName = PinYin.getPinYinHeader(sceneName)
        var repeated = false
        var i = 1
        do {
            userinfoMapper.selectByExample(Example(Userinfo::class.java).apply {
                createCriteria().andEqualTo("acountname", uName)
            }).let {
                repeated = it.isNotEmpty()
                if (repeated) {
                    uName += i
                }
            }
            i++
        } while (repeated && i < 20)
        return uName
    }
 
    override fun autoCreateAccount() {
        val sceneList = scenseMapper.selectNoAccountScene()
        sceneList.forEach {
            createAccount(it)
        }
    }
 
    private fun createAccount(sence: Scense) {
        sence.let {
            val sceneName = it.name ?: return
            val uName = getUName(sceneName)
 
            val userInfo = Userinfo().apply {
                guid = UUIDGenerator.generate16ShortUUID()
                acountname = uName
                realname = sceneName
                password = "123456"
                usertypeid = 3
                usertype = "企业"
                dGuid = it.guid
                departmentname = sceneName
                isenable = true
                remark = it.districtname
            }
 
            val r = userinfoMapper.insert(userInfo)
            if (r == 1) {
                println("${userInfo.guid}--${userInfo.acountname}--${userInfo.realname}")
            }
        }
    }
}