修改审签问题

lyh

2025-04-01 4e2be858f4ccbb7490b59ed584fd1c829eb4d556

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
package org.jeecg.modules.dnc.service.impl;
 
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.jeecg.modules.dnc.entity.DevicePermissionStream;
import org.jeecg.modules.dnc.mapper.DevicePermissionStreamMapper;
import org.jeecg.modules.dnc.utils.ValidateUtil;
import org.jeecg.modules.dnc.service.IDevicePermissionStreamService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import java.util.ArrayList;
import java.util.List;
 
@Service
public class DevicePermissionStreamServiceImpl extends ServiceImpl<DevicePermissionStreamMapper, DevicePermissionStream> implements IDevicePermissionStreamService {
    @Override
    public DevicePermissionStream getByGroupIdAndUserId(String groupId, String userId) {
        if(!ValidateUtil.validateString(groupId) || !ValidateUtil.validateString(userId))
            return null;
        List<DevicePermissionStream> list = super.lambdaQuery().eq(DevicePermissionStream::getGroupId, groupId).
                eq(DevicePermissionStream::getUserId, userId).isNull(DevicePermissionStream::getDeviceId).list();
        if(list == null || list.isEmpty())
            return null;
        return list.get(0);
    }
 
    @Override
    public DevicePermissionStream getByDeviceIdAndUserId(String groupId, String deviceId, String userId) {
        if(!ValidateUtil.validateString(groupId) || !ValidateUtil.validateString(userId)
                || !ValidateUtil.validateString(deviceId))
            return null;
        List<DevicePermissionStream> list = super.lambdaQuery().eq(DevicePermissionStream::getGroupId, groupId).
                eq(DevicePermissionStream::getUserId, userId).eq(DevicePermissionStream::getDeviceId, deviceId).list();
        if(list == null || list.isEmpty())
            return null;
        return list.get(0);
    }
 
    @Override
    public List<DevicePermissionStream> getDepartPermByGroupId(String groupId) {
        if(!ValidateUtil.validateString(groupId))
            return null;
        List<DevicePermissionStream> list = super.lambdaQuery().eq(DevicePermissionStream::getGroupId, groupId).
                isNull(DevicePermissionStream::getUserId).isNull(DevicePermissionStream::getDeviceId).list();
        if(list == null || list.isEmpty())
            return null;
        return list;
    }
 
    @Override
    public List<DevicePermissionStream> getDepartPermByDeviceId(String groupId, String deviceId) {
        if(!ValidateUtil.validateString(groupId) || !ValidateUtil.validateString(deviceId))
            return null;
        List<DevicePermissionStream> list = super.lambdaQuery().eq(DevicePermissionStream::getGroupId, groupId).
                isNull(DevicePermissionStream::getUserId).eq(DevicePermissionStream::getDeviceId, deviceId).list();
        if(list == null || list.isEmpty())
            return null;
        return list;
    }
 
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean removeByCollection(List<DevicePermissionStream> permissionStreams) {
        if(permissionStreams == null || permissionStreams.isEmpty())
            return false;
        if(permissionStreams.size() == 1)
            return super.removeById(permissionStreams.get(0).getPermId());
        List<String> ids = new ArrayList<>();
        permissionStreams.forEach(item -> {
            ids.add(item.getPermId());
        });
        return super.removeByIds(ids);
    }
 
    @Override
    public DevicePermissionStream getByGroupIdAndDepartId(String groupId, String departId) {
        if(!ValidateUtil.validateString(groupId) || !ValidateUtil.validateString(departId))
            return null;
        List<DevicePermissionStream> list = super.lambdaQuery().eq(DevicePermissionStream::getGroupId, groupId).eq(DevicePermissionStream::getDepartId, departId)
                .isNull(DevicePermissionStream::getDeviceId).isNull(DevicePermissionStream::getUserId).list();
        if(list == null || list.isEmpty())
            return null;
        return list.get(0);
    }
 
    @Override
    public DevicePermissionStream getByDeviceIdAndDepartId(String groupId, String deviceId, String departId) {
        if(!ValidateUtil.validateString(groupId) || !ValidateUtil.validateString(departId)
                || !ValidateUtil.validateString(departId))
            return null;
        List<DevicePermissionStream> list = super.lambdaQuery().eq(DevicePermissionStream::getGroupId, groupId).eq(DevicePermissionStream::getDepartId, departId)
                .eq(DevicePermissionStream::getDeviceId, deviceId).isNull(DevicePermissionStream::getUserId).list();
        if(list == null || list.isEmpty())
            return null;
        return list.get(0);
    }
 
    @Override
    public List<DevicePermissionStream> findByDepartId(String departId) {
        return super.lambdaQuery().eq(DevicePermissionStream::getDepartId, departId).list();
    }
 
    @Override
    public List<DevicePermissionStream> findByUserId(String userId) {
        return super.lambdaQuery().eq(DevicePermissionStream::getUserId, userId).list();
    }
 
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteUserByGroupId(String groupId) {
        LambdaQueryWrapper<DevicePermissionStream> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(DevicePermissionStream::getGroupId, groupId).isNull(DevicePermissionStream::getDeviceId).isNull(DevicePermissionStream::getDepartId);
        return super.remove(lambdaQueryWrapper);
    }
 
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteDepartByGroupId(String groupId) {
        LambdaQueryWrapper<DevicePermissionStream> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(DevicePermissionStream::getGroupId, groupId).isNull(DevicePermissionStream::getDeviceId).isNull(DevicePermissionStream::getUserId);
        return super.remove(lambdaQueryWrapper);
    }
 
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteUserByDeviceId(String groupId, String deviceId) {
        LambdaQueryWrapper<DevicePermissionStream> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(DevicePermissionStream::getGroupId, groupId).eq(DevicePermissionStream::getDeviceId, deviceId)
               .isNull(DevicePermissionStream::getDepartId);
        return super.remove(lambdaQueryWrapper);
    }
 
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteDepartByDeviceId(String groupId, String deviceId) {
        LambdaQueryWrapper<DevicePermissionStream> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(DevicePermissionStream::getGroupId, groupId).eq(DevicePermissionStream::getDeviceId, deviceId)
                .isNull(DevicePermissionStream::getUserId);
        return super.remove(lambdaQueryWrapper);
    }
}