ke_junjie
2025-06-04 84620534eb627e95811b971a4b552b6a177829bf
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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
using iWare.Wms.Core;
using Furion.DatabaseAccessor;
using Furion.DatabaseAccessor.Extensions;
using Furion.DependencyInjection;
using Furion.DynamicApiController;
using Furion.Extras.iWare.Wms.Util.LowCode.Front.Model;
using Furion.FriendlyException;
using Mapster;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
 
namespace iWare.Wms.Application
{
    /// <summary>
    /// 字典值服务
    /// </summary>
    [ApiDescriptionSettings(Name = "DictData", Order = 100)]
    [AllowAnonymous]
    [Route("api")]
    public class SysDictDataService : ISysDictDataService, IDynamicApiController, ITransient
    {
        private readonly IRepository<SysDictData> _sysDictDataRep;  // 字典类型表仓储
        private readonly IRepository<SysDictType> _sysDictTypeRep;  // 字典类型表仓储
 
        public SysDictDataService(IRepository<SysDictData> sysDictDataRep, IRepository<SysDictType> sysDictTypeRep)
        {
            _sysDictDataRep = sysDictDataRep;
            _sysDictTypeRep = sysDictTypeRep;
        }
 
        /// <summary>
        /// 分页查询字典值
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet("sysDictData/page")]
        public async Task<PageResult<DictDataOutput>> QueryDictDataPageList([FromQuery] DictDataPageInput input)
        {
            bool supperAdmin = CurrentUserInfo.IsSuperAdmin;
            var code = !string.IsNullOrEmpty(input.Code?.Trim());
            var value = !string.IsNullOrEmpty(input.Value?.Trim());
            var dictDatas = await _sysDictDataRep.DetachedEntities
                                  .Where(u => u.TypeId == input.TypeId)
                                  .Where((code, u => EF.Functions.Like(u.Code, $"%{input.Code.Trim()}%")),
                                         (value, u => EF.Functions.Like(u.Value, $"%{input.Value.Trim()}%")))
                                  .Where(u => (u.Status != CommonStatus.DELETED && !supperAdmin) || (u.Status <= CommonStatus.DELETED && supperAdmin))
                                  .OrderBy(u => u.Sort)
                                  .ProjectToType<DictDataOutput>()
                                  .ToADPagedListAsync(input.PageNo, input.PageSize);
            return dictDatas;
        }
 
        /// <summary>
        /// 获取某个字典类型下字典值列表
        /// </summary>
        /// <returns></returns>
        [HttpGet("sysDictData/list")]
        public async Task<List<SysDictData>> GetDictDataList([FromQuery] QueryDictDataListInput input)
        {
            return await _sysDictDataRep.DetachedEntities.Where(u => u.TypeId == input.TypeId)
                .Where(u => u.Status != CommonStatus.DELETED)
                .OrderBy(u => u.Sort)
                .ToListAsync();
        }
 
        /// <summary>
        /// 获取某个字典类型下字典值列表
        /// </summary>
        /// <returns></returns>
        [HttpGet("sysDictData/listbycode")]
        public async Task<List<Front_Option>> GetDictDataListByCode([FromQuery] QueryDictDataListByCodeInput input)
        {
            var typeid = await _sysDictTypeRep.Where(x => x.Code == input.Code).Select(x => x.Id).FirstOrDefaultAsync();
 
            return await _sysDictDataRep.DetachedEntities.Where(u => u.TypeId == typeid)
                .Where(u => u.Status != CommonStatus.DELETED)
                .OrderBy(u => u.Sort)
                .Select(u => new Front_Option() { Label = u.Value, Value = u.Code })
                .ToListAsync();
        }
 
        /// <summary>
        /// 增加字典值
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("sysDictData/add")]
        public async Task AddDictData(AddDictDataInput input)
        {
            var isExist = await _sysDictDataRep.AnyAsync(u => (u.Code == input.Code || u.Value == input.Value) && u.TypeId == input.TypeId, false);
            if (isExist) throw Oops.Oh(ErrorCode.D3003);
 
            var dictData = input.Adapt<SysDictData>();
            await _sysDictDataRep.InsertAsync(dictData);
        }
 
        /// <summary>
        /// 删除字典值
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("sysDictData/delete")]
        public async Task DeleteDictData(DeleteDictDataInput input)
        {
            var dictData = await _sysDictDataRep.FirstOrDefaultAsync(u => u.Id == input.Id);
            if (dictData == null) throw Oops.Oh(ErrorCode.D3004);
            if (dictData.Status == CommonStatus.DELETED)
            {
                await dictData.DeleteAsync();
            }
            else
            {
                dictData.Status = CommonStatus.DELETED;
                dictData.IsDeleted = true;
            }
        }
 
        /// <summary>
        /// 更新字典值
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("sysDictData/edit")]
        public async Task UpdateDictData(UpdateDictDataInput input)
        {
            var isExist = await _sysDictDataRep.AnyAsync(u => u.Id == input.Id, false);
            if (!isExist) throw Oops.Oh(ErrorCode.D3004);
 
            // 排除自己并且判断与其他是否相同
            isExist = await _sysDictDataRep.AnyAsync(u => (u.Value == input.Value || u.Code == input.Code) && u.TypeId == input.TypeId && u.Id != input.Id, false);
            if (isExist) throw Oops.Oh(ErrorCode.D3003);
 
            var dictData = input.Adapt<SysDictData>();
            await _sysDictDataRep.UpdateAsync(dictData, ignoreNullValues: true);
        }
 
        /// <summary>
        /// 字典值详情
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet("sysDictData/detail")]
        public async Task<SysDictData> GetDictData([FromQuery] QueryDictDataInput input)
        {
            return await _sysDictDataRep.FirstOrDefaultAsync(u => u.Id == input.Id, false);
        }
 
        /// <summary>
        /// 修改字典值状态
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("sysDictData/changeStatus")]
        public async Task ChangeDictDataStatus(ChageStateDictDataInput input)
        {
            var dictData = await _sysDictDataRep.FirstOrDefaultAsync(u => u.Id == input.Id);
            if (dictData == null) throw Oops.Oh(ErrorCode.D3004);
 
            if (!Enum.IsDefined(typeof(CommonStatus), input.Status))
                throw Oops.Oh(ErrorCode.D3005);
 
            dictData.Status = input.Status;
            dictData.IsDeleted = false;
        }
 
        /// <summary>
        /// 根据字典类型Id获取字典值集合
        /// </summary>
        /// <param name="dictTypeId"></param>
        /// <returns></returns>
        [NonAction]
        public async Task<List<SysDictData>> GetDictDataListByDictTypeId(long dictTypeId)
        {
            return await _sysDictDataRep.DetachedEntities.Where(u => u.SysDictType.Id == dictTypeId)
                                                         .Where(u => u.Status == CommonStatus.ENABLE).OrderBy(u => u.Sort)
                                                         .ToListAsync();
        }
 
        /// <summary>
        /// 删除字典下所有值
        /// </summary>
        /// <param name="dictTypeId"></param>
        [NonAction]
        public async Task DeleteByTypeId(long dictTypeId)
        {
            var dictDatas = await _sysDictDataRep.Where(u => u.TypeId == dictTypeId).ToListAsync();
            await _sysDictDataRep.DeleteAsync(dictDatas);
        }
    }
}