513 lines
20 KiB
C#
513 lines
20 KiB
C#
using Dlhis.Basic.Appointment.Services;
|
|
using Dlhis.Basic.Device.Services;
|
|
using Dlhis.Basic.Organization.Request;
|
|
using Dlhis.Basic.Organization.Response;
|
|
using Dlhis.Entity.Basic.Entity;
|
|
using Dlhis.Entity.Basic.Enums;
|
|
using Dlhis.Entity.Device.Entities;
|
|
using Dlhis.Entity.Device.Enums;
|
|
using Dlhis.Entity.Sys.Entities;
|
|
using Dlhis.Entity.Sys.Enums;
|
|
using Dlhis.Entity.Visitor.Entity;
|
|
using Dlhis.Entity.Visitor.Enums;
|
|
using Dlhis.Sys.Api;
|
|
using Kurisu.AspNetCore.Authentication.Abstractions;
|
|
using Kurisu.AspNetCore.DataAccess.Dto;
|
|
using Kurisu.AspNetCore.DataAccess.SqlSugar.Extensions;
|
|
using Kurisu.AspNetCore.DataAccess.SqlSugar.Services;
|
|
using Kurisu.AspNetCore.Utils.Extensions;
|
|
using Microsoft.AspNetCore.DataProtection;
|
|
using SqlSugar;
|
|
|
|
namespace Dlhis.Basic.Organization.Services.Implements;
|
|
|
|
public class GainfoService : IGainfoService
|
|
{
|
|
private readonly IGainfoStore _gainfoStore;
|
|
private readonly IDbContext _dbContext;
|
|
private readonly IDataProtectionProvider _dataProtectionProvider;
|
|
private readonly ICurrentUser _currentUser;
|
|
private readonly ITenantApi _tenantApi;
|
|
private readonly IJinkoSapService _jinkoSapService;
|
|
private readonly IDevicePermissionService _devicePermissionService;
|
|
private readonly IGainfoPermissionService _gainfoPermissionService;
|
|
private readonly IAppointmentService _appointmentService;
|
|
private readonly ILogger<GainfoService> _logger;
|
|
|
|
public GainfoService(IGainfoStore gainfoStore,
|
|
IDbContext dbContext,
|
|
IDataProtectionProvider dataProtectionProvider,
|
|
ICurrentUser currentUser,
|
|
ITenantApi tenantApi,
|
|
IJinkoSapService jinkoSapService,
|
|
IDevicePermissionService devicePermissionService,
|
|
IGainfoPermissionService gainfoPermissionService,
|
|
IAppointmentService appointmentService,
|
|
ILogger<GainfoService> logger)
|
|
{
|
|
_gainfoStore = gainfoStore;
|
|
_dbContext = dbContext;
|
|
_dataProtectionProvider = dataProtectionProvider;
|
|
_currentUser = currentUser;
|
|
_tenantApi = tenantApi;
|
|
_jinkoSapService = jinkoSapService;
|
|
_devicePermissionService = devicePermissionService;
|
|
_gainfoPermissionService = gainfoPermissionService;
|
|
_appointmentService = appointmentService;
|
|
_logger = logger;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 档案分页
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
public async Task<Pagination<GainfoPageResponse>> GetPageAsync(GainfoPageRequest request)
|
|
{
|
|
var today = DateTime.Today;
|
|
|
|
//根据组织架构搜索档案
|
|
var where = LinqExpressionExtensions.False<GainfoEntity>();
|
|
var factories = _currentUser.GetUserClaim("tenants").Split(",").ToList();
|
|
|
|
if (request.DepartmentSelections.Any())
|
|
{
|
|
foreach (var item in request.DepartmentSelections)
|
|
{
|
|
var searchDepartments = await GetRecursionDepartmentNosAsync(item.DepartmentNos);
|
|
where = searchDepartments.Any()
|
|
? where.Or(gainfo => gainfo.Factory == item.Tenant && searchDepartments.Contains(gainfo.DepartmentNo))
|
|
: where.Or(gainfo => gainfo.Factory == item.Tenant);
|
|
}
|
|
|
|
factories = request.DepartmentSelections.Select(x => x.Tenant).Distinct().ToList();
|
|
}
|
|
else
|
|
{
|
|
where = where.Or(gainfo => factories.Contains(gainfo.Factory));
|
|
}
|
|
|
|
if (request.SearchType.HasValue)
|
|
{
|
|
GainfoUserTypeEnumType userTypeEnumType = request.SearchType switch
|
|
{
|
|
GainfoSearchEnumType.Internal => GainfoUserTypeEnumType.Normal,
|
|
GainfoSearchEnumType.Outsource => GainfoUserTypeEnumType.Outsource,
|
|
GainfoSearchEnumType.BusinessTrip => throw new ArgumentNullException(request.SearchType?.ToString()),
|
|
GainfoSearchEnumType.External => GainfoUserTypeEnumType.External,
|
|
null => throw new ArgumentOutOfRangeException(request.SearchType?.ToString()),
|
|
_ => throw new ArgumentOutOfRangeException(request.SearchType?.ToString())
|
|
};
|
|
where = where.And(x => x.Type == userTypeEnumType);
|
|
}
|
|
|
|
|
|
if (request.IsSearchAll)
|
|
{
|
|
where = Expressionable.Create<GainfoEntity>()
|
|
.And(where)
|
|
.Or(gainfo => SqlFunc.Subqueryable<BusinessTripEntity>()
|
|
.Where(p => p.Code == gainfo.Code
|
|
&& factories.Contains(p.Destination)
|
|
&& SqlFunc.DateIsSame(p.BeginDate, today))
|
|
.Any()
|
|
)
|
|
.ToExpression();
|
|
}
|
|
|
|
|
|
ISugarQueryable<GainfoPageResponse> queryable = request.IsSearchAll
|
|
? _dbContext.Queryable<GainfoEntity>().AS("GainfoEntity", "gainfo")
|
|
.Where(where)
|
|
.LeftJoin<DepartmentEntity>((gainfo, department) => gainfo.DepartmentNo == department.No)
|
|
.LeftJoin<BasicTypeEntity>((gainfo, department, type) => type.Code == SqlFunc.ToString(gainfo.CardType) && type.Type == "timeperiod")
|
|
.WhereIF(request.Search.IsPresent(), gainfo =>
|
|
gainfo.Name == request.Search
|
|
|| gainfo.Code == request.Search
|
|
|| gainfo.IdNo == request.Search)
|
|
.Select((gainfo, department, type) => new GainfoPageResponse
|
|
{
|
|
DepartmentName = department.Name,
|
|
CardType = gainfo.CardType,
|
|
CardTypeName = type.Display
|
|
}, true)
|
|
: _gainfoStore.Queryable(request.Status)
|
|
.WhereIF(request.SearchType.HasValue, where)
|
|
.LeftJoin<DepartmentEntity>((gainfo, department) => gainfo.DepartmentNo == department.No)
|
|
.LeftJoin<BasicTypeEntity>((gainfo, department, type) => type.Code == SqlFunc.ToString(gainfo.CardType) && type.Type == "timeperiod")
|
|
.WhereIF(request.SearchType.HasValue == false, gainfo => SqlFunc.Subqueryable<BusinessTripEntity>()
|
|
.Where(p => p.Code == gainfo.Code && factories.Contains(p.Destination) && SqlFunc.DateIsSame(p.BeginDate, today))
|
|
.Any())
|
|
.WhereIF(request.Search.IsPresent(), gainfo =>
|
|
gainfo.Name.Contains(request.Search)
|
|
|| gainfo.Code == request.Search
|
|
|| gainfo.IdNo == request.Search)
|
|
.OrderByIF(request.SearchType == GainfoSearchEnumType.Outsource, gainfo => gainfo.ResignationDate, OrderByType.Desc) //外包人员按离职日期倒排
|
|
.Select((gainfo, department, type) => new GainfoPageResponse
|
|
{
|
|
DepartmentName = department.Name,
|
|
CardType = gainfo.CardType,
|
|
CardTypeName = type.Display
|
|
}, true);
|
|
|
|
var page = await queryable.ToPageListAsync(request);
|
|
|
|
//外包人员部门号处理
|
|
if (request.SearchType == GainfoSearchEnumType.Outsource)
|
|
{
|
|
var codes = page.Data.Select(x => x.Code).ToList();
|
|
var outsourceInfos = await _dbContext.Queryable<OutsourceEntity>()
|
|
.Where(x => codes.Contains(x.Code))
|
|
.Select(x => new { x.Code, x.Supplier })
|
|
.ToListAsync();
|
|
|
|
page.Data.ForEach(item => { item.DepartmentName = outsourceInfos.FirstOrDefault(x => x.Code == item.Code)?.Supplier; });
|
|
}
|
|
|
|
return page;
|
|
}
|
|
|
|
public async Task<Pagination<GainfoAllPageResponse>> GetPageByCodeAsync(string code)
|
|
{
|
|
var page = await _gainfoStore.Queryable()
|
|
.Where(x => x.Code == code)
|
|
.Select<GainfoAllPageResponse>()
|
|
.ToPageListAsync(new PageDto { PageIndex = 1, PageSize = 1 });
|
|
|
|
var tenants = await _tenantApi.GetTenantsInternalAsync();
|
|
|
|
page.Data.ForEach(x =>
|
|
{
|
|
x.Workplace = tenants.FirstOrDefault(item => item.Code == x.Workplace)?.Name;
|
|
x.Factory = tenants.FirstOrDefault(item => item.Code == x.Factory)?.Name;
|
|
});
|
|
|
|
return page;
|
|
}
|
|
|
|
public async Task<GainfoCurrentResponse> CurrentUserInfoAsync()
|
|
{
|
|
var code = _currentUser.GetUserClaim("jinko-code");
|
|
if (code.IsEmpty())
|
|
{
|
|
_logger.LogWarning("工号为空尝试获取人员信息");
|
|
return null;
|
|
}
|
|
|
|
var gainfo = await _gainfoStore.Queryable().Where(x => x.Code == code).SingleAsync();
|
|
if (gainfo == null)
|
|
{
|
|
//开启同步处理
|
|
await _jinkoSapService.GetPersonsByCodeAsync(code);
|
|
gainfo = await _gainfoStore.Queryable().Where(x => x.Code == code).SingleAsync();
|
|
if (gainfo == null) return null;
|
|
}
|
|
|
|
var info = await _gainfoStore.Queryable(GainfoStatusEnumType.Working)
|
|
.LeftJoin<DepartmentEntity>((ga, department) => ga.DepartmentNo == department.No)
|
|
.LeftJoin<BasicTypeEntity>((ga, department, type) => type.Code == ga.CardType.ToString() && type.Type == "timeperiod")
|
|
.Where((ga, department) => ga.Id == gainfo.Id)
|
|
.Select((ga, department, type) => new GainfoCurrentResponse
|
|
{
|
|
UserNo = ga.No,
|
|
Birthday = ga.Birthday,
|
|
DepartmentNo = department.No,
|
|
DepartmentName = department.Name,
|
|
Gender = ga.Gender,
|
|
UserCode = ga.Code,
|
|
UserName = ga.Name,
|
|
Factory = ga.Factory,
|
|
CardType = ga.CardType,
|
|
CardTypeName = type.Display
|
|
}).SingleAsync();
|
|
|
|
if (info != null)
|
|
{
|
|
try
|
|
{
|
|
var tenant = await _tenantApi.GetTenantByCodeAsync(info.Factory);
|
|
info.FactoryName = tenant?.Name;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
// ignored
|
|
}
|
|
}
|
|
|
|
return info;
|
|
}
|
|
|
|
public async Task<object> CheckIdNoAndNameMatchAsync(GainfoCheckIdNoAndNameRequest request)
|
|
{
|
|
var gainfo = await _gainfoStore.Queryable(GainfoStatusEnumType.Working).SingleAsync(x => x.IdNo == request.IdNo && x.Name == request.Name);
|
|
gainfo.ThrowIfNull("验证失败!");
|
|
|
|
var protector = _dataProtectionProvider.CreateProtector("gainfo:external:idno");
|
|
return new
|
|
{
|
|
loginPass = protector.Protect(request.IdNo),
|
|
UserNo = gainfo.No
|
|
};
|
|
}
|
|
|
|
|
|
public async Task ResignAsync(GainfoResignRequest request)
|
|
{
|
|
var gainfo = await _dbContext.Queryable<GainfoEntity>().SingleAsync(x => x.Id == request.Id);
|
|
gainfo.ThrowIfNull("档案数据不存在");
|
|
|
|
if (gainfo.Type == GainfoUserTypeEnumType.External)
|
|
{
|
|
var visitorAppointmentDetails = await _dbContext.Queryable<VisitorAppointmentDetailEntity>()
|
|
.Where(x => x.UserNo == gainfo.No)
|
|
.Where(x => x.DoorStatus == VisitorAppointmentDetailStatusEnumType.Wait || x.WorkplaceStatus == VisitorAppointmentDetailStatusEnumType.Wait)
|
|
.ToListAsync();
|
|
|
|
|
|
foreach (var visitorAppointment in visitorAppointmentDetails)
|
|
{
|
|
await _appointmentService.FocusLeaveAsync(visitorAppointment.Id, request.Reason);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
await _gainfoPermissionService.ResetPermissionsAsync(gainfo.No, DeviceTaskEnumType.Delete, null, request.Reason);
|
|
|
|
await _dbContext.Deleteable<GainfoGroupRelationshipEntity>().Where(x => x.UserNo == gainfo.No).ExecuteCommandAsync();
|
|
await _dbContext.Deleteable<DevicePermissionEntity>().Where(x => x.AssignType == AssignTypeEnumType.User && x.AssignValue == gainfo.No).ExecuteCommandAsync();
|
|
}
|
|
|
|
//先写入离职表
|
|
gainfo.IdentityUserId = (int)gainfo.Id; //记录原始id
|
|
gainfo.ResignationDate = request.Date;
|
|
gainfo.Remark = request.Reason;
|
|
gainfo.Id = 0;
|
|
|
|
if (!await _dbContext.Queryable<GainfoEntity>().AS("GainfoLeave").AnyAsync(x => x.Code == gainfo.Code))
|
|
{
|
|
await _dbContext.Client.Insertable(gainfo).AS("GainfoLeave").ExecuteCommandAsync();
|
|
}
|
|
|
|
gainfo.Id = gainfo.IdentityUserId;
|
|
await _dbContext.DeleteReallyAsync(gainfo);
|
|
}
|
|
|
|
public async Task SetSecurityWhiteAsync(string userCode)
|
|
{
|
|
var gainfo = await _gainfoStore.Queryable().Where(x => x.Code == userCode).SingleAsync();
|
|
gainfo.ThrowIfNull("档案信息不存在");
|
|
|
|
gainfo.Type = gainfo.Type switch
|
|
{
|
|
GainfoUserTypeEnumType.Normal => GainfoUserTypeEnumType.SecurityWhite,
|
|
GainfoUserTypeEnumType.SecurityWhite => GainfoUserTypeEnumType.Normal,
|
|
_ => gainfo.Type
|
|
};
|
|
|
|
await _dbContext.UpdateAsync(gainfo);
|
|
|
|
var deviceCodes = await _devicePermissionService.GetUserDeviceCodesByNoAsync(gainfo.No);
|
|
|
|
var dhDevices = await _dbContext.Queryable<DeviceEntity>().LeftJoin<DeviceTemplateEntity>((x, xt) => x.TemplateCode == xt.Code)
|
|
.Where((x, xt) => xt.Name == "大华人脸机")
|
|
.Where(x => deviceCodes.Contains(x.Code))
|
|
.ToListAsync();
|
|
|
|
await _dbContext.InsertAsync(dhDevices.Select(x => new DeviceTaskEntity
|
|
{
|
|
Type = DeviceTaskEnumType.Update,
|
|
DeviceType = x.Type,
|
|
UserId = gainfo.Id,
|
|
UserNo = gainfo.No,
|
|
DeviceUniqueNo = x.UniqueNo,
|
|
Status = DeviceTaskStatusEnumType.Wait,
|
|
Version = 0,
|
|
ResultMessage = null,
|
|
Source = "安全级别提高",
|
|
Priority = 60,
|
|
TenantId = x.TenantId
|
|
}).ToList());
|
|
}
|
|
|
|
/// <summary>
|
|
/// 档案列表
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
public async Task<Pagination<GainfoListResponse>> GetGainfoListAsync(GainfoListRequest request)
|
|
{
|
|
var page = await _gainfoStore.Queryable(request.Status)
|
|
.LeftJoin<DepartmentEntity>((ga, de) => ga.DepartmentNo == de.No)
|
|
.WhereIF(!request.Name.IsEmpty(), ga => ga.Name == request.Name)
|
|
.WhereIF(!request.IdNo.IsEmpty(), ga => ga.IdNo == request.IdNo)
|
|
.WhereIF(!request.DepartmentNo.IsEmpty(), ga => ga.DepartmentNo == request.DepartmentNo)
|
|
.WhereIF(!request.Code.IsEmpty(), ga => ga.Code == request.Code)
|
|
.Select((ga, de) => new GainfoListResponse
|
|
{
|
|
No = ga.No,
|
|
Name = ga.Name,
|
|
Code = ga.Code,
|
|
IdNo = ga.IdNo,
|
|
Gender = ga.Gender,
|
|
Phone = ga.Phone,
|
|
DepartmentNo = de.No,
|
|
DepartmentName = de.Name,
|
|
Address = ga.Address,
|
|
}).ToPageListAsync(request);
|
|
|
|
return page;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 档案详情
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
public async Task<GainfoDetailResponse> GetGainfoDetailAsync(GainfoDetailRequest request)
|
|
{
|
|
var info = await _gainfoStore.Queryable(request.Status)
|
|
.LeftJoin<DepartmentEntity>((ga, de) => ga.DepartmentNo == de.No)
|
|
.LeftJoin<PositionEntity>((ga, de, pos) => ga.PositionNo == pos.No)
|
|
.LeftJoin<BasicTypeEntity>((ga, de, pos, type) => type.Code == ga.CardType.ToString() && type.Type == "timeperiod")
|
|
.Where(ga => ga.No == request.No)
|
|
.Select((ga, de, pos, type) => new GainfoDetailResponse
|
|
{
|
|
No = ga.No,
|
|
InternalNo = ga.InternalNo,
|
|
Name = ga.Name,
|
|
Code = ga.Code,
|
|
IdClass = ga.IdClass,
|
|
IdNo = ga.IdNo,
|
|
Gender = ga.Gender,
|
|
Address = ga.Address,
|
|
OriginalBirthday = ga.Birthday,
|
|
Phone = ga.Phone,
|
|
Grade = ga.Grade,
|
|
Title = ga.Title,
|
|
Degree = ga.Degree,
|
|
Werks = ga.Werks,
|
|
CostId = ga.CostId,
|
|
NativeName = ga.Native,
|
|
CountryName = ga.CountryNo,
|
|
NationName = ga.Nation,
|
|
ClassName = ga.IdClass,
|
|
|
|
EntryDate = ga.EntryDate,
|
|
|
|
Workplace = ga.Workplace,
|
|
Factory = ga.Factory,
|
|
|
|
DepartmentName = de.Name,
|
|
Position = pos.Name,
|
|
CardType = ga.CardType,
|
|
CardTypeName = type.Display
|
|
})
|
|
.SingleAsync();
|
|
|
|
if (info != null)
|
|
{
|
|
var searchTypes = new List<string> { "native", "country", "nation", "cls" };
|
|
var types = await _dbContext.Queryable<BasicTypeEntity>().Where(x => searchTypes.Contains(x.Type)).ToListAsync();
|
|
|
|
info.NativeName = types.Where(x => x.Type == "native").FirstOrDefault(x => x.Code == info.NativeName)?.Display;
|
|
info.CountryName = types.Where(x => x.Type == "country").FirstOrDefault(x => x.Code == info.CountryName)?.Display ?? "中国";
|
|
info.NationName = types.Where(x => x.Type == "nation").FirstOrDefault(x => x.Code == info.NationName)?.Display;
|
|
info.ClassName = types.Where(x => x.Type == "cls").FirstOrDefault(x => x.Code == info.ClassName)?.Display ?? "身份证";
|
|
|
|
if (request.WithFace)
|
|
{
|
|
info.Face = await _dbContext.ChangeDb("face").Queryable<GainfoFaceEntity>().Where(x => x.UserCode == info.Code).Select(x => x.Face).SingleAsync();
|
|
}
|
|
|
|
try
|
|
{
|
|
var tenants = await _tenantApi.GetTenantsInternalAsync();
|
|
|
|
info.Workplace = tenants.FirstOrDefault(x => x.Code == info.Workplace)?.Name;
|
|
info.Factory = tenants.FirstOrDefault(x => x.Code == info.Factory)?.Name;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
//ignore
|
|
}
|
|
}
|
|
|
|
return info;
|
|
}
|
|
|
|
public async Task MigrationAsync(MigrationRequest request)
|
|
{
|
|
//档案数据
|
|
var gainfo = await _gainfoStore.Queryable().Where(x => x.Code == request.Code).FirstAsync();
|
|
if (gainfo == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//卡号为空则更新
|
|
if (gainfo.CardNo.IsEmpty())
|
|
{
|
|
gainfo.CardNo = request.CardNo;
|
|
await _gainfoStore.UpdateAsync(gainfo);
|
|
}
|
|
|
|
//外部传入人脸
|
|
if (request.Face.IsPresent())
|
|
{
|
|
var faceDbContext = _dbContext.ChangeDb("face");
|
|
var exists = await faceDbContext.Queryable<GainfoFaceEntity>().AnyAsync(x => x.UserCode == gainfo.Code);
|
|
//人脸不存在则写入
|
|
if (!exists)
|
|
{
|
|
await faceDbContext.InsertAsync(new GainfoFaceEntity
|
|
{
|
|
UserCode = gainfo.Code,
|
|
Face = request.Face
|
|
});
|
|
|
|
//海宁触发权限下发
|
|
if (gainfo.Workplace == "5")
|
|
{
|
|
await _devicePermissionService.GenerateDeviceTasksAsync(gainfo.No, DeviceTaskEnumType.Add, "人员迁移生成");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------help methods ------------------------------------------------
|
|
|
|
/// <summary>
|
|
/// 递归获取部门No
|
|
/// </summary>
|
|
/// <param name="departmentNos"></param>
|
|
/// <returns></returns>
|
|
private async Task<List<string>> GetRecursionDepartmentNosAsync(List<string> departmentNos)
|
|
{
|
|
if (departmentNos.IsEmpty())
|
|
{
|
|
return new List<string>();
|
|
}
|
|
|
|
var departments = await _dbContext.Queryable<DepartmentEntity>().ToListAsync();
|
|
var currentNos = departments.Where(x => departmentNos.Contains(x.No)).ToList();
|
|
|
|
foreach (var item in currentNos)
|
|
{
|
|
RecursionGetNext(item.No, departments, departmentNos);
|
|
}
|
|
|
|
return departmentNos.Distinct().ToList();
|
|
|
|
//local method
|
|
void RecursionGetNext(string currentNo, List<DepartmentEntity> internalDepartments, List<string> result)
|
|
{
|
|
var next = internalDepartments.Where(x => x.PNo == currentNo).ToList();
|
|
|
|
foreach (var item in next)
|
|
{
|
|
result.Add(item.No);
|
|
RecursionGetNext(item.No, internalDepartments, result);
|
|
}
|
|
}
|
|
}
|
|
} |