You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1925 lines
91 KiB
1925 lines
91 KiB
using ATS.NonCustodial.Application.Base; |
|
using ATS.NonCustodial.Application.Contracts.Interfaces.Admins.AppDictionaries; |
|
using ATS.NonCustodial.Application.Contracts.Interfaces.Admins.Role; |
|
using ATS.NonCustodial.Application.Contracts.Interfaces.Admins.User; |
|
using ATS.NonCustodial.Application.Contracts.Interfaces.Admins.User.Input; |
|
using ATS.NonCustodial.Application.Contracts.Interfaces.Business.AppCaseManagements.AppCaseManagement; |
|
using ATS.NonCustodial.Application.Contracts.Interfaces.Business.AppCaseManagements.AppCaseManagement.Input; |
|
using ATS.NonCustodial.Application.Contracts.Interfaces.Business.AppCaseManagements.AppCaseManagement.Output; |
|
using ATS.NonCustodial.Application.Contracts.Interfaces.Business.AppCaseManagements.AppSupervisedPersons.Output; |
|
using ATS.NonCustodial.Domain.Entities.Admins; |
|
using ATS.NonCustodial.Domain.Entities.Business; |
|
using ATS.NonCustodial.Domain.Entities.Business.CaseManagements; |
|
using ATS.NonCustodial.Domain.Shared.AggRootEntities.Dtos; |
|
using ATS.NonCustodial.Domain.Shared.Common.Dtos; |
|
using ATS.NonCustodial.Domain.Shared.Enums; |
|
using ATS.NonCustodial.Domain.Shared.OrmRepositories.Basic.EfCore; |
|
using ATS.NonCustodial.DynamicApi; |
|
using ATS.NonCustodial.DynamicApi.Attributes; |
|
using ATS.NonCustodial.Shared.Common.Auth; |
|
using ATS.NonCustodial.Shared.Common.Dtos; |
|
using ATS.NonCustodial.Shared.Common.Enums; |
|
using ATS.NonCustodial.Shared.Common.UnifiedResults; |
|
using ATS.NonCustodial.Shared.Configurations.Options; |
|
using ATS.NonCustodial.Shared.Extensions; |
|
using ATS.NonCustodial.Shared.Extensions.AdvancedQuery; |
|
using ATS.NonCustodial.Shared.Extensions.Collection; |
|
using ATS.NonCustodial.Shared.Helpers; |
|
using AutoMapper.QueryableExtensions; |
|
using Castle.Components.DictionaryAdapter; |
|
using Microsoft.AspNetCore.Http; |
|
using Microsoft.AspNetCore.Mvc; |
|
using Microsoft.EntityFrameworkCore; |
|
using SixLabors.ImageSharp; |
|
using Yitter.IdGenerator; |
|
|
|
|
|
namespace ATS.NonCustodial.Application.Impl.Business.CaseManagements |
|
{ |
|
/// <summary> |
|
/// 案件管理服务 |
|
/// </summary> |
|
/// Author:mxg |
|
/// CreatedTimed:2022-06-06 10:41 AM |
|
/// <remarks> |
|
/// 案件进度： |
|
/// 1、待执行：案件创建后的案件进度为待执行 |
|
/// 2、执行中：案件中被监管人有一个在app上的绑定申请通过了，案件进度变为执行中 |
|
/// 3、已结束：手动结束案件后的进度为已结束 |
|
/// </remarks> |
|
[DynamicApi(Area = "admin")] |
|
public class AppCaseManagementService : AdminCommonService, IAppCaseManagementService, IDynamicApi |
|
{ |
|
#region Identity |
|
|
|
private readonly IEfRepository<AppCaseNotes, long> _appCaseNotesRepository; |
|
private readonly IEfRepository<AppBusinessApplication, long> _appBusinessApplicationRepository; |
|
private readonly IRoleService _roleService; |
|
private readonly IEfRepository<AppCommonFence, long> _appCommonFenceRepository; |
|
private readonly IEfRepository<AppUser, long> _appUserRepository; |
|
private readonly IEfRepository<AppDeviceManagement, long> _appDeviceManagementRepository; |
|
private readonly IEfRepository<AppUser, long> _appuserRepository; |
|
|
|
/// <summary> |
|
/// |
|
/// </summary> |
|
/// <param name="appCaseManagementRepository"></param> |
|
/// <param name="appCaseSupervisorRepository"></param> |
|
/// <param name="appCaseNotesRepository"></param> |
|
/// <param name="appSupervisedPersonRepository"></param> |
|
/// <param name="appBusinessApplicationRepository"></param> |
|
/// <param name="userService"></param> |
|
/// <param name="roleService"></param> |
|
/// <param name="appDictionaryService"></param> |
|
/// <param name="appCommonFenceRepository"></param> |
|
/// <param name="appUserRepository"></param> |
|
/// <param name="appSupervisedPersonRealTimeLocationRepository"></param> |
|
/// <param name="appDeviceManagementRepository"></param> |
|
public AppCaseManagementService( |
|
IEfRepository<AppCaseManagement, long> appCaseManagementRepository, |
|
IEfRepository<AppCaseSupervisor, long> appCaseSupervisorRepository, |
|
IEfRepository<AppCaseNotes, long> appCaseNotesRepository, |
|
IEfRepository<AppCaseSupervisedPerson, long> appSupervisedPersonRepository, |
|
IEfRepository<AppBusinessApplication, long> appBusinessApplicationRepository, |
|
IUserService userService, |
|
IRoleService roleService, |
|
IEfRepository<AppUser, long> appuserRepository, |
|
IAppDictionaryService appDictionaryService, |
|
IEfRepository<AppCommonFence, long> appCommonFenceRepository, |
|
IEfRepository<AppUser, long> appUserRepository, |
|
IEfRepository<AppSupervisedPersonRealTimeLocation, long> appSupervisedPersonRealTimeLocationRepository, |
|
IEfRepository<AppDeviceManagement, long> appDeviceManagementRepository) |
|
: base( |
|
appCaseManagementRepository, |
|
appCaseSupervisorRepository, |
|
appSupervisedPersonRepository, |
|
userService, |
|
appDictionaryService, |
|
appSupervisedPersonRealTimeLocationRepository) |
|
{ |
|
_appCaseNotesRepository = appCaseNotesRepository; |
|
_appBusinessApplicationRepository = appBusinessApplicationRepository; |
|
_roleService = roleService; |
|
_appCommonFenceRepository = appCommonFenceRepository; |
|
_appUserRepository = appUserRepository; |
|
_appDeviceManagementRepository = appDeviceManagementRepository; |
|
_appuserRepository = appuserRepository; |
|
} |
|
|
|
#endregion Identity |
|
|
|
/// <summary> |
|
/// 查询 |
|
/// </summary> |
|
/// <param name="id"></param> |
|
/// <returns></returns> |
|
public async Task<IResultOutput> Get(long id) |
|
{ |
|
var caseDto = await base.GetWithDataAsync<AppCaseManagement, AppCaseManagementGetDto, long>(_appCaseManagementRepository, id); |
|
|
|
//监管人员(管理员) |
|
caseDto.SupervisorIds = await _appCaseSupervisorRepository |
|
.AsQueryable(false, true) |
|
.Where(w => w.CaseId == id) |
|
.Select(w => w.SupervisorId).ToListAsync(); |
|
|
|
//案子-被监管人员 |
|
caseDto.SupervisedPersonGetDtos = await _appSupervisedPersonRepository.AsQueryable(false, true) |
|
.Where(w => w.CaseId == id) |
|
.OrderBy(W => W.Id) |
|
.ProjectTo<AppSupervisedPersonGetDto>(Mapper.ConfigurationProvider).ToListAsync(); |
|
|
|
//返回结果 |
|
return ResultOutput.Ok(caseDto); |
|
} |
|
|
|
/// <summary> |
|
/// 分页查询 |
|
/// </summary> |
|
/// <param name="input"></param> |
|
/// <returns></returns> |
|
[HttpPost] |
|
public async Task<IResultOutput> GetPageAsync(AppCaseManagementGetPageInput input) |
|
{ |
|
var limits = User.limits; |
|
var selectLimits = await _appCaseSupervisorRepository.AsQueryable(false, true) |
|
.Where(w => limits.Contains(w.UnitId.ToString())) |
|
.ToListAsync(); |
|
input.CaseIds = selectLimits.Select(w => w.CaseId).Distinct().ToList(); |
|
|
|
var express = await GetExpression(input, _appCaseManagementRepository.AsQueryable(false, true)); |
|
|
|
var rtn = await base.GetPageAsync<AppCaseManagement, AppCaseManagementGetPageInput, AppCaseManagementListDto>(input, express); |
|
|
|
foreach (var listDto in rtn.Data) |
|
{ |
|
listDto.Supervisor = selectLimits.Where(w => w.CaseId == listDto.Id).Select(w => w.SupervisorName).JoinAsString(","); |
|
} |
|
|
|
return ResultOutput.Ok(rtn); |
|
} |
|
|
|
//[HttpPost] |
|
//public async Task<IResultOutput> GetPageAsync(AppCaseManagementGetPageInput input) |
|
//{ |
|
// var express = await GetExpression(input, _appCaseManagementRepository.AsQueryable(false, true)); |
|
|
|
// var rtn = await base.GetPageAsync<AppCaseManagement, AppCaseManagementGetPageInput, AppCaseManagementListDto>(input, express); |
|
|
|
// var caseIds = rtn.Data.Select(w => w.Id).ToList(); |
|
|
|
// var caseSupervisor = await _appCaseSupervisorRepository.AsQueryable(false, true) |
|
// .Where(w => caseIds.Contains(w.CaseId)) |
|
// .ToListAsync(); |
|
|
|
// foreach (var listDto in rtn.Data) |
|
// { |
|
// listDto.Supervisor = caseSupervisor.Where(w => w.CaseId == listDto.Id).Select(w => w.SupervisorName).JoinAsString(","); |
|
// } |
|
|
|
// return ResultOutput.Ok(rtn); |
|
//} |
|
|
|
/// <summary> |
|
/// 案件统计 |
|
/// </summary> |
|
/// <param name="input"></param> |
|
/// <returns></returns> |
|
[HttpPost] |
|
public async Task<IResultOutput> GetAjtjAsync(AppCaseManagementGetPageInput input) |
|
{ |
|
var Caselist = await _appCaseManagementRepository.AsQueryable(false, true).WhereIf(input.TimeSearch.BeginTime != null && input.TimeSearch.EndTime != null, q => q.CreatedTime >= input.TimeSearch.BeginTime && q.CreatedTime <= $"{input.TimeSearch.EndTime.Value.ToString("yyyy-MM-dd")} 23:59:59".ToDateTime()).Where(q => q.IsDeleted == false).ToListAsync(); |
|
var count = Caselist.Count(); |
|
var datalist = Caselist.Where(q => q.CreatedTime != null).GroupBy(q => $"{q.CreatedTime.Value.ToString("MM月dd日")}").Select(q => new { name = q.Key, value = q.Count() }).ToList(); |
|
return ResultOutput.Ok(new { count = count, data = datalist }); |
|
} |
|
|
|
/// <summary> |
|
/// 涉案人员统计 |
|
/// </summary> |
|
/// <param name="input"></param> |
|
/// <returns></returns> |
|
[HttpPost] |
|
public async Task<IResultOutput> GetSaryAsync(AppCaseManagementGetPageInput input) |
|
{ |
|
var caseIds = await _appCaseManagementRepository.AsQueryable(false, true).Where(q => q.IsDeleted == false).Select(q => q.Id).ToListAsync(); |
|
|
|
var list = await _appSupervisedPersonRepository.AsQueryable(false, true).WhereIf(input.TimeSearch.BeginTime != null && input.TimeSearch.EndTime != null, q => q.CreatedTime >= input.TimeSearch.BeginTime && q.CreatedTime <= $"{input.TimeSearch.EndTime.Value.ToString("yyyy-MM-dd")} 23:59:59".ToDateTime()).Where(q => q.IsDeleted == false && caseIds.Contains(q.CaseId)).ToListAsync(); |
|
var dalist = list.Distinct((a, b) => a.SupervisedPersonId == b.SupervisedPersonId); |
|
var count = dalist.Count(); |
|
var datalist = dalist.Where(q => q.CreatedTime != null).GroupBy(q => $"{q.CreatedTime.Value.ToString("MM月dd日")}").Select(q => new { name = q.Key, value = q.Count() }); |
|
return ResultOutput.Ok(new { count = count, data = datalist, list = dalist }); |
|
} |
|
|
|
/// <summary> |
|
/// 涉案人员统计分页查询 |
|
/// </summary> |
|
/// <param name="input"></param> |
|
/// <returns></returns> |
|
[HttpPost] |
|
public async Task<IResultOutput> SupervisedPersonAsync(GetSupervisedPersonPage input) |
|
{ |
|
var caselist = await _appCaseManagementRepository.AsQueryable(false, true).WhereIf(input.TimeSearch.BeginTime != null && input.TimeSearch.EndTime != null, q => q.CreatedTime >= input.TimeSearch.BeginTime && q.CreatedTime <= $"{input.TimeSearch.EndTime.Value.ToString("yyyy-MM-dd")} 23:59:59".ToDateTime()).Where(q => q.IsDeleted == false).ToListAsync(); |
|
var caseIds = caselist.Select(q => q.Id).ToList(); |
|
var data = await _appSupervisedPersonRepository |
|
.Where(q => caseIds.Contains(q.CaseId)) |
|
.OrderByDescending(r => r.CreatedTime) |
|
.ProjectTo<AppSupervisedPersonGetDto>(Mapper.ConfigurationProvider) |
|
.PagedAsync(input) |
|
.ConfigureAwait(false); |
|
return ResultOutput.Ok(new { data, caselist }); |
|
} |
|
|
|
|
|
/// <summary> |
|
/// 案件信息数据统计 |
|
/// </summary> |
|
/// <param name="input"></param> |
|
/// <returns></returns> |
|
[HttpPost] |
|
public async Task<IResultOutput> caseStatistics() |
|
{ |
|
//获取案件信息 |
|
var express = await base.GetCurrentUserCaseListAsync(); |
|
//案件信息Id |
|
var caseIds = await express.Select(w => w.AppCaseManagement.Id).ToListAsync(); |
|
//监管人数 |
|
var caseSupervisor = await _appCaseSupervisorRepository.AsQueryable(false, true) |
|
.Where(w => caseIds.Contains(w.CaseId)) |
|
.ToListAsync(); |
|
//被监管人数 |
|
var caseSupervisorperson = await _appSupervisedPersonRepository.AsQueryable(false, true) |
|
.Where(w => caseIds.Contains(w.CaseId)) |
|
.ToListAsync(); |
|
var total = express.GroupBy(q => q.AppCaseManagement.Id).Count();//案件总数 |
|
var typenotused = express.GroupBy(q => q.AppCaseManagement.CaseTypeId).Count();//案件类型总数 |
|
var superviseNumber = caseSupervisor.GroupBy(q => q.SupervisorId).Count();//监管人数 |
|
var Supervisedpersonnumber = caseSupervisorperson.Count();//被监管人数 |
|
return ResultOutput.Ok(new { total, typenotused, superviseNumber, Supervisedpersonnumber }); |
|
} |
|
|
|
/// <summary> |
|
/// 案件类型统计 |
|
/// </summary> |
|
/// <param name="input"></param> |
|
/// <returns></returns> |
|
[HttpPost] |
|
public async Task<IResultOutput> casetypeStatistics() |
|
{ |
|
var diclist = new List<dynamic>(); |
|
//获取当前用户能看到的数据Id |
|
var caseIds = await (await base.GetCurrentUserCaseListAsync()).Select(w => w.AppCaseManagement.Id).ToListAsync(); |
|
//获取案件信息 |
|
var express = await _appCaseManagementRepository.AsQueryable(false, true).Where(q => caseIds.Contains(q.Id)).ToListAsync(); |
|
var otherexpress = express; |
|
//var total = express.Count();//获取案件总数 |
|
//案件类型分组获取数量最多前10个 其余得为其他分组 |
|
var expresstype = express.GroupBy(q => q.CaseTypeId).OrderByDescending(q => q.Count()).Take(5).ToList(); |
|
foreach (var item in expresstype) |
|
{ |
|
//计算百分比 |
|
//double number = (Convert.ToDouble(item.ToList().Count()) / Convert.ToDouble(total)) * 100; |
|
double number = item.ToList().Count(); |
|
//通过id获取字典信息 |
|
var dataDict = await _appDictionaryService.GetDicByDicId(item.Key); |
|
diclist.Add(new { name = dataDict?.Name, value = Convert.ToInt32(number) }); |
|
otherexpress = otherexpress.Where(q => q.CaseTypeId != item.Key).ToList(); |
|
} |
|
//类型大于10 |
|
if (expresstype.Count() > 5) |
|
diclist.Add(new { name = "其他", value = otherexpress.Count() }); |
|
//diclist.Add(new { name = "其他", value = Convert.ToInt32(Convert.ToDouble((otherexpress.Count() / total) * 100)) }); |
|
return ResultOutput.Ok(diclist); |
|
} |
|
|
|
/// <summary> |
|
/// 非羁押人员流向统计 |
|
/// </summary> |
|
/// <param name="input"></param> |
|
/// <returns></returns> |
|
[HttpPost] |
|
public async Task<IResultOutput> flowtoStatistics() |
|
{ |
|
//定义当前年开始时间结束时间 |
|
var st = $"{DateTime.Now.ToString("yyyy-MM")}-01".ToDateTime().AddMonths(-5); |
|
var et = $"{DateTime.Now.ToString("yyyy-MM")}-{DateTime.DaysInMonth(DateTime.Now.Year, DateTime.Now.Month)}".ToDateTime(); |
|
//获取当前用户能看到的数据 |
|
var caseIds = await (await base.GetCurrentUserCaseListAsync()).Select(w => w.AppCaseManagement.Id).ToListAsync(); |
|
//获取当前年案件信息及案件被监管人----已通过审核的被监管人 |
|
var datalist = await (from a in _appCaseManagementRepository.AsQueryable(false, true).Where(q => q.CreatedTime >= st && q.CreatedTime <= et && caseIds.Contains(q.Id)) |
|
join b in _appSupervisedPersonRepository.AsQueryable(false, true) |
|
.Where(w => w.ApprovalStatus == ApprovalStatusEnum.PassReview) on a.Id equals b.CaseId |
|
select new { ajid = a.Id, a.CreatedTime, a.CaseProgress, b.Id }).ToListAsync(); |
|
|
|
//获取每月非羁押人员数及释放人员数 |
|
var list = datalist.GroupBy(q => $"{q.CreatedTime}".ToDateTime().ToString("MM")).Select(q => new |
|
{ |
|
timestr = q.Key, |
|
fjynumber = q.ToList().Where(q => q.CaseProgress == CaseProgressEnum.Closed).Count(), |
|
sfnumber = q.ToList().Where(q => q.CaseProgress != CaseProgressEnum.Pending && q.CaseProgress != CaseProgressEnum.Closed).Count(), |
|
}).ToList(); |
|
string YearMonth = "", fjynumber = "", sfnumber = ""; |
|
for (int i = 0; i < 6; i++) |
|
{ |
|
var time = st.AddMonths(i); |
|
var data = list.Where(q => q.timestr == $"{time.ToString("MM")}").FirstOrDefault(); |
|
YearMonth += $"{time.Year}/{time.Month},"; |
|
if (data != null) |
|
{ |
|
fjynumber += $"{data.fjynumber},"; |
|
sfnumber += $"{data.sfnumber},"; |
|
} |
|
else |
|
{ |
|
fjynumber += $"0,"; |
|
sfnumber += $"0,"; |
|
} |
|
} |
|
return ResultOutput.Ok(new { YearMonth = YearMonth.Trim(',').Split(","), fjynumber = fjynumber.Trim(',').Split(","), sfnumber = sfnumber.Trim(',').Split(",") }); |
|
} |
|
|
|
/// <summary> |
|
/// 根据案件Id查询被监管人员信息 |
|
/// </summary> |
|
/// <param name="input"></param> |
|
/// <returns></returns> |
|
[HttpPost] |
|
public async Task<IResultOutput> GetSupervisedPersonPageAsync(GetSupervisedPersonPage input) |
|
{ |
|
var data = await _appSupervisedPersonRepository.AsQueryable(false, true) |
|
.Where(w => w.CaseId == input.Id) |
|
.OrderBy(r => r.Id) |
|
.ProjectTo<AppSupervisedPersonGetDto>(Mapper.ConfigurationProvider) |
|
.PagedAsync(input) |
|
.ConfigureAwait(false); |
|
|
|
return ResultOutput.Ok(data); |
|
} |
|
/// <summary> |
|
/// 根据案件Id查询监管人员信息 |
|
/// </summary> |
|
/// <param name="input"></param> |
|
/// <returns></returns> |
|
[HttpPost] |
|
public async Task<List<GetSupervisorListDto>> GetSupervisedPageAsync(GetSuperviseorPage input) |
|
{ |
|
var data = await _appCaseSupervisorRepository.AsQueryable(false, true) |
|
.Where(w => input.Ids.Contains(w.CaseId)) |
|
.ProjectTo<GetSupervisorListDto>(Mapper.ConfigurationProvider) |
|
.ToListAsync() |
|
.ConfigureAwait(false); |
|
return data; |
|
} |
|
|
|
/// <summary> |
|
/// 获取案件批注内容列表 |
|
/// </summary> |
|
/// <param name="id"></param> |
|
/// <returns></returns> |
|
public async Task<IResultOutput> GetCaseNotes(long id) => await base.GetListAsync<AppCaseNotes, AppCaseNotesListOut, long>(_appCaseNotesRepository, w => w.CaseId == id); |
|
|
|
/// <summary> |
|
/// 添加案件重要节点批注 |
|
/// </summary> |
|
/// <param name="input"></param> |
|
/// <returns></returns> |
|
public async Task<IResultOutput> AddCaseNotes(AddCaseNotesInput input) |
|
{ |
|
if (input.CaseId == default || !input.Notes.NotNull()) return ResultOutput.Ok("参数错误!"); |
|
|
|
await _appCaseNotesRepository.InsertAsync(new AppCaseNotes(YitIdHelper.NextId()) |
|
{ |
|
CaseId = input.CaseId, |
|
Notes = input.Notes |
|
}); |
|
|
|
return ResultOutput.Ok(); |
|
} |
|
|
|
/// <summary> |
|
/// 批量处理案子进度 |
|
/// </summary> |
|
/// <param name="input"></param> |
|
/// <returns></returns> |
|
public async Task<IResultOutput> BatchHandleCaseProgress(BatchHandleCaseProgressInput input) |
|
{ |
|
if (!input.Ids.Any()) return ResultOutput.NotOk("参数错误!"); |
|
|
|
var dataList = await _appCaseManagementRepository.Where(w => input.Ids.Contains(w.Id)) |
|
.ToListAsync(); |
|
|
|
if (!dataList.Any()) return ResultOutput.NotOk("数据为空!"); |
|
|
|
//没有开始的案件不能执行结束 |
|
if (input.CaseProgress == CaseProgressEnum.Closed && dataList.Exists(w => w.CaseProgress == CaseProgressEnum.Pending)) return ResultOutput.NotOk("待执行的案件不能结束"); |
|
|
|
dataList.ForEach(item => |
|
{ |
|
item.CaseProgress = input.CaseProgress; |
|
//案子结束时间 |
|
item.CaseClosedTime = input.CaseProgress == CaseProgressEnum.Closed ? DateTime.Now : null; |
|
}); |
|
|
|
await _appCaseManagementRepository.UpdateAsync(dataList); |
|
|
|
return ResultOutput.Ok(); |
|
} |
|
|
|
/// <summary> |
|
/// 创建或者添加 案子 |
|
/// </summary> |
|
/// <param name="input"></param> |
|
/// <returns></returns> |
|
/// <remarks> |
|
/// ###### 入参示例 |
|
/// { |
|
/// "id": 0, |
|
/// "name": "moshang4", |
|
/// "caseTypeId": 297606176055365, |
|
/// "judgmentStatusId": 297606175068229, |
|
/// "proximityLevel": 11, |
|
/// "restBeginTime": "16:07", |
|
/// "restEndTime": "02:07", |
|
/// "checkInFrequency": 2, |
|
/// "supervisorIds": [ |
|
/// { |
|
/// "supervisedId": 303362251345989, |
|
/// "supervisedName": "moshang2" |
|
/// } |
|
/// ], |
|
/// "supervisedPersonGetDtos": [ |
|
/// { |
|
/// "id": 0, |
|
/// "supervisedPersonId": 297606179328069, |
|
/// "supervisedPersonName": "moshang", |
|
/// "caseId": 0, |
|
/// "approvalStatus": 0, |
|
/// "isBound": true, |
|
/// "name": "moshang", |
|
/// "warningGradeId": 0, |
|
/// "idCard": "511502198912311256", |
|
/// "phone": "18980975824", |
|
/// "electricFenceId": 303366664052805, |
|
/// "electricFenceName": "常用围栏1", |
|
/// "privacyLevel": 11, |
|
/// "enterFace": "", |
|
/// "imei": "" |
|
/// } |
|
/// ] |
|
/// } |
|
/// </remarks> |
|
public async Task<IResultOutput> CreateOrModify(AppCaseManagementCreateOrModifyInput input) |
|
{ |
|
/* |
|
1、案件添加和编辑被监管人不做用户表数据重复验证，包括身份证和手机号 |
|
2、添加和修改时候，只通过身份证去查询用户表数据 如果存在，则获取被监管人id，如果不存在则新增后返回id, |
|
3、如果身份证存在用户表，直接强行修改用户姓名和手机号 |
|
4、案件执行和待执行的校验值通过身份证进行判断，如果该身份证存在待执行或执行中的 提示 xxxxxx身份证存在待执行或执行中的案件，注意已删除的不需要判断 |
|
*/ |
|
|
|
if (input.SupervisedPersonGetDtos == null || !input.SupervisedPersonGetDtos.Any()) return ResultOutput.Ok("每个案件至少需要一个被监管人!"); |
|
|
|
//if (input.RestBeginTime == input.RestEndTime) return ResultOutput.NotOk("休息结束时间必须大于开算时间"); |
|
|
|
#region Valid |
|
|
|
//校验案子 |
|
var caseValid = await base.Valid<AppCaseManagement, AppCaseManagementCreateOrModifyInput, long>(input, _appCaseManagementRepository, w => |
|
{ |
|
w = w.AndNotNull(w => w.Bmsah == input.Bmsah, input.Bmsah.IsNotNullOrEmpty()); |
|
|
|
return (w, $"当前部门受案号：{input.Bmsah}已存在"); |
|
}); |
|
if (!caseValid.Success) return caseValid; |
|
|
|
//校验案件被监管人 |
|
var validSpCase = await ValidSupervisedPerson(input); |
|
if (!validSpCase.Success) return validSpCase; |
|
|
|
#endregion Valid |
|
|
|
var caseId = input.Id; |
|
|
|
Uow.BeginTransaction(); |
|
|
|
//修改 |
|
if (input.Id > 0) |
|
{ |
|
var data = _appCaseManagementRepository.AsQueryable().Where(q => q.Id == input.Id).FirstOrDefault(); |
|
input.CaseProgress = data?.CaseProgress; |
|
await base.UpdateAsync(input, _appCaseManagementRepository); |
|
} |
|
else |
|
{ |
|
var entity = Mapper.Map<AppCaseManagement>(input); |
|
caseId = (await _appCaseManagementRepository.InsertAsync(entity)).Id; |
|
} |
|
|
|
//案子监管管理人员(Bug:当我修改监管人后，已审核过的被监管人需要重新申请，被切换的监管人没有对应数据) |
|
if (input.SupervisorIds!.Any()) |
|
{ |
|
var sList = input.SupervisorIds!.Select(csp => new AppCaseSupervisor(YitIdHelper.NextId()) |
|
{ |
|
CaseId = caseId.Value, |
|
SupervisorId = csp.SupervisedId, |
|
SupervisorName = csp.SupervisedName |
|
}); |
|
var dels = new List<long>(); |
|
var list = await _appCaseSupervisorRepository.AsQueryable(false, true).Where(w => w.CaseId == caseId).ToListAsync(); |
|
foreach (var item in sList) |
|
{ |
|
if (list.Count > 0) |
|
{ |
|
var data = list.First(q => q.SupervisorId == item.SupervisorId); |
|
if (data != null) |
|
{ |
|
//排除不需要删除的被监管人 |
|
list = list.Where(q => q.SupervisorId != item.SupervisorId).ToList(); |
|
//排除已存在的监管人 |
|
sList = sList.Where(q => q.SupervisorId != item.SupervisorId); |
|
} |
|
} |
|
} |
|
//需要删除的监管人 |
|
var SupervisorIds = list.Select(q => q.SupervisorId); |
|
//删除的监管人 |
|
await _appCaseSupervisorRepository.DeleteAsync(w => w.CaseId == caseId && SupervisorIds.Contains(w.SupervisorId)); |
|
//新增监管人 |
|
await _appCaseSupervisorRepository.InsertAsync(sList); |
|
} |
|
|
|
//案子-被监管人员 |
|
if (input.SupervisedPersonGetDtos!.Any()) |
|
{ |
|
//不存在的被监管人 |
|
var roles = (await _roleService.GetRoleByKeyword("supervisedPerson")).FirstOrDefault(); |
|
|
|
//被监管人职位字典 |
|
var supervisedPersonPosition = await base.GetDictionariesOutput("job_position", "supervisedperson"); |
|
|
|
//被监管人员 |
|
var supervisedPersonList = Mapper.Map<List<AppSupervisedPersonGetDto>, List<AppCaseSupervisedPerson>>(input.SupervisedPersonGetDtos); |
|
supervisedPersonList.ForEach(item => |
|
{ |
|
if (item.Id == null) |
|
item.Id = YitIdHelper.NextId(); |
|
item.CaseId = caseId!.Value; |
|
}); |
|
|
|
#region [1]如果用户不存在就添加到用户表中(根据身份证来判断) |
|
|
|
List<SupervisedPersonAddInput> addUsers = new(); |
|
List<SupervisedPersonUpdateInput> updateAppUsers = new(); |
|
|
|
foreach (var item in supervisedPersonList) |
|
{ |
|
var tempUser = await _appUserRepository.FindAsync(w => w.IdCard == item.IdCard); |
|
|
|
//存在就修改名字和手机号 |
|
if (tempUser != null) |
|
{ |
|
tempUser.UserName = tempUser.Name = item.SupervisedPersonName; |
|
tempUser.Phone = item.Phone; |
|
updateAppUsers.Add(new SupervisedPersonUpdateInput() |
|
{ |
|
UserName = item.SupervisedPersonName, |
|
Name = item.SupervisedPersonName, |
|
Phone = tempUser.Phone, |
|
IdCard = item.IdCard, |
|
Id = tempUser.Id |
|
}); |
|
} |
|
else |
|
{ |
|
addUsers.Add(new SupervisedPersonAddInput() |
|
{ |
|
UserName = item.SupervisedPersonName, |
|
Name = item.SupervisedPersonName, |
|
Password = "Mr@123456", |
|
Phone = item.Phone, |
|
RoleIds = new[] { roles!.Id }, |
|
DataStatus = DataStatusEnum.Normal, |
|
PositionId = supervisedPersonPosition?.Id, |
|
PositionName = supervisedPersonPosition?.Name, |
|
RoleName = roles.Name, |
|
IdCard = item.IdCard, |
|
Id = YitIdHelper.NextId() |
|
}); |
|
} |
|
} |
|
if (addUsers.Any()) await _userService.BatchAddAsync(addUsers); |
|
if (updateAppUsers.Any()) await _userService.BatchUpdateAsync(updateAppUsers); |
|
|
|
var userIds = addUsers.Select(w => w.Id).Union(updateAppUsers.Select(w => w.Id)).Distinct(); |
|
|
|
//所有用户 |
|
var allUsers = await _appUserRepository.Where(w => userIds.Contains(w.Id)).ToListAsync(); |
|
|
|
foreach (var person in supervisedPersonList) |
|
{ |
|
//根据身份证号来确定唯一 |
|
var tempUser = allUsers.FirstOrDefault(w => w.IdCard == person.IdCard); |
|
if (tempUser == null) |
|
tempUser = await _appUserRepository.FindAsync(w => w.IdCard == person.IdCard); |
|
if (tempUser == null) continue; |
|
person.SupervisedPersonId = tempUser.Id; |
|
person.SupervisedPersonName = tempUser.UserName; |
|
person.Phone = tempUser.Phone; |
|
} |
|
|
|
#endregion [1]如果用户不存在就添加到用户表中(根据身份证来判断) |
|
|
|
#region 被监管人电子围栏 |
|
|
|
{ |
|
var spIds = supervisedPersonList |
|
.Where(w => w.ElectricFenceId == 0) |
|
.Select(w => w.SupervisedPersonId) |
|
.ToList(); |
|
|
|
//只有是设置得才添加 |
|
if (spIds.Any()) |
|
{ |
|
//先删除 |
|
await _appCommonFenceRepository.DeleteAsync(w => |
|
w.CaseId == caseId && w.CommonFenceType == CommonFenceTypeEnum.SupervisedPerson && |
|
spIds.Contains(w.SupervisedPersonId.Value)); |
|
|
|
var adCfList = input.SupervisedPersonGetDtos |
|
.Select(w => new AppCommonFence(YitIdHelper.NextId()) |
|
{ |
|
CaseId = caseId, |
|
SupervisedPersonId = w.SupervisedPersonId, |
|
SupervisedPersonName = w.SupervisedPersonName, |
|
CommonFenceType = CommonFenceTypeEnum.SupervisedPerson, |
|
Name = w.CommonFenceAddInput?.Name, |
|
Path = w.CommonFenceAddInput?.Path |
|
}); |
|
|
|
if (adCfList.Any()) |
|
{ |
|
var addedCfList = await _appCommonFenceRepository.InsertAsync(adCfList); |
|
|
|
foreach (var item in supervisedPersonList) |
|
{ |
|
var tempCommonFence = addedCfList.FirstOrDefault(w => |
|
w.CaseId == caseId && |
|
w.CommonFenceType == CommonFenceTypeEnum.SupervisedPerson && |
|
w.SupervisedPersonId == item.SupervisedPersonId); |
|
|
|
//说明是常用围栏 |
|
if (tempCommonFence == null) continue; |
|
|
|
item.ElectricFenceId = tempCommonFence?.Id; |
|
item.ElectricFenceName = tempCommonFence?.Name; |
|
} |
|
} |
|
} |
|
} |
|
|
|
#endregion 被监管人电子围栏 |
|
|
|
//案子被监管人中间表 |
|
var sprIds = supervisedPersonList.Select(w => w.SupervisedPersonId).ToList(); |
|
//当前案件所有已经存在的被监管人 |
|
var sprList = await _appSupervisedPersonRepository.AsQueryable(false, true) |
|
.Where(w => w.CaseId == caseId && sprIds.Contains(w.SupervisedPersonId)).ToListAsync(); |
|
|
|
//await _appSupervisedPersonRepository.DeleteAsync(w => w.CaseId == caseId); |
|
|
|
var addsupervisedPerson = new List<AppCaseSupervisedPerson>(); |
|
var UpdatesupervisedPerson = new List<AppCaseSupervisedPerson>(); |
|
//防止漏网之鱼 |
|
foreach (var person in supervisedPersonList) |
|
{ |
|
if (person.SupervisedPersonId == default) |
|
{ |
|
var temUser = allUsers.FirstOrDefault(w => w.IdCard == person.IdCard); |
|
if (temUser == null) continue; |
|
person.SupervisedPersonId = temUser!.Id; |
|
person.SupervisedPersonName = temUser.UserName; |
|
} |
|
else |
|
{ |
|
var tempSp = sprList.FirstOrDefault(w => w.IdCard == person.IdCard); |
|
if (tempSp == null) |
|
{ |
|
addsupervisedPerson.Add(person); |
|
continue; |
|
} |
|
//把已经存在的数据全部赋值上(案件只能修改名字、身份证、手机号) |
|
person.ApprovalStatus = tempSp!.ApprovalStatus; |
|
person.IsBound = tempSp.IsBound; |
|
person.WarningGradeId = tempSp.WarningGradeId; |
|
person.EnterFace = tempSp.EnterFace; |
|
person.IMEI = tempSp.IMEI; |
|
UpdatesupervisedPerson.Add(person); |
|
} |
|
} |
|
await _appSupervisedPersonRepository.UpdateAsync(UpdatesupervisedPerson); |
|
await _appSupervisedPersonRepository.InsertAsync(addsupervisedPerson); |
|
} |
|
|
|
#region 打卡消息推送手机通知栏 |
|
if (input.Id == 0) |
|
{ |
|
var cidslist = new List<string>(); |
|
//通过新案件id获取监管人 |
|
var CaseSupervisorlist = await _appCaseSupervisorRepository.AsQueryable(false, true).Where(q => q.CaseId == caseId).ToListAsync(); |
|
//监管人ids |
|
var SupervisedIds = new List<long>(); |
|
CaseSupervisorlist.ForEach(q => |
|
{ |
|
SupervisedIds.Add(q.SupervisorId); |
|
}); |
|
//获取监管人手机唯一id |
|
var supervisecids = _appuserRepository.AsQueryable(false, true).ToList().Where(q => SupervisedIds.Contains(q.Id) && !string.IsNullOrEmpty(q.CId)); |
|
supervisecids.Where(q => !string.IsNullOrEmpty(q.CId)).ForEach(q => |
|
{ |
|
cidslist.Add($"{q.CId}"); |
|
}); |
|
//所有管理员 |
|
var adminList = await _userService.GetAllAdminUserIds(); |
|
adminList.Where(q => !string.IsNullOrEmpty(q.CId)).ForEach(q => |
|
{ |
|
cidslist.Add($"{q.CId}"); |
|
}); |
|
if (cidslist.Count() > 0) |
|
{ |
|
try |
|
{ |
|
//获取个推配置 |
|
var TweetConfig = LazyGetRequiredService<TweetsConfigConfiguration>(); |
|
//查询判断token是否存在 存在直接获取 不存在通过接口重新获取token |
|
var token = Cache.Exists("token"); |
|
if (!token) |
|
base.GettoekenQuery(); |
|
var tokenstr = Cache.Get("token"); |
|
var msg_list = new List<dynamic>(); |
|
foreach (var item in cidslist.Distinct()) |
|
{ |
|
//随机生成数 |
|
var request_id = Guid.NewGuid().ToString().Replace("-", "").Substring(0, 32).ToString(); |
|
msg_list.Add(new |
|
{ |
|
request_id = request_id, |
|
settings = new { ttl = 7200000 }, |
|
audience = new { cid = item.ToString().Split(",") }, |
|
push_message = new |
|
{ |
|
notification = new |
|
{ |
|
title = "非羁押", |
|
body = $"有新案件录入！", |
|
click_type = "none", |
|
} |
|
} |
|
}); |
|
} |
|
|
|
var data = new |
|
{ |
|
is_async = true, |
|
msg_list = msg_list |
|
}; |
|
//打卡消息推送被监管人手机通知栏 |
|
var re = base.GetpostQuery($"{TweetConfig.BaseUrl.Replace("$appId", TweetConfig.AppID)}{TweetConfig.cidurl}", data, tokenstr); |
|
} |
|
catch (Exception) |
|
{ |
|
} |
|
} |
|
} |
|
#endregion |
|
|
|
await Uow.CommitAsync(); |
|
|
|
//返回结果 |
|
return ResultOutput.Ok(); |
|
} |
|
|
|
/// <summary> |
|
/// 新增案子监管人 |
|
/// </summary> |
|
/// <param name="input"></param> |
|
/// <returns></returns> |
|
public async Task<IResultOutput> addCreateOrModify(AppCaseManagementCreateOrModifyInput input) |
|
{ |
|
var caseId = input.Id; |
|
var data = await _appCaseManagementRepository.AsQueryable(false, true).FirstAsync(q => q.Id == caseId); |
|
if (data != null) |
|
{ |
|
Uow.BeginTransaction(); |
|
//当案件移交后添加监管人和修改案件状态 |
|
if (input.SupervisorIds!.Any()) |
|
{ |
|
var sList = input.SupervisorIds!.Select(csp => new AppCaseSupervisor(YitIdHelper.NextId()) |
|
{ |
|
CaseId = caseId.Value, |
|
SupervisorId = csp.SupervisedId, |
|
SupervisorName = csp.SupervisedName |
|
}); |
|
|
|
var Supervisordata = await _appCaseSupervisorRepository.FindAsync(q => q.CaseId == caseId && sList.Select(q => q.SupervisorId).Contains(q.SupervisorId)); |
|
//if (Supervisordata != null) |
|
//{ |
|
// return ResultOutput.NotOk("已是监管人，请选择其他监管人"); |
|
//} |
|
if (Supervisordata == null) |
|
await _appCaseSupervisorRepository.InsertAsync(sList); |
|
} |
|
data.CaseProgress = (CaseProgressEnum)input.CaseProgress; |
|
await _appCaseManagementRepository.UpdateAsync(data, UpdatingProps<AppCaseManagement>(x => x.CaseProgress)!); |
|
await Uow.CommitAsync(); |
|
} |
|
|
|
//返回结果 |
|
return ResultOutput.Ok(); |
|
} |
|
|
|
/// <summary> |
|
/// 批量删除案子 |
|
/// </summary> |
|
/// <param name="input"></param> |
|
/// <returns></returns> |
|
[HttpDelete] |
|
public async Task<IResultOutput> BatchDelete(BatchIdsInput input) |
|
{ |
|
Uow.BeginTransaction(); |
|
{ |
|
//删除案子主表 |
|
await _appCaseManagementRepository.DeleteAsync(w => input.Ids.Contains(w.Id)); |
|
|
|
//删除案子监管人员表数据 |
|
await _appCaseSupervisorRepository.DeleteAsync(w => input.Ids.Contains(w.CaseId)); |
|
|
|
//删除案子被监管人员 |
|
await _appSupervisedPersonRepository.DeleteAsync(w => input.Ids.Contains(w.CaseId)); |
|
|
|
//删除案子的评论 |
|
await _appCaseNotesRepository.DeleteAsync(w => input.Ids.Contains(w.CaseId)); |
|
} |
|
await Uow.CommitAsync(); |
|
return ResultOutput.Ok(); |
|
} |
|
|
|
/// <summary> |
|
/// 删除案子中被监管人员 |
|
/// </summary> |
|
/// <param name="input"></param> |
|
/// <returns></returns> |
|
[HttpDelete] |
|
public async Task<IResultOutput> DeleteAsync(DeleteCaseSupervisedPersonInput input) |
|
{ |
|
if (await _appSupervisedPersonRepository.CountAsync(w => w.CaseId == input.CaseId) <= 1) |
|
return ResultOutput.NotOk("每一个案件至少存在一个被监管人!"); |
|
|
|
await _appSupervisedPersonRepository.DeleteAsync(w => |
|
w.CaseId == input.CaseId && |
|
w.SupervisedPersonId == input.SupervisedPersonId); |
|
|
|
return ResultOutput.Ok(); |
|
} |
|
|
|
/// <summary> |
|
/// 办案时长统计(办案时长允许0.5天的这样形式当前 显示为0天) |
|
/// </summary> |
|
/// <param name="input"></param> |
|
/// <returns></returns> |
|
public async Task<IResultOutput> CaseStatisticsHandlingTime(CaseStatisticsHandlingTimePageInput input) |
|
{ |
|
var query = _appCaseManagementRepository |
|
.AsQueryable(false, true) |
|
.Where(w => w.CaseProgress == CaseProgressEnum.Closed) |
|
.WhereIf(input.KeyWord.NotNull(), a => a.Name.Contains(input.KeyWord)) |
|
.WhereIf(input.TimeSearch.BeginTime.Length == 2, w => w.CaseBeginTime > input.TimeSearch.BeginTime[0] && w.CaseBeginTime < input.TimeSearch.BeginTime[1].AddDays(1)) |
|
.WhereIf(input.TimeSearch.EndTime.Length == 2, w => w.CaseClosedTime > input.TimeSearch.EndTime[0] && w.CaseClosedTime <= input.TimeSearch.EndTime[1].AddDays(1)); |
|
|
|
var pageData = await |
|
query.ProjectTo<CaseStatisticsHandlingTimeListDto>(Mapper.ConfigurationProvider) |
|
.PagedAsync(input) |
|
.ConfigureAwait(false); |
|
|
|
var caseIds = pageData.Data.Select(w => w.Id); |
|
|
|
//涉事人员（被监管人员） |
|
var personInvolvedList = await _appSupervisedPersonRepository |
|
.AsQueryable(false, true) |
|
.Where(w => caseIds.Contains(w.CaseId)) |
|
.ToListAsync(); |
|
|
|
//处理时长和涉事人员 |
|
foreach (var person in pageData.Data) |
|
{ |
|
person.PersonInvolved = personInvolvedList |
|
.Where(w => w.CaseId == person.Id) |
|
.Select(w => w.SupervisedPersonName)! |
|
.JoinAsString(","); |
|
|
|
if (person.CaseBeginTime.HasValue) person.CaseHandlingTime = new TimeSpan(person.CaseClosedTime!.Value.Ticks - person.CaseBeginTime.Value.Ticks).TotalDays.ToString("F1"); |
|
} |
|
|
|
//返回结果 |
|
return ResultOutput.Ok(pageData); |
|
} |
|
|
|
/// <summary> |
|
/// 案件类型统计 |
|
/// </summary> |
|
/// <returns></returns> |
|
public async Task<IResultOutput> CaseTypeStatistics(CaseTypeStatisticsGetPageInput input) |
|
{ |
|
//获取当前用户权限下的案件ids |
|
var limits = User.limits; |
|
var selectLimits = await _appCaseSupervisorRepository.AsQueryable(false, true) |
|
.Where(w => limits.Contains(w.UnitId.ToString())) |
|
.ToListAsync(); |
|
var caseIds = selectLimits.Select(w => w.CaseId).Distinct().ToList(); |
|
|
|
var data = await _appCaseManagementRepository.AsQueryable(false, true) |
|
.WhereIf(input.KeyWord.NotNull(), a => a.Name.Contains(input.KeyWord)) |
|
.WhereIf(input.TimeSearch.BeginTime.Length == 2, w => w.CreatedTime > input.TimeSearch.BeginTime[0] && w.CreatedTime < input.TimeSearch.BeginTime[1].AddDays(1)) |
|
.WhereIf(input.TimeSearch.EndTime.Length == 2, w => w.CaseClosedTime > input.TimeSearch.EndTime[0] && w.CaseClosedTime < input.TimeSearch.EndTime[1].AddDays(1)) |
|
.WhereIf(input.ajtype.NotNull(), w => w.CaseTypeId == input.ajtype.ToLong()).Where(w=> caseIds.Contains(w.Id)) |
|
.ToListAsync(); |
|
|
|
var dataGroup = data.GroupBy(w => w.CaseTypeId); |
|
|
|
var pageData = dataGroup |
|
.OrderBy(w => w.Key) |
|
.Skip((input.PageIndex - 1) * input.PageSize) |
|
.Take(input.PageSize); |
|
|
|
//案件类型Id |
|
var caseTypeIds = pageData |
|
.Select(w => w.Key) |
|
.ToList(); |
|
|
|
var allCaseTypeDics = await _appDictionaryService.GetDicByDicIds(new BatchIdsInput |
|
{ |
|
Ids = caseTypeIds |
|
}); |
|
|
|
//处理配型 |
|
var dataList = pageData.Select(data => new CaseTypeStatisticsListDto() |
|
{ |
|
CaseTypeId = data.Key, |
|
CaseTypeName = allCaseTypeDics.FirstOrDefault(w => w.Id == data.Key)?.Name, |
|
TotalCaseCount = data.Count() |
|
}).ToList(); |
|
|
|
var rtn = new PageOutput<CaseTypeStatisticsListDto>() |
|
{ |
|
Total = dataGroup.Count(), |
|
List = dataList |
|
}; |
|
|
|
//返回结果 |
|
return ResultOutput.Ok(rtn); |
|
} |
|
|
|
/// <summary> |
|
/// 办案频次统计(办案次数是指被监管人申请业务的次数【当前监管人】) |
|
/// </summary> |
|
/// <param name="input"></param> |
|
/// <returns></returns> |
|
public async Task<IResultOutput> CaseHandlingFrequencyStatistics(CaseHandlingFrequencyStatisticsGetPageInput input) |
|
{ |
|
//获取当前用户权限下的案件ids |
|
var limits = User.limits; |
|
var selectLimits = await _appCaseSupervisorRepository.AsQueryable(false, true) |
|
.Where(w => limits.Contains(w.UnitId.ToString())) |
|
.ToListAsync(); |
|
var caseIds = selectLimits.Select(w => w.CaseId).Distinct().ToList(); |
|
//query |
|
var query = await (await base.GetCurrentUserCaseListAsync()) |
|
//.Where(w => w.AppCaseSupervisedPerson != null && w.AppCaseManagement.CaseProgress != CaseProgressEnum.Closed) |
|
.Where(w => w.AppCaseSupervisedPerson != null) |
|
.WhereIf(input.SupervisedPersonName.IsNotNullOrWhiteSpace(), w => w.AppCaseSupervisedPerson.SupervisedPersonName.Contains(input.SupervisedPersonName)) |
|
.Select(w => new CaseHandlingFrequencyStatisticsListDto() |
|
{ |
|
CaseId = w.AppCaseManagement.Id, |
|
Name = w.AppCaseManagement.Name, |
|
SupervisedPersonId = w.AppCaseSupervisedPerson.SupervisedPersonId, |
|
SupervisedPersonName = w.AppCaseSupervisedPerson.SupervisedPersonName |
|
}).ToListAsync(); |
|
|
|
var dataGroup = query.Where(w=> caseIds.Contains(w.CaseId)).GroupBy(w => new |
|
{ |
|
w.CaseId, |
|
w.SupervisedPersonId, |
|
w.Name, |
|
w.SupervisedPersonName |
|
}); |
|
|
|
//pageData |
|
var pageData = dataGroup |
|
.Skip((input.PageIndex - 1) * input.PageSize) |
|
.Take(input.PageSize) |
|
.ToList(); |
|
|
|
//业务申请 |
|
var dataList = new List<CaseHandlingFrequencyStatisticsListDto>(); |
|
|
|
//处理身份证字段 |
|
var userList = await _userService.GetAllByConditionAsync(new BatchIdsInput() |
|
{ |
|
Ids = pageData.Select(w => w.Key.SupervisedPersonId).ToList() |
|
}); |
|
|
|
foreach (var data in pageData) |
|
{ |
|
var chFCount = await _appBusinessApplicationRepository |
|
.AsQueryable(false, true) |
|
.CountAsync(w => w.SupervisedPersonId == data.Key.SupervisedPersonId && w.CaseId == data.Key.CaseId); |
|
|
|
dataList.Add(new CaseHandlingFrequencyStatisticsListDto() |
|
{ |
|
CaseId = data.Key.CaseId, |
|
Name = data.Key.Name, |
|
SupervisedPersonId = data.Key.SupervisedPersonId, |
|
SupervisedPersonName = data.Key.SupervisedPersonName, |
|
HandleCaseCount = chFCount, |
|
IdCard = userList.FirstOrDefault(w => w.Id == data.Key.SupervisedPersonId)?.IdCard |
|
}); |
|
} |
|
|
|
//分页输出 |
|
var rtn = new PageOutput<CaseHandlingFrequencyStatisticsListDto>() |
|
{ |
|
Total = dataGroup.Count(), |
|
List = dataList |
|
}; |
|
|
|
return ResultOutput.Ok(rtn); |
|
} |
|
|
|
/// <summary> |
|
/// 即时通讯管理(当前案件下所有被监管人分组) |
|
/// </summary> |
|
/// <param name="input"></param> |
|
/// <returns></returns> |
|
public async Task<IResultOutput> ImManagement(ImManagementInput input) |
|
{ |
|
var imManagementList = await (from cm in _appCaseManagementRepository.AsQueryable(false, true).Where(w => w.CaseProgress != CaseProgressEnum.Closed) |
|
join csp in _appSupervisedPersonRepository.AsQueryable(false, true) |
|
.WhereIf(input.SupervisedPersonName.NotNull(), w => w.SupervisedPersonName.Contains(input.SupervisedPersonName)) |
|
on cm.Id equals csp.CaseId |
|
select new ImManagementListDto() |
|
{ |
|
CaseId = cm.Id, |
|
CaseName = cm.Name, |
|
SupervisedPersonId = csp.SupervisedPersonId, |
|
SupervisedPersonName = csp.SupervisedPersonName |
|
}).ToListAsync(); |
|
|
|
var spIdList = imManagementList.Select(w => w.SupervisedPersonId).ToList(); |
|
var spList = await _appSupervisedPersonRepository.AsQueryable(false, true) |
|
.Where(w => spIdList.Contains(w.Id)) |
|
.ToListAsync(); |
|
|
|
foreach (var imManagementListDto in imManagementList) |
|
{ |
|
imManagementListDto.Gender = |
|
spList.FirstOrDefault(w => w.Id == imManagementListDto.SupervisedPersonId)!.Gender; |
|
} |
|
|
|
//分组 |
|
var rtn = imManagementList.GroupBy(w => new { w.CaseId, w.CaseName }) |
|
.Select(w => new ImManagementGroupListDto() |
|
{ |
|
Key = w.Key.CaseName + "-" + w.Key.CaseId, |
|
ImList = w.ToList() |
|
}).ToList(); |
|
|
|
//返回 |
|
return ResultOutput.Ok(rtn); |
|
} |
|
|
|
/// <summary> |
|
/// 业务工作台===>即时通讯(取最新5条作为展示) |
|
/// </summary> |
|
/// <returns></returns> |
|
public async Task<IResultOutput> ImBusinessWorkbench() |
|
{ |
|
var caseIds = await (await base.GetCurrentUserCaseListAsync()).Select(w => w.AppCaseManagement.Id).ToListAsync(); |
|
|
|
var imManagementList = await (from cm in _appCaseManagementRepository.AsQueryable(false, true) |
|
.Where(w => w.CaseProgress != CaseProgressEnum.Closed && caseIds.Contains(w.Id)) |
|
join csp in _appSupervisedPersonRepository.AsQueryable(false, true) |
|
on cm.Id equals csp.CaseId |
|
select new ImManagementListDto() |
|
{ |
|
CaseId = cm.Id, |
|
CaseName = cm.Name, |
|
SupervisedPersonId = csp.SupervisedPersonId, |
|
SupervisedPersonName = csp.SupervisedPersonName, |
|
CreatedTime = cm.CreatedTime |
|
}).OrderByDescending(w => w.CreatedTime) |
|
.Skip(0) |
|
.Take(5) |
|
.ToListAsync(); |
|
|
|
return ResultOutput.Ok(imManagementList); |
|
} |
|
|
|
/// <summary> |
|
/// 业务工作台===>查看案件（取最新5条作为展示） |
|
/// </summary> |
|
/// <returns></returns> |
|
public async Task<IResultOutput> CaseBusinessWorkbench() |
|
{ |
|
var dataDict = await _appDictionaryService.GetListNoApiAsync(null); |
|
var caseList = (await (await base.GetCurrentUserCaseListAsync()).ToListAsync()) |
|
.Where(w => w.AppCaseManagement.CaseProgress != CaseProgressEnum.Closed) |
|
.OrderByDescending(w => w.AppCaseSupervisedPerson?.CreatedTime) |
|
.Where(w => w.AppCaseSupervisedPerson != null) |
|
.Skip(0) |
|
.Take(5) |
|
.Select(caseAgg => |
|
{ |
|
return new ImManagementListDto() |
|
{ |
|
CaseId = caseAgg.AppCaseManagement!.Id, |
|
CaseName = caseAgg.AppCaseManagement.Name, |
|
CreatedTime = caseAgg.AppCaseManagement.CreatedTime, |
|
JudgmentStatusId = caseAgg.AppCaseManagement.JudgmentStatusId, |
|
JudgmentStatusName = dataDict |
|
.FirstOrDefault(w => w.Code == "judgment")! |
|
.Dictionaries! |
|
.FirstOrDefault(w => w.Id == caseAgg.AppCaseManagement.JudgmentStatusId)! |
|
.Name, |
|
SupervisedPersonId = caseAgg.AppCaseSupervisedPerson!.SupervisedPersonId, |
|
SupervisedPersonName = caseAgg.AppCaseSupervisedPerson.SupervisedPersonName, |
|
Avatar = caseAgg.AppCaseSupervisedPerson?.EnterFace ?? "/avatar/default.png" |
|
}; |
|
}) |
|
.Distinct((x, y) => x.CaseId == y.CaseId) |
|
.ToList(); |
|
|
|
return ResultOutput.Ok(caseList); |
|
} |
|
|
|
/// <summary> |
|
/// 获取监管人员手里的案子列表 |
|
/// </summary> |
|
/// <param name="input"></param> |
|
/// <returns></returns> |
|
public async Task<IResultOutput> GetSupervisorCaseList(GetSupervisorCaseListInput input) |
|
{ |
|
var dataaggList = await (await base.GetCurrentUserCaseListAsync()) |
|
.Where(w => w.AppCaseManagement.CaseProgress == input.CaseProgress) |
|
.Select(w => new GetSupervisorCaseListDto() |
|
{ |
|
Id = w.AppCaseManagement.Id, |
|
CaseProgress = w.AppCaseManagement.CaseProgress, |
|
Name = w.AppCaseManagement.Name, |
|
//SupervisorId = w.cspr.SupervisorId, |
|
SupervisorName = w.AppCaseSupervisor.SupervisorName, |
|
//UserId = w.csR.UserId, |
|
SupervisedPersonName = w.AppCaseSupervisedPerson.SupervisedPersonName, |
|
SupervisedPersonfile = w.AppCaseSupervisedPerson.EnterFace, |
|
CreatedTime = w.AppCaseManagement.CreatedTime, |
|
CreatedUserId = w.AppCaseManagement.CreatedUserId, |
|
CreatedUserName = w.AppCaseManagement.CreatedUserName |
|
}) |
|
.ToListAsync(); |
|
|
|
var dataGroup = dataaggList.GroupBy(w => new { w.Id }); |
|
|
|
var totalCount = dataGroup.Count(); |
|
|
|
dataGroup = dataGroup |
|
.Skip((input.PageIndex - 1) * input.PageSize) |
|
.Take(input.PageSize) |
|
.ToList(); |
|
|
|
var rtn = (from data in dataGroup |
|
let dataList = data.ToList() |
|
let first = data.FirstOrDefault() |
|
select new GetSupervisorCaseListDto() |
|
{ |
|
Id = first.Id, |
|
CaseProgress = first.CaseProgress, |
|
Name = first.Name, |
|
SupervisorName = dataList.GroupBy(q => q.SupervisorName).Select(w => w.Key).JoinAsString(","), |
|
SupervisedPersonName = dataList.GroupBy(q => q.SupervisedPersonName).Select(w => w.Key)!.JoinAsString(","), |
|
SupervisedPersonfile = dataList.GroupBy(q => q.SupervisedPersonfile).Select(w => w.Key)!.JoinAsString(","), |
|
CreatedTime = first.CreatedTime, |
|
CreatedUserId = first.CreatedUserId, |
|
CreatedUserName = first.CreatedUserName |
|
}).ToList(); |
|
|
|
//返回结果 |
|
return ResultOutput.Ok(new PagedList<GetSupervisorCaseListDto>() |
|
{ |
|
TotalCount = totalCount, |
|
Data = rtn |
|
}); |
|
} |
|
|
|
/// <summary> |
|
/// 获取当前监管人手里的案件(带数据权限) |
|
/// </summary> |
|
/// <returns></returns> |
|
public async Task<List<CaseSuperviseListDto>> GetCaseSuperviseList() |
|
{ |
|
var data = await (await GetCurrentUserCaseListAsync()) |
|
.Where(w => w.AppCaseManagement.CaseProgress != CaseProgressEnum.Closed) |
|
.ToListAsync(); |
|
|
|
var dataGroup = data.GroupBy(w => new |
|
{ |
|
w.AppCaseManagement!.Id, |
|
w.AppCaseManagement.Name |
|
}).Select(data => |
|
{ |
|
var tempData = data.ToList(); |
|
|
|
//监管人 |
|
var superviseDetailDtos = tempData.Select(w => new CaseSuperviseDetailDto() |
|
{ |
|
SupervisedId = w.AppCaseSupervisor.SupervisorId, |
|
SupervisedName = w.AppCaseSupervisor?.SupervisorName, |
|
}).Distinct((x, y) => x.SupervisedId == y.SupervisedId).ToList(); |
|
|
|
//被监管人 |
|
var supervisedPersonDetailDtps = tempData.Where(w => w.AppCaseSupervisedPerson != null).Select(w => new CaseSupervisedPersonDetailDto |
|
{ |
|
SupervisedPersonId = w.AppCaseSupervisedPerson.SupervisedPersonId, |
|
SupervisedPersonName = w.AppCaseSupervisedPerson?.SupervisedPersonName, |
|
}).Distinct((x, y) => x.SupervisedPersonId == y.SupervisedPersonId).ToList(); |
|
|
|
return new CaseSuperviseListDto() |
|
{ |
|
CaseId = data.Key.Id, |
|
CaseName = data.Key.Name, |
|
SuperviseDetailDtos = superviseDetailDtos, |
|
SupervisedPersonDetailDtps = supervisedPersonDetailDtps |
|
}; |
|
}).ToList(); |
|
|
|
return dataGroup; |
|
} |
|
|
|
/// <summary> |
|
/// 根据被监管人Id获取相关信息(案件、监管人信息) |
|
/// </summary> |
|
/// <param name="id"></param> |
|
/// <returns></returns> |
|
public async Task<SupervisedPersonInfoDto> GetSupervisedPersonInfoById(long id) |
|
{ |
|
var rtn = new SupervisedPersonInfoDto(); |
|
|
|
var data = await (await GetCurrentUserCaseListAsync()) |
|
.Where(w => w.AppCaseManagement.CaseProgress != CaseProgressEnum.Closed) |
|
.ToListAsync(); |
|
|
|
var dataGroup = data.Where(w => w.AppCaseSupervisedPerson != null).GroupBy(w => new |
|
{ |
|
w.AppCaseSupervisedPerson.SupervisedPersonId, |
|
w.AppCaseSupervisedPerson.SupervisedPersonName |
|
}).ToList(); |
|
|
|
rtn.SupervisedPersonId = User.Id; |
|
rtn.SupervisedPersonName = User.Name; |
|
rtn.Phone = User.Phone; |
|
rtn.Avatar = User.Avatar; |
|
rtn.NickName = User.NickName; |
|
|
|
//所有监管人信息 |
|
var spList = await _userService.GetAllByConditionAsync(new BatchIdsInput() |
|
{ |
|
Ids = data.Select(w => w.AppCaseSupervisor.SupervisorId).ToList() |
|
}); |
|
|
|
//循环处理 |
|
dataGroup.ForEach(item => |
|
{ |
|
var tempData = item.ToList(); |
|
//案件信息 |
|
rtn.SpCaseListDtos.AddRange(tempData.Select(w => new SpCaseListDto() |
|
{ |
|
CaseId = w.AppCaseManagement.Id, |
|
CaseName = w.AppCaseManagement.Name |
|
}).ToList()); |
|
|
|
//监管人信息 |
|
rtn.SpCaseSpListDtos.AddRange(tempData.Select(w => new SpCaseSpListDto() |
|
{ |
|
SupervisedId = w.AppCaseSupervisor.SupervisorId, |
|
SupervisedName = w.AppCaseSupervisor.SupervisorName, |
|
Avatar = spList.FirstOrDefault(s => s.Id == w.AppCaseSupervisor.SupervisorId)?.Avatar, |
|
NickName = spList.FirstOrDefault(s => s.Id == w.AppCaseSupervisor.SupervisorId)?.NickName, |
|
Phone = spList.FirstOrDefault(s => s.Id == w.AppCaseSupervisor.SupervisorId)?.Phone, |
|
}).ToList()); |
|
}); |
|
|
|
//返回结果 |
|
return rtn; |
|
} |
|
|
|
/// <summary> |
|
/// 根据当前用户Id(被监管人)获取【监管人】列表 |
|
/// </summary> |
|
/// <param name="userId"></param> |
|
/// <returns></returns> |
|
public async Task<List<GetSuperviseListByIdOutput>> GetSuperviseListByUserId(long userId) => await base.GetSuperviseListByUserId(new EditableList<long>() |
|
{ |
|
userId |
|
}); |
|
|
|
/// <summary> |
|
/// 根据当前登录的用户获取【被监管人】列表 （监控大屏被监管人列表）只查询有经纬度且案件没有结束的人且没有被删除的人 |
|
/// </summary> |
|
/// <returns></returns> |
|
public async Task<IResultOutput> GetSupervisedPersonListByCurrentUser() |
|
{ |
|
var superviseList = await (await base.GetCurrentUserCaseListAsync()) |
|
.Where(w => w.AppCaseManagement.CaseProgress != CaseProgressEnum.Closed) |
|
.Select(w => new SupervisedPersonByUserOutput() |
|
{ |
|
SupervisedPersonId = w.AppCaseSupervisedPerson!.SupervisedPersonId, |
|
SupervisedPersonName = w.AppCaseSupervisedPerson.SupervisedPersonName, |
|
CaseId = w.AppCaseManagement!.Id, |
|
CaseName = w.AppCaseManagement.Name, |
|
Gender = w.AppCaseSupervisedPerson.Gender |
|
}).ToListAsync(); |
|
|
|
//返回列表 |
|
return ResultOutput.Ok(superviseList); |
|
} |
|
|
|
/// <summary> |
|
/// 获取所有案件没有结束的被监管人列表() |
|
/// </summary> |
|
/// <returns></returns> |
|
/// <remarks> |
|
/// 1、被监管人输入身份证 绑定当前案件 （待执行或执行中）的被监管人数据 |
|
/// 2、同一个被监管人 只能绑定同一个设备的1次 |
|
/// </remarks> |
|
public async Task<IResultOutput> GetSupervisedPersonList() |
|
{ |
|
var rtn = await (from c in _appCaseManagementRepository.AsQueryable(false, true) |
|
join spr in _appSupervisedPersonRepository.AsQueryable(false, true) on c.Id equals spr.CaseId |
|
//join device in _appDeviceManagementRepository.AsQueryable(false, true) on spr.SupervisedPersonId equals device.SupervisedPersonId into td |
|
//from d in td.DefaultIfEmpty() |
|
//where c.CaseProgress != CaseProgressEnum.Closed && spr.IdCard != null && d == null |
|
where c.CaseProgress != CaseProgressEnum.Closed && spr.IdCard != null |
|
select new SupervisedPersonDto() |
|
{ |
|
SupervisedPersonId = spr.SupervisedPersonId, |
|
SupervisedPersonName = spr.SupervisedPersonName, |
|
CaseId = c.Id, |
|
IdCard = spr.IdCard |
|
}).ToListAsync(); |
|
|
|
//去重 |
|
rtn = rtn.Distinct((x, y) => x.SupervisedPersonId == y.SupervisedPersonId).ToList(); |
|
|
|
return ResultOutput.Ok(rtn); |
|
} |
|
|
|
/// <summary> |
|
/// 根据当前登录的被监管人员获取其正在进行的案件信息 |
|
/// </summary> |
|
/// <returns></returns> |
|
public async Task<GetCaseInfoBySupervisedPersonIdOutput?> GetCaseInfoBySupervisedPersonId(long? userId = null) => await base.GetCaseInfoBySupervisedPersonId(userId); |
|
|
|
/// <summary> |
|
/// 查看当前案件是否还存在待提交或待审核的被监管人员 |
|
/// </summary> |
|
/// <param name="caseId">案件Id</param> |
|
/// <returns></returns> |
|
public async Task<IResultOutput<bool>> IsExistSupervisedPersonCase(long caseId) |
|
{ |
|
var caseDetail = GetCaseSupervisedPersonQuery() |
|
.Where(w => |
|
w.AppCaseManagement.Id == caseId && |
|
w.AppCaseSupervisedPerson.ApprovalStatus != ApprovalStatusEnum.PassReview); |
|
|
|
return (IResultOutput<bool>)ResultOutput.Ok(await caseDetail.AnyAsync()); |
|
} |
|
|
|
/// <summary> |
|
/// 一个被监管人待审核状态的列表 用于前端直接点击查看 |
|
/// </summary> |
|
/// <param name="input"></param> |
|
/// <returns></returns> |
|
[HttpPost] |
|
public async Task<IResultOutput<PagedList<GetSupervisedPersonApprovalStatusOutput>>> GetSupervisedPersonApprovalStatus(GetSupervisedPersonApprovalStatusPageInput input) |
|
{ |
|
var queryable = (await GetCurrentUserCaseListAsync()) |
|
.WhereIf(input.SupervisedPersonId > 0, w => w.AppCaseSupervisedPerson.SupervisedPersonId == input.SupervisedPersonId) |
|
.WhereIf(input.ApprovalStatus.HasValue, w => w.AppCaseSupervisedPerson.ApprovalStatus == input.ApprovalStatus) |
|
.WhereIf(input.name.NotNull(), w => w.AppCaseSupervisedPerson.SupervisedPersonName.Contains(input.name)); |
|
|
|
var caseSpQueryable = await queryable.Where(q => q.AppCaseSupervisedPerson != null).Select(w => Mapper.Map<AppCaseSupervisedPerson, GetSupervisedPersonApprovalStatusOutput>(w.AppCaseSupervisedPerson)).ToListAsync(); |
|
if ((await base.IsAdmin()).IsAdmin) caseSpQueryable = caseSpQueryable.Distinct((x, y) => x.CaseId == y.CaseId && x.SupervisedPersonId == y.SupervisedPersonId).ToList(); |
|
|
|
var totalCount = caseSpQueryable.Count(); |
|
|
|
var dataList = caseSpQueryable.Skip((input.PageIndex - 1) * input.PageSize).Take(input.PageSize).ToList(); |
|
|
|
dataList.ForEach(item => |
|
{ |
|
item.CaseName = queryable.FirstOrDefault(w => w.AppCaseManagement.Id == item.CaseId)?.AppCaseManagement?.Name; |
|
}); |
|
|
|
return (IResultOutput<PagedList<GetSupervisedPersonApprovalStatusOutput>>)ResultOutput.Ok(new PagedList<GetSupervisedPersonApprovalStatusOutput>() |
|
{ |
|
TotalCount = totalCount, |
|
Data = dataList.OrderByDescending(q => q.CreatedTime).ToList() |
|
}); |
|
} |
|
|
|
/// <summary> |
|
/// 根据当前登录人获取能看到的Id(监管人、管理员) |
|
/// </summary> |
|
/// <returns></returns> |
|
public async Task<List<long>> GetUserIdListByCurrentUser() |
|
{ |
|
var data = await (await base.GetCurrentUserCaseListAsync()).ToListAsync(); |
|
|
|
var userList = new List<long>(); |
|
userList = data.Where(q => q.AppCaseSupervisedPerson != null).Select(w => w.AppCaseSupervisedPerson.SupervisedPersonId) |
|
.Union(data.Select(w => w.AppCaseSupervisor.SupervisorId)) |
|
.Union(new List<long>() { User.Id }) |
|
.Distinct() |
|
.ToList(); |
|
|
|
return userList; |
|
} |
|
|
|
#region Private |
|
|
|
/// <summary> |
|
/// 查询条件 |
|
/// </summary> |
|
/// <param name="pageInput"></param> |
|
/// <param name="query"></param> |
|
/// <returns></returns> |
|
private async Task<IQueryable<AppCaseManagement>> GetExpression(AppCaseManagementGetPageInput pageInput, IQueryable<AppCaseManagement?> query) |
|
{ |
|
var caseIds = await (await base.GetCurrentUserCaseListAsync()).Select(w => w.AppCaseManagement.Id).ToListAsync(); |
|
|
|
query = query |
|
.WhereIf(pageInput.CaseIds.IsNotNullOrEmpty(), w => pageInput.CaseIds.Contains(w.Id)) |
|
.WhereIf(pageInput.CaseName.NotNull(), a => a.Name.Contains(pageInput.CaseName)) |
|
.WhereIf(pageInput.CaseTypeId != null, a => a.CaseTypeId == pageInput.CaseTypeId) |
|
.WhereIf(pageInput.JudgmentStatusIds.IsNotNullOrEmpty(), w => pageInput.JudgmentStatusIds.Contains(w.JudgmentStatusId)) |
|
.WhereIf(pageInput.CaseProgresses.IsNotNullOrEmpty(), w => pageInput.CaseProgresses.Contains(w.CaseProgress)) |
|
.WhereIf(pageInput.TimeSearch != null && pageInput.TimeSearch.BeginTime != null && pageInput.TimeSearch.EndTime != null, q => q.CreatedTime >= pageInput.TimeSearch.BeginTime && q.CreatedTime <= $"{pageInput.TimeSearch.EndTime.Value.ToString("yyyy-MM-dd")} 23:59:59".ToDateTime()); |
|
|
|
var express = base.GetWithOutStatusExpression<AppCaseManagement, AppCaseManagementGetPageInput, long>(pageInput, query); |
|
|
|
return express; |
|
} |
|
|
|
/// <summary> |
|
/// 校验被监管人信息 ，通过身份证号 和手机号 |
|
/// </summary> |
|
/// <param name="input"></param> |
|
/// <returns></returns> |
|
private async Task<IResultOutput> ValidSupervisedPerson(AppCaseManagementCreateOrModifyInput input) |
|
{ |
|
var validMsg = string.Empty; |
|
if (input.SupervisedPersonGetDtos!.Any(w => w.Name.IsNull() || w.Phone.IsNull() || w.IdCard.IsNull())) validMsg = "被监管人姓名,手机号或者身份证不能为空!"; |
|
|
|
if (validMsg.NotNull()) return ResultOutput.NotOk(validMsg); |
|
|
|
//校验身份证、手机号不能重复 |
|
if (input.SupervisedPersonGetDtos!.GroupBy(w => w.IdCard).Any(w => w.Count() > 1)) validMsg = "身份证重复"; |
|
if (input.SupervisedPersonGetDtos!.GroupBy(w => w.Phone).Any(w => w.Count() > 1)) validMsg = "手机号重复"; |
|
|
|
var spList = (from ca in _appCaseManagementRepository.AsQueryable(false, true) |
|
join sp in _appSupervisedPersonRepository.AsQueryable(false, true) on ca.Id equals sp.CaseId |
|
select new |
|
{ |
|
ca, |
|
sp |
|
}); |
|
|
|
//一个人只能存在一个正在进行中的案件 (根据身份证) |
|
foreach (var personGetDto in input.SupervisedPersonGetDtos!) |
|
{ |
|
if (spList.Any(w => w.sp.Id != personGetDto.Id && w.sp.IdCard == personGetDto.IdCard && w.ca.CaseProgress != CaseProgressEnum.Closed)) |
|
{ |
|
validMsg = $"{personGetDto.SupervisedPersonName}的身份证{personGetDto.IdCard}存在一个没结束的案件"; |
|
break; |
|
} |
|
} |
|
|
|
return validMsg.NotNull() ? ResultOutput.NotOk(validMsg) : ResultOutput.Ok(); |
|
} |
|
|
|
/// <summary> |
|
/// 校验被监管人电子围栏名称 |
|
/// </summary> |
|
/// <param name="input"></param> |
|
/// <returns></returns> |
|
private async Task<IResultOutput> ValidSpCommonFence(AppCaseManagementCreateOrModifyInput input) |
|
{ |
|
var validMsg = string.Empty; |
|
|
|
var commName = input.SupervisedPersonGetDtos.Where(w => w.CommonFenceAddInput != null).Select(w => w.CommonFenceAddInput.Name).ToList(); |
|
|
|
var commFenceList = await _appCommonFenceRepository.AsQueryable(false, true) |
|
.Where(w => commName.Contains(w.Name)) |
|
.ToListAsync(); |
|
|
|
foreach (var fence in commFenceList) |
|
{ |
|
validMsg = $"电子围栏名称为:{fence.Name}已存在!"; |
|
break; |
|
} |
|
|
|
return validMsg.NotNull() |
|
? ResultOutput.NotOk(validMsg) |
|
: ResultOutput.Ok(); |
|
} |
|
|
|
#endregion Private |
|
|
|
#region 新增涉嫌人员接口 |
|
/// <summary> |
|
/// 查询被监管人员信息---列表 |
|
/// </summary> |
|
/// <param name="input"></param> |
|
/// <returns></returns> |
|
[HttpPost] |
|
public async Task<IResultOutput> GetSupervisedPersonAsync(GetSupervisedPersonPage input) |
|
{ |
|
var limits = User.limits; |
|
var selectLimits = await _appCaseSupervisorRepository.AsQueryable(false, true) |
|
.Where(w => limits.Contains(w.UnitId.ToString())) |
|
.ToListAsync(); |
|
var caseIds = selectLimits.Select(w => w.CaseId).Distinct().ToList(); |
|
|
|
//var caseIds = await (await base.GetCurrentUserCaseListAsync()).Select(w => w.AppCaseManagement.Id).ToListAsync(); |
|
var caselist = await (await base.GetCurrentUserCaseListAsync()).Select(w => new { w.AppCaseManagement.Id, w.AppCaseManagement.Name }).ToListAsync(); |
|
//查询待执行，执行种案件涉嫌人员 去除状态筛选，与导出接口一致 |
|
//var appSupervisedlist = from a in base._appCaseManagementRepository.AsQueryable(false, true).Where(q => q.CaseProgress != CaseProgressEnum.Closed) |
|
// join b in _appSupervisedPersonRepository.AsQueryable(false, true) on a.Id equals b.CaseId |
|
// select b; |
|
var appSupervisedlist = from a in base._appCaseManagementRepository.AsQueryable(false, true) |
|
join b in _appSupervisedPersonRepository.AsQueryable(false, true) on a.Id equals b.CaseId |
|
select b; |
|
var data = await appSupervisedlist |
|
.Where(q => caseIds.Contains(q.CaseId)) |
|
.WhereIf(input.TimeSearch?.BeginTime != null && input.TimeSearch?.EndTime != null, q => q.CreatedTime >= input.TimeSearch.BeginTime && q.CreatedTime <= $"{input.TimeSearch.EndTime.Value.ToString("yyyy-MM-dd")} 23:59:59".ToDateTime()) |
|
.WhereIf(input.name.NotNull(), q => q.SupervisedPersonName.Contains(input.name)) |
|
.OrderByDescending(r => r.CreatedTime) |
|
.ProjectTo<AppSupervisedPersonGetDto>(Mapper.ConfigurationProvider) |
|
.PagedAsync(input) |
|
.ConfigureAwait(false); |
|
|
|
|
|
return ResultOutput.Ok(new { data, caselist }); |
|
} |
|
|
|
/// <summary> |
|
/// 添加修改被监管人 |
|
/// </summary> |
|
/// <param name="input"></param> |
|
/// <returns></returns> |
|
public async Task<IResultOutput> AddSupervisedPersonAsync(AppCaseManagementCreateOrModifyInput input) |
|
{ |
|
//校验案件被监管人 |
|
var validSpCase = await ValidSupervisedPerson(input); |
|
if (!validSpCase.Success) return validSpCase; |
|
//案件Id |
|
var caseId = input.Id; |
|
Uow.BeginTransaction(); |
|
//不存在的被监管人 |
|
var roles = (await _roleService.GetRoleByKeyword("supervisedPerson")).FirstOrDefault(); |
|
|
|
//被监管人职位字典 |
|
var supervisedPersonPosition = await base.GetDictionariesOutput("job_position", "supervisedperson"); |
|
|
|
//被监管人员 |
|
var supervisedPersonList = Mapper.Map<List<AppSupervisedPersonGetDto>, List<AppCaseSupervisedPerson>>(input.SupervisedPersonGetDtos); |
|
supervisedPersonList.ForEach(item => |
|
{ |
|
item.Id = YitIdHelper.NextId(); |
|
item.CaseId = caseId!.Value; |
|
}); |
|
|
|
#region [1]如果用户不存在就添加到用户表中(根据身份证来判断) |
|
|
|
List<SupervisedPersonAddInput> addUsers = new(); |
|
List<SupervisedPersonUpdateInput> updateAppUsers = new(); |
|
|
|
foreach (var item in supervisedPersonList) |
|
{ |
|
var tempUser = await _appUserRepository.FindAsync(w => w.IdCard == item.IdCard); |
|
|
|
//存在就修改名字和手机号 |
|
if (tempUser != null) |
|
{ |
|
tempUser.UserName = tempUser.Name = item.SupervisedPersonName; |
|
tempUser.Phone = item.Phone; |
|
} |
|
else |
|
{ |
|
addUsers.Add(new SupervisedPersonAddInput() |
|
{ |
|
UserName = item.SupervisedPersonName, |
|
Name = item.SupervisedPersonName, |
|
Password = "Mr@123456", |
|
Phone = item.Phone, |
|
RoleIds = new[] { roles!.Id }, |
|
DataStatus = DataStatusEnum.Normal, |
|
PositionId = supervisedPersonPosition?.Id, |
|
PositionName = supervisedPersonPosition?.Name, |
|
RoleName = roles.Name, |
|
IdCard = item.IdCard, |
|
Id = YitIdHelper.NextId() |
|
}); |
|
} |
|
} |
|
if (addUsers.Any()) await _userService.BatchAddAsync(addUsers); |
|
if (updateAppUsers.Any()) await _userService.BatchUpdateAsync(updateAppUsers); |
|
|
|
var userIds = addUsers.Select(w => w.Id).Union(updateAppUsers.Select(w => w.Id)).Distinct(); |
|
|
|
//所有用户 |
|
var allUsers = await _appUserRepository.Where(w => userIds.Contains(w.Id)).ToListAsync(); |
|
|
|
foreach (var person in supervisedPersonList) |
|
{ |
|
//根据身份证号来确定唯一 |
|
var tempUser = allUsers.FirstOrDefault(w => w.IdCard == person.IdCard); |
|
if (tempUser == null) |
|
tempUser = await _appUserRepository.FindAsync(w => w.IdCard == person.IdCard); |
|
if (tempUser == null) continue; |
|
person.SupervisedPersonId = tempUser.Id; |
|
person.SupervisedPersonName = tempUser.UserName; |
|
person.Phone = tempUser.Phone; |
|
} |
|
|
|
#endregion [1]如果用户不存在就添加到用户表中(根据身份证来判断) |
|
|
|
#region 被监管人电子围栏 |
|
|
|
{ |
|
var spIds = supervisedPersonList |
|
.Where(w => w.ElectricFenceId == 0) |
|
.Select(w => w.SupervisedPersonId) |
|
.ToList(); |
|
|
|
//只有是设置得才添加 |
|
if (spIds.Any()) |
|
{ |
|
//先删除 |
|
await _appCommonFenceRepository.DeleteAsync(w => |
|
w.CaseId == caseId && w.CommonFenceType == CommonFenceTypeEnum.SupervisedPerson && |
|
spIds.Contains(w.SupervisedPersonId.Value)); |
|
|
|
var adCfList = input.SupervisedPersonGetDtos |
|
.Select(w => new AppCommonFence(YitIdHelper.NextId()) |
|
{ |
|
CaseId = caseId, |
|
SupervisedPersonId = w.SupervisedPersonId, |
|
SupervisedPersonName = w.SupervisedPersonName, |
|
CommonFenceType = CommonFenceTypeEnum.SupervisedPerson, |
|
Name = w.CommonFenceAddInput?.Name, |
|
Path = w.CommonFenceAddInput?.Path |
|
}); |
|
|
|
if (adCfList.Any()) |
|
{ |
|
var addedCfList = await _appCommonFenceRepository.InsertAsync(adCfList); |
|
|
|
foreach (var item in supervisedPersonList) |
|
{ |
|
var tempCommonFence = addedCfList.FirstOrDefault(w => |
|
w.CaseId == caseId && |
|
w.CommonFenceType == CommonFenceTypeEnum.SupervisedPerson && |
|
w.SupervisedPersonId == item.SupervisedPersonId); |
|
|
|
//说明是常用围栏 |
|
if (tempCommonFence == null) continue; |
|
|
|
item.ElectricFenceId = tempCommonFence?.Id; |
|
item.ElectricFenceName = tempCommonFence?.Name; |
|
} |
|
} |
|
} |
|
} |
|
|
|
#endregion 被监管人电子围栏 |
|
|
|
//案子被监管人中间表 |
|
var sprIds = supervisedPersonList.Select(w => w.SupervisedPersonId).ToList(); |
|
//当前案件所有已经存在的被监管人 |
|
var sprList = await _appSupervisedPersonRepository.AsQueryable(false, true) |
|
.Where(w => w.CaseId == caseId && sprIds.Contains(w.SupervisedPersonId)).ToListAsync(); |
|
//删除当前 |
|
await _appSupervisedPersonRepository.DeleteAsync(w => sprIds.Contains(w.SupervisedPersonId)); |
|
|
|
//防止漏网之鱼 |
|
foreach (var person in supervisedPersonList) |
|
{ |
|
if (person.SupervisedPersonId == default) |
|
{ |
|
var temUser = allUsers.FirstOrDefault(w => w.IdCard == person.IdCard); |
|
if (temUser == null) continue; |
|
person.SupervisedPersonId = temUser!.Id; |
|
person.SupervisedPersonName = temUser.UserName; |
|
} |
|
else |
|
{ |
|
var tempSp = sprList.FirstOrDefault(w => w.IdCard == person.IdCard); |
|
if (tempSp == null) continue; |
|
//把已经存在的数据全部赋值上(案件只能修改名字、身份证、手机号) |
|
person.ApprovalStatus = tempSp!.ApprovalStatus; |
|
person.IsBound = tempSp.IsBound; |
|
person.WarningGradeId = tempSp.WarningGradeId; |
|
person.EnterFace = tempSp.EnterFace; |
|
person.IMEI = tempSp.IMEI; |
|
} |
|
} |
|
//添加被监管人 |
|
await _appSupervisedPersonRepository.InsertAsync(supervisedPersonList); |
|
await Uow.CommitAsync(); |
|
//返回结果 |
|
return ResultOutput.Ok(); |
|
} |
|
|
|
/// <summary> |
|
/// 查询被监管人----id |
|
/// </summary> |
|
/// <param name="id"></param> |
|
/// <returns></returns> |
|
public async Task<IResultOutput> GetSupervised(long id) |
|
{ |
|
var caseDto = await _appSupervisedPersonRepository.AsQueryable(false, true) |
|
.Where(w => w.SupervisedPersonId == id) |
|
.OrderBy(W => W.Id) |
|
.ProjectTo<AppSupervisedPersonGetDto>(Mapper.ConfigurationProvider).ToListAsync(); |
|
|
|
//返回结果 |
|
return ResultOutput.Ok(caseDto); |
|
} |
|
#endregion |
|
|
|
#region 新增案件导入接口 |
|
/// <summary> |
|
/// 案件导入预览 |
|
/// </summary> |
|
/// <param name="id"></param> |
|
/// <returns></returns> |
|
[HttpPut] |
|
public async Task<IResultOutput> BatchHandlefile([FromForm] IFormFile file) |
|
{ |
|
var datalist = ExcelHelper.GetList<AppCaseManagementInput>(file, 0); |
|
|
|
//返回结果 |
|
return ResultOutput.Ok(datalist); |
|
} |
|
/// <summary> |
|
/// 案件导入保存 |
|
/// </summary> |
|
/// <param name="id"></param> |
|
/// <returns></returns> |
|
public async Task<IResultOutput> Getfilesava(List<AppCaseManagementInput> inputlist) |
|
{ |
|
var mag = "";//已存在数据库的案件部门受案号提示 |
|
var datalist = new List<AppCaseManagementCreateOrModifyInput>();//案件信息集合 |
|
var Supervisorlist = new List<AppCaseSupervisor>();//案件监管人信息集合 |
|
var list = Mapper.Map<List<AppCaseManagementInput>, List<AppCaseManagementCreateOrModifyInput>>(inputlist); |
|
foreach (var item in list) |
|
{ |
|
//校验案子 |
|
var caseValid = await base.Valid<AppCaseManagement, AppCaseManagementCreateOrModifyInput, long>(item, _appCaseManagementRepository, w => |
|
{ |
|
w = w.AndNotNull(w => w.Bmsah == item.Bmsah, item.Bmsah.IsNotNullOrEmpty()); |
|
|
|
return (w, $"{item.Bmsah}"); |
|
}); |
|
if (!caseValid.Success) |
|
{ |
|
mag += $"{caseValid.Msg},"; |
|
continue; |
|
} |
|
else |
|
{ |
|
item.Id = YitIdHelper.NextId(); |
|
} |
|
//案子监管管理人员(Bug:当我修改监管人后，已审核过的被监管人需要重新申请，被切换的监管人没有对应数据) |
|
if (item.SupervisorIds!.Any()) |
|
{ |
|
var sList = item.SupervisorIds!.Select(csp => new AppCaseSupervisor(YitIdHelper.NextId()) |
|
{ |
|
CaseId = (long)item.Id, |
|
SupervisorId = csp.SupervisedId, |
|
SupervisorName = csp.SupervisedName |
|
}); |
|
|
|
await _appCaseSupervisorRepository.DeleteAsync(w => w.CaseId == item.Id); |
|
Supervisorlist.AddRange(sList); |
|
} |
|
datalist.AddRange(item); |
|
} |
|
Uow.BeginTransaction(); |
|
if (datalist.Any()) |
|
{ |
|
var entity = Mapper.Map<List<AppCaseManagement>>(datalist); |
|
await _appCaseManagementRepository.InsertAsync(entity); |
|
await _appCaseSupervisorRepository.InsertAsync(Supervisorlist); |
|
} |
|
await Uow.CommitAsync(); |
|
//返回结果 |
|
if (string.IsNullOrEmpty(mag)) |
|
return ResultOutput.Ok("", "保存成功"); |
|
else return datalist.Count == 0 |
|
? ResultOutput.Ok("", $"案件已存在，重复案件的部门受案号为:{mag.Trim(',')}") |
|
: ResultOutput.Ok("", $"保存成功,重复案件的部门受案号为:{mag.Trim(',')}"); |
|
} |
|
/// <summary> |
|
/// 案件导出 |
|
/// </summary> |
|
/// <param name="id"></param> |
|
/// <returns></returns> |
|
public async Task<IActionResult> Getexport(AppCaseManagementGetPageInput input) |
|
{ |
|
input.PageIndex = 1; |
|
input.PageSize = 999999; |
|
var limits = User.limits; |
|
var selectLimits = await _appCaseSupervisorRepository.AsQueryable(false, true) |
|
.Where(w => limits.Contains(w.UnitId.ToString())) |
|
.ToListAsync(); |
|
input.CaseIds = selectLimits.Select(w => w.CaseId).Distinct().ToList(); |
|
|
|
var express = await GetExpression(input, _appCaseManagementRepository.AsQueryable(false, true)); |
|
|
|
var rtn = await base.GetPageAsync<AppCaseManagement, AppCaseManagementGetPageInput, AppCaseManagementListexportDto>(input, express); |
|
|
|
//var caseIds = rtn.Data.Select(w => w.Id).ToList(); |
|
|
|
var caseSupervisor = await _appCaseSupervisorRepository.AsQueryable(false, true) |
|
.Where(w => input.CaseIds.Contains(w.CaseId)) |
|
.ToListAsync(); |
|
|
|
foreach (var listDto in rtn.Data) |
|
{ |
|
var judgmentlist = await base.GetDictionariesOutput1("judgment", ""); |
|
var type_caselist = await base.GetDictionariesOutput1("type_case", ""); |
|
listDto.CaseTypename = type_caselist.Where(w => w.Id == listDto.CaseTypeId).Select(w => w.Name).JoinAsString(","); |
|
listDto.JudgmentStatusname = judgmentlist.Where(w => w.Id == listDto.JudgmentStatusId).Select(w => w.Name).JoinAsString(","); |
|
listDto.Supervisor = caseSupervisor.Where(w => w.CaseId == listDto.Id).Select(w => w.SupervisorName).JoinAsString(","); |
|
} |
|
var list = new List<AppCaseManagementListexportDto>(); |
|
list.AddRange(rtn.Data); |
|
var memorySystem = ExcelHelper.ToExcel(list); |
|
return new Controller().File(memorySystem.ToArray(), "application/ms-excel", $"{DateTime.Now.ToString("f")}.xlsx"); |
|
} |
|
|
|
/// <summary> |
|
/// 案件涉案人员导出 |
|
/// </summary> |
|
/// <param name="id"></param> |
|
/// <returns></returns> |
|
public async Task<IActionResult> Getuserexport(GetSupervisedPersonPage input) |
|
{ |
|
input.PageIndex = 1; |
|
input.PageSize = 999999; |
|
var limits = User.limits; |
|
var selectLimits = await _appCaseSupervisorRepository.AsQueryable(false, true) |
|
.Where(w => limits.Contains(w.UnitId.ToString())) |
|
.ToListAsync(); |
|
var caseIds = selectLimits.Select(w => w.CaseId).Distinct().ToList(); |
|
|
|
//var caseIds = await (await base.GetCurrentUserCaseListAsync()).Select(w => w.AppCaseManagement.Id).ToListAsync(); |
|
var caselist = await (await base.GetCurrentUserCaseListAsync()).Select(w => new { w.AppCaseManagement.Id, w.AppCaseManagement.Name }).ToListAsync(); |
|
var data = await _appSupervisedPersonRepository.AsQueryable(false, true) |
|
.Where(q => caseIds.Contains(q.CaseId)) |
|
.WhereIf(input.name.NotNull(), q => q.SupervisedPersonName.Contains(input.name)) |
|
.OrderByDescending(r => r.CreatedTime) |
|
.ProjectTo<AppSupervisedPersonListexportDto>(Mapper.ConfigurationProvider) |
|
.PagedAsync(input) |
|
.ConfigureAwait(false); |
|
|
|
foreach (var listDto in data.Data) |
|
{ |
|
//var judgmentlist = await base.GetDictionariesOutput1("judgment", ""); |
|
//var type_caselist = await base.GetDictionariesOutput1("type_case", ""); |
|
listDto.Casename = caselist.Where(q => q.Id == listDto.CaseId).Select(q => q.Name).JoinAsString(","); |
|
//listDto.CaseTypename = type_caselist.Where(w => w.Id == listDto.CaseTypeId).Select(w => w.Name).JoinAsString(","); |
|
//listDto.JudgmentStatusname = judgmentlist.Where(w => w.Id == listDto.JudgmentStatusId).Select(w => w.Name).JoinAsString(","); |
|
//listDto.Supervisor = caseSupervisor.Where(w => w.CaseId == listDto.Id).Select(w => w.SupervisorName).JoinAsString(","); |
|
} |
|
var list = new List<AppSupervisedPersonListexportDto>(); |
|
list.AddRange(data.Data); |
|
var memorySystem = ExcelHelper.ToExcel(list); |
|
return new Controller().File(memorySystem.ToArray(), "application/ms-excel", $"{DateTime.Now.ToString("f")}.xlsx"); |
|
} |
|
|
|
#endregion |
|
} |
|
public class Controller : ControllerBase |
|
{ |
|
|
|
} |
|
} |