245 lines
11 KiB
C#
245 lines
11 KiB
C#
using Dlhis.Entity.Basic.Entity;
|
|
using Dlhis.Entity.Device.Entities;
|
|
using Dlhis.Entity.Device.Enums;
|
|
using Dlhis.ScheduledTask.DeviceUploadLog.Request;
|
|
using Dlhis.ScheduledTask.DeviceUploadLog.Response;
|
|
using Kurisu.AspNetCore.Authentication.Abstractions;
|
|
using Kurisu.AspNetCore.CustomClass;
|
|
using Kurisu.AspNetCore.DataAccess.Dto;
|
|
using Kurisu.AspNetCore.DataAccess.SqlSugar.Extensions;
|
|
using Kurisu.AspNetCore.DataAccess.SqlSugar.Services;
|
|
using Kurisu.AspNetCore.Utils.Extensions;
|
|
using SqlSugar;
|
|
|
|
namespace Dlhis.ScheduledTask.DeviceUploadLog.Services.Implements;
|
|
|
|
public class DeviceUploadLogService : IDeviceUploadLogService
|
|
{
|
|
private readonly IDbContext _dbContext;
|
|
private readonly ICurrentUser _currentUser;
|
|
|
|
public DeviceUploadLogService(IDbContext dbContext, ICurrentUser currentUser)
|
|
{
|
|
_dbContext = dbContext;
|
|
_currentUser = currentUser;
|
|
}
|
|
|
|
public async Task UploadLogsAsync(List<DeviceUploadLogUploadRequest> requests)
|
|
{
|
|
var deviceUniqueNos = requests.Select(x => x.DeviceUniqueNo).Distinct().ToList();
|
|
var devices = await _dbContext.Queryable<DeviceEntity>().Where(x => deviceUniqueNos.Contains(x.UniqueNo)).ToListAsync();
|
|
var existsDeviceUniqueNos = devices.Select(x => x.UniqueNo).ToList();
|
|
|
|
var inserts = new List<DeviceUploadLogEntity>();
|
|
foreach (var request in requests.Where(x => existsDeviceUniqueNos.Contains(x.DeviceUniqueNo)))
|
|
{
|
|
if (await _dbContext.Queryable<DeviceUploadLogEntity>().Where(x => x.DeviceUniqueNo == request.DeviceUniqueNo
|
|
&& x.SerialNo == request.SerialNo
|
|
&& x.RaiseDateTime == request.RaiseDateTime).AnyAsync())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (request.CardNo.IsPresent() && request.UserUniqueNo != request.CardNo)
|
|
{
|
|
//UserUniqueNo为老系统档案号(自动生成),CardNo为工号
|
|
if (await _dbContext.Queryable<OldDeviceGainfoEntity>()
|
|
.Where(x => x.DeviceUniqueNo == request.DeviceUniqueNo)
|
|
.Where(x => x.No == request.UserUniqueNo && x.Code == request.CardNo)
|
|
.Select(x => x.Code)
|
|
.AnyAsync())
|
|
{
|
|
request.UserUniqueNo = request.CardNo;
|
|
}
|
|
}
|
|
|
|
var device = devices.First(x => x.UniqueNo == request.DeviceUniqueNo);
|
|
|
|
inserts.Add(new DeviceUploadLogEntity
|
|
{
|
|
DeviceUniqueNo = request.DeviceUniqueNo,
|
|
UserUniqueNo = request.UserUniqueNo,
|
|
RaiseDateTime = request.RaiseDateTime,
|
|
SerialNo = request.SerialNo,
|
|
Type = device.Type == DeviceTypeEnumType.Attendance
|
|
? DeviceUploadLogTypeEnumType.Attendance
|
|
: device.Type == DeviceTypeEnumType.Door && device.AsAttendance
|
|
? DeviceUploadLogTypeEnumType.Attendance
|
|
: DeviceUploadLogTypeEnumType.Door,
|
|
|
|
TenantId = device.TenantId,
|
|
Status = request.Status ?? true,
|
|
CreatedBy = 1,
|
|
ModifiedBy = 1,
|
|
});
|
|
}
|
|
|
|
await _dbContext.InsertAsync(inserts);
|
|
}
|
|
|
|
|
|
public async Task<List<DeviceUploadLogResponse>> GetMyRecordsAsync(DeviceUploadLogMyRecordRequest request)
|
|
{
|
|
var jinkoCode = _currentUser.GetUserClaim("jinko-code") ?? string.Empty;
|
|
|
|
return await _dbContext.Queryable<DeviceUploadLogEntity>()
|
|
.LeftJoin<DeviceEntity>((log, d) => log.DeviceUniqueNo == d.UniqueNo)
|
|
.Where(log => log.UserUniqueNo == jinkoCode)
|
|
.Where(log => log.Status)
|
|
.WhereIF(request.DateTimePeriod.HasValue(), log => log.RaiseDateTime >= request.DateTimePeriod.Start && log.RaiseDateTime <= request.DateTimePeriod.End)
|
|
.Where((log, d) => d.Type == DeviceTypeEnumType.Attendance || (d.Type == DeviceTypeEnumType.Door && d.AsAttendance))
|
|
.OrderBy(log => log.RaiseDateTime)
|
|
.Select((log, d) => new DeviceUploadLogResponse
|
|
{
|
|
OriginUserUniqueNo = log.UserUniqueNo,
|
|
DeviceUniqueNo = log.DeviceUniqueNo,
|
|
Id = log.Id,
|
|
RaiseDateTime = log.RaiseDateTime,
|
|
CreateTime = log.CreateTime,
|
|
SerialNo = log.SerialNo,
|
|
DeployPlace = d.DeployPlace,
|
|
Sync = log.Sync,
|
|
Status = log.Status
|
|
})
|
|
.ToListAsync();
|
|
}
|
|
|
|
public async Task QiaoqiaoGaoshiqingAsync(DeviceUploadLogSecretAddRequest request)
|
|
{
|
|
var device = await _dbContext.Queryable<DeviceEntity>().Where(x => x.UniqueNo == request.DeviceUniqueNo).SingleAsync();
|
|
|
|
await _dbContext.InsertAsync(new DeviceUploadLogEntity
|
|
{
|
|
DeviceUniqueNo = device.UniqueNo,
|
|
UserUniqueNo = request.UserCode,
|
|
RaiseDateTime = request.RaiseDateTime,
|
|
SerialNo = string.Empty,
|
|
Type = device.Type == DeviceTypeEnumType.Attendance
|
|
? DeviceUploadLogTypeEnumType.Attendance
|
|
: device.Type == DeviceTypeEnumType.Door && device.AsAttendance
|
|
? DeviceUploadLogTypeEnumType.Attendance
|
|
: DeviceUploadLogTypeEnumType.Door,
|
|
|
|
TenantId = device.TenantId,
|
|
Status = true,
|
|
CreatedBy = 1,
|
|
ModifiedBy = 1,
|
|
});
|
|
}
|
|
|
|
public async Task<DateTimePeriod> GetDeviceUploadRecordSettingAsync(string deviceNo)
|
|
{
|
|
var start = await _dbContext.Queryable<DeviceUploadLogEntity>()
|
|
.Where(x => x.DeviceUniqueNo == deviceNo)
|
|
.Select(x => SqlFunc.AggregateMax(x.RaiseDateTime))
|
|
.SingleAsync();
|
|
|
|
//0001-01-01 00:00:00
|
|
return new DateTimePeriod
|
|
{
|
|
Start = start,
|
|
End = DateTime.Now.AddDays(1)
|
|
};
|
|
}
|
|
|
|
public async Task<Pagination<DeviceUploadLogResponse>> GetPageAsync(DeviceUploadLogPageRequest request)
|
|
{
|
|
DeviceUploadLogTypeEnumType? type = request.Type switch
|
|
{
|
|
DeviceTypeEnumType.Attendance => DeviceUploadLogTypeEnumType.Attendance,
|
|
DeviceTypeEnumType.Door => DeviceUploadLogTypeEnumType.Door,
|
|
_ => throw new UserFriendlyException("不支持当前设备类型")
|
|
};
|
|
|
|
if (request.IsOutsource.HasValue && !request.IsOutsource.Value)
|
|
{
|
|
var r = await _dbContext.Queryable<OutsourceEntity>()
|
|
.LeftJoin<DeviceUploadLogEntity>((os, x) => os.Code == x.UserUniqueNo)
|
|
.LeftJoin<DeviceEntity>((os, x, device) => x.DeviceUniqueNo == device.UniqueNo)
|
|
.LeftJoin<GainfoEntity>((os, x, device, ga) => os.Code == ga.Code)
|
|
.LeftJoin<GainfoEntity>((os, x, device, ga, gasap) => gasap.Code == os.SapCode)
|
|
.WhereIF(request.Search.IsPresent(), (os, x, device, ga, gasap) =>
|
|
ga.Code == request.Search
|
|
|| ga.Name == request.Search
|
|
|| x.DeviceUniqueNo == request.Search
|
|
|| os.Supplier.Contains(request.Search)
|
|
|| os.SapCode == request.Search
|
|
).OrderBy(x => x.ModifiedTime, OrderByType.Desc)
|
|
.Select((os, x, device, ga, gasap) => new DeviceUploadLogResponse
|
|
{
|
|
Id = x.Id,
|
|
OriginUserUniqueNo = x.UserUniqueNo,
|
|
OutsourceSupplier = os.Supplier,
|
|
SapUserCode = os.SapCode,
|
|
SapUserName = gasap.Name,
|
|
DeviceUniqueNo = x.DeviceUniqueNo,
|
|
RaiseDateTime = x.RaiseDateTime,
|
|
CreateTime = x.CreateTime,
|
|
SerialNo = x.SerialNo,
|
|
UserNo = ga.No,
|
|
UserCode = ga.Code,
|
|
UserName = ga.Name,
|
|
DeployPlace = device.DeployPlace,
|
|
Sync = x.Sync,
|
|
Status = x.Status,
|
|
}).ToPageListAsync(request.PageIndex, request.PageSize);
|
|
|
|
return new Pagination<DeviceUploadLogResponse>
|
|
{
|
|
PageIndex = request.PageIndex,
|
|
PageSize = request.PageSize,
|
|
Total = 0,
|
|
Data = r
|
|
};
|
|
}
|
|
else
|
|
{
|
|
var r = await _dbContext.Queryable<DeviceUploadLogEntity>()
|
|
.LeftJoin<DeviceEntity>((x, device) => x.DeviceUniqueNo == device.UniqueNo)
|
|
.LeftJoin<GainfoEntity>((x, device, ga) => x.UserUniqueNo == ga.Code)
|
|
.LeftJoin<OutsourceEntity>((x, device, ga, os) => x.UserUniqueNo == os.Code)
|
|
.LeftJoin<GainfoEntity>((x, device, ga, os, gasap) => gasap.Code == os.SapCode)
|
|
.WhereIF(request.SearchDateTimePeriod.HasValue(), x => x.RaiseDateTime >= request.SearchDateTimePeriod.Start && x.RaiseDateTime <= request.SearchDateTimePeriod.End)
|
|
.Where((x, device) => x.Type == type && !SqlFunc.IsNullOrEmpty(x.UserUniqueNo))
|
|
.WhereIF(request.Sync.HasValue, x => x.Sync == request.Sync)
|
|
.WhereIF(request.IsOutsource.HasValue && request.IsOutsource.Value,
|
|
x => SqlFunc.Subqueryable<OutsourceEntity>().Where(p => p.Code == x.UserUniqueNo).Any())
|
|
.WhereIF(request.IsOutsource.HasValue && !request.IsOutsource.Value,
|
|
x => SqlFunc.Subqueryable<OutsourceEntity>().Where(p => p.Code == x.UserUniqueNo).NotAny())
|
|
.WhereIF(request.Search.IsPresent(), (x, device, ga, os) =>
|
|
ga.Code == request.Search
|
|
|| ga.Name == request.Search
|
|
|| x.DeviceUniqueNo == request.Search
|
|
|| os.Supplier.Contains(request.Search)
|
|
|| os.SapCode == request.Search
|
|
)
|
|
.OrderBy(x => x.ModifiedTime, OrderByType.Desc)
|
|
.Select((x, device, ga, os, gasap) => new DeviceUploadLogResponse
|
|
{
|
|
Id = x.Id,
|
|
OriginUserUniqueNo = x.UserUniqueNo,
|
|
OutsourceSupplier = os.Supplier,
|
|
SapUserCode = os.SapCode,
|
|
SapUserName = gasap.Name,
|
|
DeviceUniqueNo = x.DeviceUniqueNo,
|
|
RaiseDateTime = x.RaiseDateTime,
|
|
CreateTime = x.CreateTime,
|
|
SerialNo = x.SerialNo,
|
|
UserNo = ga.No,
|
|
UserCode = ga.Code,
|
|
UserName = ga.Name,
|
|
DeployPlace = device.DeployPlace,
|
|
Sync = x.Sync,
|
|
Status = x.Status,
|
|
}).ToPageListAsync(request.PageIndex, request.PageSize);
|
|
|
|
return new Pagination<DeviceUploadLogResponse>
|
|
{
|
|
PageIndex = request.PageIndex,
|
|
PageSize = request.PageSize,
|
|
Total = 0,
|
|
Data = r
|
|
};
|
|
}
|
|
}
|
|
} |