BaseEquipmentPartService.cs
10.6 KB
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
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
using Hh.Mes.Common.Infrastructure;
using Hh.Mes.Common.log;
using Hh.Mes.Common.Request;
using Hh.Mes.POJO.Entity;
using Hh.Mes.POJO.Response;
using Hh.Mes.Service.Repository;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using Hh.Mes.Pojo.System;
using System.Data;
using Hh.Mes.Service.Base;
using Microsoft.AspNetCore.Http;
using Hh.Mes.Service.SystemAuth;
namespace Hh.Mes.Service.Equipment
{
public class BaseEquipmentPartService : RepositorySqlSugar<base_equipment_part>
{
private readonly SysFileService _sysFileService;
public BaseEquipmentPartService(SysFileService sysFileService, IAuth auth) : base(auth)
{
_sysFileService = sysFileService;
_sysFileService.sysWebUser = auth.GetCurrentUser().User;
}
public dynamic Load(PageReq pageReq, base_equipment_part entity)
{
return ExceptionsHelp.Instance.ExecuteT(() =>
{
var result = new Response();
var expression = LinqWhere(entity);
//先组合查询表达式(多表查询查看IOT 设备列表案例)
var query = Context.Queryable<base_equipment_part>().Where(expression);
//Exel false 分页
if (!entity.Exel)
{
int total = 0;
var list = query.ToOffsetPage(pageReq.page, pageReq.limit, ref total);
result.Result = HandleLoadDesc(list);
result.Count = total;
}
else
{
result.Result = HandleLoadDesc(query.ToList());
result.Count = result.Result.Count;
}
return result;
}, catchRetrunValue: "list");
}
private List<base_equipment_part> HandleLoadDesc(List<base_equipment_part> list)
{
var detailKeys = list.Select(i => i.id).ToList();
//查询附件
var ids = list.Select(i => i.id.ToString()).ToList();
var filesQuery = Context.Queryable<sys_File>()
.Where(i => ids.Contains(i.targetId) && i.targetTableName == "base_equipment_part")
.Select(i => new
{
i.targetId,
i.fileName,
i.suffix,
i.url
}).ToList();
//赋值
foreach (var item in list)
{
var fileUrl = filesQuery.Where(i => i.targetId == item.id.ToString()).Select(i => i.url).ToList();
item.url = string.Join(",", fileUrl);
}
return list;
}
public dynamic Ins(base_equipment_part entity)
{
return ExceptionsHelp.Instance.ExecuteT(() =>
{
var response = new Response();
entity.createBy = sysWebUser.Account;
entity.createTime = DateTime.Now;
response.Status = Add(entity);
if (!response.Status) response.Message = SystemVariable.dataActionError;
return response;
});
}
public dynamic Upd(base_equipment_part entity)
{
return ExceptionsHelp.Instance.ExecuteT(() =>
{
var response = new Response();
entity.updateBy = sysWebUser.Account;
entity.updateTime = DateTime.Now;
//编辑前判断保养基础信息是否设置，
var isHave = Context.Queryable<bus_equipment_maintain_rule_detail>()
.Any(x => x.equipmentPartCode == entity.partCode);
if (isHave)
{
return response.ResponseError("设备保养基础信息已绑定，禁止编辑！");
}
response.Status = Update(entity);
if (!response.Status) response.Message = SystemVariable.dataActionError;
return response;
});
}
public dynamic DelByIds(string[] ids)
{
return ExceptionsHelp.Instance.ExecuteT(() =>
{
var response = new Response();
var fileNames = "";//保养操作档案附件名称
foreach (string id in ids)
{
//查询部件编码
var ep = Context.Queryable<base_equipment_part>().Where(x => x.id.Equals(id)).First();
//删除前判断保养基础信息是否设置，
var isHave = Context.Queryable<bus_equipment_maintain_rule_head, bus_equipment_maintain_rule_detail>(
(h, d) => h.keys == d.headKeys)
.Where((h, d) => h.equipmentTypeCode == ep.equipmentTypeCode && d.equipmentPartCode == ep.partCode)
.Select((h, d) => new
{
h.equipmentTypeCode,
d.equipmentPartName
})
.ToList();
if (isHave.Count > 0)
{
return response.ResponseError("设备保养基础信息已绑定，禁止删除！");
}
//删除部件数据
Context.Deleteable<base_equipment_part>(t => t.id == ep.id).AddQueue();
//判断是否有附件
var isHaveFile = Context.Queryable<sys_File>()
.Where(s => s.targetTableName == nameof(base_equipment_part) && s.targetId == id)
.Select(x=>x.url);
if (isHaveFile.Any())
{
fileNames = string.Join(",", isHaveFile.ToList());
Context.Deleteable<sys_File>(s => s.targetTableName == nameof(base_equipment_part) && s.targetId == id).AddQueue();
}
}
response.Status = Context.SaveQueuesAsync().Result > 0;
if (response.Status)//数据操作完成，删除目录文件(保养操作档案附件)
{
foreach (var fileName in fileNames.Split(','))
{
_sysFileService.DeleteDocument(fileName);
}
}
if (!response.Status) response.Message = SystemVariable.dataActionError;
return response;
});
}
public Response ExportData(base_equipment_part entity)
{
return Load(null, entity);
}
public Expression<Func<base_equipment_part, bool>> LinqWhere(base_equipment_part model)
{
try
{
var exp = Expressionable.Create<base_equipment_part>();
//数据过滤条件
//if (!string.IsNullOrWhiteSpace(model.XXX)) exp.And(x => x.XXX.Contains(model.XXX));
if (!string.IsNullOrWhiteSpace(model.partCode) && model.filterPartFlag == 0)
{
exp.And(x => x.partCode.Contains(model.partCode));
}
if (!string.IsNullOrWhiteSpace(model.partName))
{
exp.And(x => x.partName.Contains(model.partName));
}
if (!string.IsNullOrWhiteSpace(model.equipmentTypeCode))
{
exp.And(x => x.equipmentTypeCode == model.equipmentTypeCode);
}
if (model.filterPartFlag == 1)//保养规则明细新增时增加条件过滤
{
var partCodes = Context.Queryable<bus_equipment_maintain_rule_detail>()
.Where(i => i.headKeys == model.headKeys)
.Select(i => i.equipmentPartCode).ToList();
exp.And(x => !partCodes.Contains(x.partCode));
}
if (model.filterPartFlag == 2)//保养规则明细编辑时增加条件过滤
{
var partCodes = Context.Queryable<bus_equipment_maintain_rule_detail>()
.Where(i => i.headKeys == model.headKeys && i.equipmentPartCode != model.partCode)
.Select(i => i.equipmentPartCode).ToList();
exp.And(x => !partCodes.Contains(x.partCode));
}
return exp.ToExpression();//拼接表达式
}
catch (Exception ex)
{
throw new Exception($"{ex.Message}");
}
}
public dynamic uploadImage(int id, List<IFormFile> excelfile)
{
return ExceptionsHelp.Instance.ExecuteT(() =>
{
var response = _sysFileService.AddOrUpdate(new sys_File
{
targetId = id.ToString(),
fileCode = "rule_detail" + DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss"),
targetTableName = nameof(base_equipment_part),
createBy = sysWebUser.Account,
createTime = DateTime.Now,
excelfile = excelfile,
remark = "设备保养规则明细-上传附件，预览将来在推送时候查看文档",
});
if (!response.Status) return response;
return response;
});
}
/// <summary>
/// /左侧列表 设备类型树
/// </summary>
public DataTable GetTreeList()
{
string sql = $@" select name='设备根节点',
keys ='00000000-0000-0000-0000-000000000000',
parentId=null,rootInfo='root',
equipmentTypeCode=''
union all
select
name,
keys=newid(),
parentId ='00000000-0000-0000-0000-000000000000',rootInfo='twoRoot',
equipmentTypeCode=code
from base_equipment_type ";
var dt = base.Context.Ado.GetDataTable(sql);
return dt == null || dt.Rows.Count == 0 ? null : dt;
}
}
}