public async Task ExecuteAsync(string userPIN, string signatureImage)
{
try
{
if (string.IsNullOrWhiteSpace(userPIN))
{
throw new ArgumentNullException(nameof(userPIN));
}
if (string.IsNullOrWhiteSpace(signatureImage))
{
throw new ArgumentNullException(nameof(signatureImage));
}
using (var dbSession = dbFacade.Transaction())
{
var user = await dbSession.Set <User>().FirstOrDefaultAsync(u => u.Pin == userPIN);
if (user == null)
{
throw new Exception("User not found");
}
user.Signature = signatureImage;
await dbSession.SaveChangesAsync();
}
}
catch (Exception e)
{ throw Oops.Rewrap(e); }
}
/// <summary>
/// 删除班级
/// </summary>
/// <param name="classIds"></param>
/// <returns></returns>
public async Task DeleteAsync([Required, MinLength(1), MaxLength(20)] int[] classIds)
{
// 判断用户Id中是否有重复项
var isRepeat = classIds.GroupBy(i => i).Any(g => g.Count() > 1);
if (isRepeat)
{
throw Oops.Oh(SystemErrorCodes.u1011);
}
// 查询所有存在且不被引用的用户
var classes = await _classRepository
.Where(u => classIds.Contains(u.Id))
.ToListAsync();
// 判断要操作的数据长度是是否等于传入数据的长度
if (classIds.Length != classes.Count)
{
throw Oops.Oh(SystemErrorCodes.u1007);
}
var nowTime = DateTimeOffset.Now;
classes.ForEach(u =>
{
u.UpdatedTime = nowTime;
u.IsDeleted = true;
});
}
/// <summary>
/// 添加动态接口控制器服务
/// </summary>
/// <param name="mvcBuilder">Mvc构建器</param>
/// <returns>Mvc构建器</returns>
public static IMvcBuilder AddDynamicApiControllers(this IMvcBuilder mvcBuilder)
{
var services = mvcBuilder.Services;
var partManager = services.FirstOrDefault(s => s.ServiceType == typeof(ApplicationPartManager)).ImplementationInstance as ApplicationPartManager
?? throw Oops.Oh($"`{nameof(AddDynamicApiControllers)}` must be invoked after `{nameof(MvcServiceCollectionExtensions.AddControllers)}`", typeof(InvalidOperationException));
// 添加控制器特性提供器
partManager.FeatureProviders.Add(new DynamicApiControllerFeatureProvider());
// 添加配置
services.AddConfigurableOptions <DynamicApiControllerSettingsOptions>();
// 配置 Mvc 选项
mvcBuilder.AddMvcOptions(options =>
{
// 添加应用模型转换器
options.Conventions.Add(new DynamicApiControllerApplicationModelConvention());
// 处理 Web API 不支持的返回格式，统一返回 406 状态码
//options.ReturnHttpNotAcceptable = true;
});
// 添加丰富类型支持
mvcBuilder.AddNewtonsoftJson();
// 添加 Xml 支持
mvcBuilder.AddXmlDataContractSerializerFormatters();
return(mvcBuilder);
}
/// <summary>
/// 获取实体仓储
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <typeparam name="TDbContextLocator">数据库上下文定位器</typeparam>
/// <returns>IRepository<TEntity, TDbContextLocator></returns>
public static IRepository <TEntity, TDbContextLocator> GetRepository <TEntity, TDbContextLocator>()
where TEntity : class, IEntity, new()
where TDbContextLocator : class, IDbContextLocator
{
return(RequestServiceProvider.GetService <IRepository <TEntity, TDbContextLocator> >()
?? throw Oops.Oh("Reading IRepository<TEntity, TDbContextLocator> instances on non HTTP requests is not supported.", typeof(NotSupportedException)));
}
/// <summary>
/// 删除试卷
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
/// <exception cref="Exception"></exception>
public async Task DeleteExam(int id)
{
var exam = await _examRepository
.FirstOrDefaultAsync(u => u.Id == id);
if (exam == null)
{
throw Oops.Oh(ExamErrorCodes.s1901);
}
// 删除卷题目
await _examRepository
.Change <TbExamquestion>()
.DeleteAsync(
_examRepository
.Change <TbExamquestion>()
.Where(u => u.ExamId == id, false).ToList()
);
// 删除试卷班级关联
await _examRepository
.Change <TbExamclass>()
.DeleteAsync(
_examRepository
.Change <TbExamclass>()
.Where(u => u.ExamId == id, false).ToList()
);
await _examRepository.DeleteAsync(exam);
}
/// <summary>
/// 删除字典数据
/// </summary>
/// <param name="categoryId"></param>
/// <param name="dataIds"></param>
/// <returns></returns>
public async Task DeleteDictionaryDataAsync([Required, Range(1, int.MaxValue, ErrorMessage = "请输入有效的字典分类Id"), ApiSeat(ApiSeats.ActionStart)] int categoryId,
[Required, MinLength(1), MaxLength(20)] int[] dataIds)
{
// 查询字典分类是否存在
var isExist = await _categoryRepository.AnyAsync(u => u.Id == categoryId, false);
if (!isExist)
{
throw Oops.Oh(SystemErrorCodes.u1002);
}
var dictionaryDatas = await _dataRepository.Where(u => dataIds.Contains(u.Id) && u.CategoryId == categoryId).ToListAsync();
// 判断要操作的角色集合长度是否和传入数组的长度相等
if (dataIds.Length != dictionaryDatas.Count)
{
throw Oops.Oh(SystemErrorCodes.u1007);
}
// 软/假删除
var nowTime = DateTimeOffset.Now;
dictionaryDatas.ForEach(u =>
{
u.UpdatedTime = nowTime;
u.IsDeleted = true;
});
}
/// <summary>
/// 查询教师
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
/// <exception cref="Exception"></exception>
public async Task <TeacherDto> FindTeacherById(int id)
{
var teacher = await _teacherRepository
.Entities
.Select(u => new TbTeacher
{
Id = u.Id,
TeacherName = u.TeacherName,
DeptId = u.DeptId,
Sex = u.Sex,
TeacherNo = u.TeacherNo,
Telphone = u.Telphone,
IdCard = u.IdCard,
CreateTime = u.CreateTime,
Dept = new TbDept
{
CreateTime = u.Dept.CreateTime,
DeptName = u.Dept.DeptName
}
})
.FirstOrDefaultAsync(x => x.Id == id);
if (teacher == null)
{
throw Oops.Oh(TeacherErrorCodes.t1402);
}
return(teacher.Adapt <TeacherDto>());
}
/// <summary>
/// 为老师分配受教班级
/// </summary>
/// <param name="classId"></param>
/// <param name="teacherds"></param>
public async Task GiveAsync([Range(1, int.MaxValue, ErrorMessage = "请输入有效的班级、老师 Id"), Required] int classId, [MinLength(1), Required] int[] teacherds)
{
// 判断传入老师数据是否正确
var count = await _teacherRepository.CountAsync(u => teacherds.Contains(u.Id), false);
if (teacherds.Contains(0) || count != teacherds.Length)
{
throw Oops.Oh(SystemErrorCodes.u1009);
}
// 删除已有的老师
var classTeacherRepository = _teacherRepository.Change <ClassTeacher>();
await classTeacherRepository.DeleteAsync(classTeacherRepository.Where(u => u.SchoolClassId == classId, false).ToList());
var list = new List <ClassTeacher>();
foreach (var techerId in teacherds)
{
list.Add(new ClassTeacher {
TeacherId = techerId, SchoolClassId = classId
});
}
await classTeacherRepository.InsertAsync(list);
}
/// <summary>
/// 异常拦截
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public async Task OnExceptionAsync(ExceptionContext context)
{
// 解析异常处理服务，实现自定义异常额外操作，如记录日志等
var globalExceptionHandler = _serviceProvider.GetService <IGlobalExceptionHandler>();
if (globalExceptionHandler != null)
{
await globalExceptionHandler.OnExceptionAsync(context);
}
// 排除 Mvc 视图
var actionDescriptor = context.ActionDescriptor as ControllerActionDescriptor;
if (actionDescriptor.ControllerTypeInfo.BaseType == typeof(Controller))
{
return;
}
// 标识异常已经被处理
context.ExceptionHandled = true;
// 设置异常结果
var exception = context.Exception;
// 处理规范化结果
var unifyResult = _serviceProvider.GetService <IUnifyResultProvider>();
context.Result = unifyResult == null ? new ContentResult {
Content = exception.Message
} : unifyResult.OnException(context);
// 打印错误到 MiniProfiler 中
Oops.PrintToMiniProfiler(context.Exception);
}
/// <summary>
/// 学生注册
/// </summary>
/// <param name="studentDto"></param>
/// <returns></returns>
public async Task <StudentDto> RegisterStudent(StudentDto studentDto)
{
// 判断学号是否已经注册
var stu = await _studentRepository.Where(x => x.StuNo == studentDto.StuNo).FirstOrDefaultAsync();
if (stu != null)
{
throw Oops.Oh(StudentErrorCodes.s1205);
}
// 判断班级是否存在
var classes = await _studentRepository.Change <TbClass>().FirstOrDefaultAsync(x => x.Id == studentDto.ClassesId);
if (classes == null)
{
throw Oops.Oh(StudentErrorCodes.s1202);
}
// 判断班级是否属于该系别
if (classes.DeptId != studentDto.DeptId)
{
throw Oops.Oh(StudentErrorCodes.s1203);
}
// studentDto.CreateTime = TimeUtil.GetTimeStampNow();
var stduent = await _studentRepository
.InsertNowAsync(studentDto.Adapt <TbStudent>());
return(stduent.Entity.Adapt <StudentDto>());
}
[ApiDescriptionSettings(Name = "Roles")] // 自定义接口名称
public List <string> GetUserRoles(
// 自定义参数位置
[ApiSeat(ApiSeats.ControllerEnd)] string id)
{
// 友好的异常处理
throw Oops.Oh(ErrorCodes.UserNotFound, id);
}
public async Task <LoginOutput> LoginAsync([FromServices] IHttpContextAccessor httpContextAccessor, [Required] LoginInput input)
{
// 获取加密后的密码
var encryptPassword = MD5Encryption.Encrypt(input.Password.Trim());
// 判断用户名或密码是否正确
var user = await _userRepository.FirstOrDefaultAsync(u => u.Account.Equals(input.Account) && u.Password.Equals(encryptPassword));
_ = user ?? throw Oops.Oh(SystemErrorCodes.u1000);
// 更新登录时间
user.SigninedTime = DateTimeOffset.Now;
// 映射结果
var output = user.Adapt <LoginOutput>();
// 生成 token
var accessToken = output.AccessToken = JWTEncryption.Encrypt(new Dictionary <string, object>
{
{ "UserId", user.Id },
{ "Account", user.Account }
});
// 生成 刷新token
var refreshToken = JWTEncryption.GenerateRefreshToken(accessToken);
// 设置 Swagger 自动登录
httpContextAccessor.SigninToSwagger(accessToken);
// 设置刷新 token
httpContextAccessor.HttpContext.Response.Headers["x-access-token"] = refreshToken;
return(output);
}
public IHttpActionResult InsertOops(Oops oops)
{
dbContext.Oops.Add(oops);
dbContext.SaveChangesAsync();
return(Ok(oops.ID));
}
public Electrode Execute(int productionOrderId)
{
try
{
using (var dbSession = dbFacade.Transaction())
{
var order = dbSession.Set <ProductionOrder>()
.Include(x => x.Grade)
.Where(x => x.ID == productionOrderId)
.Select(x => new { GradeName = x.Grade.Name })
.SingleOrDefault();
if (order == null)
{
return(null);
}
return(new Electrode()
{
});
}
}
catch (Exception e)
{ throw Oops.Rewrap(e); }
}
/// <summary>
/// 添加编辑角色
/// </summary>
/// <param name="dto"></param>
/// <returns></returns>
public void AddEdit(RoleAddEditDto dto)
{
dto.RoleName = dto.RoleName.Trim();
SysRole role = null;
if (dto.RoleId.HasValue)
{
if (dbClint.Queryable<SysRole>().Where(r => r.RoleName == dto.RoleName && r.IsDeleted == false && r.RoleId != dto.RoleId.Value).Any())
throw Oops.Oh($"已存在角色【{dto.RoleName}】!");
role = _repository.FirstOrDefault(r=>r.RoleId==dto.RoleId.Value);
role.ModifyDate = DateTime.Now;
role.ModifyUserId = _userManager.UserId;
role.ModifyUserName = _userManager.UserName;
}
else
{
if (dbClint.Queryable<SysRole>().Where(r => r.RoleName == dto.RoleName && r.IsDeleted == false).Any())
throw Oops.Oh($"已存在角色【{dto.RoleName}】!");
role = new SysRole()
{
CreateDate = DateTime.Now,
CreateUserId = _userManager.UserId,
CreateUserName = _userManager.UserName,
IsDeleted = false
};
}
role.RoleName = dto.RoleName;
role.Remark = dto.Remark;
role.IsEnabled = dto.IsEnabled;
if (dto.RoleId.HasValue)
dbClint.Updateable(role).ExecuteCommand();
else
dbClint.Insertable(role).ExecuteCommand();
}
public ObservableCollection <InstructionMaterial> Execute(string heatNumber)
{
try
{
// RecipeESR approach
var materials = new GetAllMaterials(dbFacade).ExecuteWithMaterialTypeAndMaterialElements().Where(m => m.Active == true);
using (var dbSession = dbFacade.Transaction())
{
int?id = dbSession.Set <ProductionOrder>().Where(x => x.HeatNumber == heatNumber).FirstOrDefault()?.ID;
if (id == null)
{
return(null);
}
Instruction instruction = dbSession.Set <Instruction>()
.Include(x => x.ProductionOrder)
.Include(x => x.Materials)
.Include(r => r.Materials.Select(rr => rr.Material))
.Include(r => r.Materials.Select(rr => rr.Material.MaterialType))
.Include(r => r.Materials.Select(rr => rr.Material.MaterialElements.Select(x => x.Element)))
.FirstOrDefault(x => x.ProductionOrderID == id);
if (instruction != null)
{
return(CreateMaterialList(instruction.Materials, materials, "Slag"));
}
return(null);
}
}
catch (Exception e)
{ throw Oops.Rewrap(e); }
}
/// <summary>
/// 更新字典数据
/// </summary>
/// <param name="categoryId"></param>
/// <param name="dataId"></param>
/// <param name="input"></param>
/// <returns></returns>
public async Task UpdateDictionaryDataAsync(
[Required, Range(1, int.MaxValue, ErrorMessage = "请输入有效的字典分类Id"), ApiSeat(ApiSeats.ActionStart)] int categoryId,
[Required, Range(1, int.MaxValue, ErrorMessage = "请输入有效的字典数据Id")] int dataId,
[Required] EditSystemDataInput input)
{
// 查询字典分类是否存在
var isExist = await _categoryRepository.AnyAsync(u => u.Id == categoryId, false);
if (!isExist)
{
throw Oops.Oh(SystemErrorCodes.u1002);
}
// 查询字典数据是否存在
isExist = await _dataRepository.AnyAsync(u => u.Id == dataId && u.CategoryId == categoryId, false);
if (!isExist)
{
throw Oops.Oh(SystemErrorCodes.u1002);
}
var dictionaryData = input.Adapt <SystemData>();
// 配置主外键和更新时间
dictionaryData.Id = dataId;
dictionaryData.CategoryId = categoryId;
dictionaryData.UpdatedTime = DateTimeOffset.Now;
await _dataRepository.UpdateExcludeAsync(dictionaryData, new[] { nameof(SystemData.IsDeleted), nameof(SystemData.CreatedTime) }, ignoreNullValues : true);
}
public IList <Substance> ExecuteWrapper(string heatNumber)
{
try
{
var listSet = Execute(heatNumber);
if (listSet != null)
{
// Convert to List<Substance>
var substances = new List <Substance>();
foreach (var item in listSet)
{
substances.Add(new Substance()
{
ID = item.MaterialID,
Name = item.Material.Name,
Charge = item.Material.Number,
Amount = item.Amount
});
}
return(substances);
}
return(null);
}
catch (Exception e)
{ throw Oops.Rewrap(e); }
}
/// <summary>
/// 根据学生查询错题本详情
/// </summary>
/// <param name="examId"></param>
/// <param name="studentId"></param>
/// <returns></returns>
public async Task <ExamDto> FindWrongInfoByExamAndStudent(int examId, int studentId)
{
var wrong = await _answerRepository.Change <TbExam>()
.Entities.AsNoTracking()
.Where(u => u.IsEnable == "1")
.Include(u => u.Stuanswerdetails)
.Select(u => new TbExam
{
Id = u.Id,
ExamName = u.ExamName,
Stuanswerdetails = u.Stuanswerdetails
.Where(x => x.StuId == studentId && x.Isright == "0" && x.ExamId == examId)
.Select(s => new TbStuanswerdetail
{
Id = s.Id,
QuestionType = s.QuestionType,
}).ToList(),
}).FirstOrDefaultAsync();
if (wrong == null)
{
throw Oops.Oh(ExamErrorCodes.s1901);
}
return(wrong.Adapt <ExamDto>());
}
/// <summary>
/// 获取实体仓储
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <typeparam name="TDbContextLocator">数据库上下文定位器</typeparam>
/// <returns>IRepository<TEntity, TDbContextLocator></returns>
public static IRepository <TEntity, TDbContextLocator> GetRepository <TEntity, TDbContextLocator>()
where TEntity : class, IEntityDependency, new()
where TDbContextLocator : class, IDbContextLocator
{
return(RequestServiceProvider.GetService <IRepository <TEntity, TDbContextLocator> >()
?? throw Oops.Oh(NotSupportedResolveMessage, typeof(NotSupportedException), nameof(IRepository <TEntity, TDbContextLocator>)));
}
public async Task <StuscoreDto> FindExamScoreByStudent(int examId, int studentId)
{
var score = await _stuscoreRepository
.Entities
.Where(u => u.ExamId == examId && u.StuId == studentId)
.Select(u => new TbStuscore
{
Id = u.Id,
StuId = u.StuId,
CourseId = u.CourseId,
ExamId = u.ExamId,
Score = u.Score,
CreateTime = u.CreateTime,
Exam = new TbExam
{
Id = u.Exam.Id,
ExamName = u.Exam.ExamName,
StartTime = u.Exam.StartTime,
Duration = u.Exam.Duration,
},
})
.FirstOrDefaultAsync();
if (score == null)
{
throw Oops.Oh(ExamScoreErrorCodes.k2001);
}
return(score.Adapt <StuscoreDto>());
}
/// <summary>
/// 检查是否支持存储过程
/// </summary>
/// <param name="databaseFacade">ADO.NET 数据库对象</param>
/// <param name="commandType">命令类型</param>
private static void CheckStoredProcedureSupported(DatabaseFacade databaseFacade, CommandType commandType)
{
if (DatabaseProvider.IsSupportStoredProcedure(databaseFacade.ProviderName, commandType))
{
Oops.Oh(NotSupportException, typeof(NotSupportedException), "stored procedure");
}
}
public virtual IList <MachineEventViewModel> Execute(int?ingotId, DateTime fromDate)
{
try
{
using (var dbSession = dbFacade.Transaction())
{
if (!ingotId.HasValue)
{
return(new List <MachineEventViewModel>());
}
return(dbSession.Set <MachineEvent>()
.Where(x =>
x.Timestamp >= fromDate &&
x.IngotID.HasValue &&
x.IngotID.Value == ingotId.Value
)
.Select(x => new MachineEventViewModel
{
Name = x.ValueString,
Timestamp = x.Timestamp,
})
.OrderByDescending(x => x.Timestamp)
.ToList());
}
}
catch (Exception e)
{ throw Oops.Rewrap(e); }
}
/// <summary>
/// 创建数据库命令参数字典
/// </summary>
/// <param name="method"></param>
/// <param name="arguments"></param>
/// <returns></returns>
private static object CombineDbParameter(MethodInfo method, object[] arguments)
{
var parameters = method.GetParameters();
if (parameters == null || parameters.Length == 0)
{
return(null);
}
// 只支持要么全是基元类型，或全部都是类类型
if (!parameters.All(u => u.ParameterType.IsRichPrimitive()) && !parameters.All(u => u.ParameterType.IsClass))
{
throw Oops.Oh("Invalid type cast", typeof(InvalidOperationException));
}
if (parameters.All(u => u.ParameterType.IsRichPrimitive()))
{
var dic = new Dictionary <string, object>();
for (var i = 0; i < parameters.Length; i++)
{
var parameter = parameters[i];
var parameterValue = arguments.Length > i ? arguments[i] : null;
dic.Add(parameter.Name, parameterValue);
}
return(dic);
}
else
{
return(arguments.First());
}
}
public virtual List <int> Execute(string plantName)
{
try
{
using (var dbSession = dbFacade.Transaction())
{
return(dbSession.Set <ProcessVariable>()
.Where(x =>
x.Name == plantName + "." + Constants.PROCESS_VARIABLE_CURRENT ||
x.Name == plantName + "." + Constants.PROCESS_VARIABLE_ELECTRODE_POSITION ||
x.Name == plantName + "." + Constants.PROCESS_VARIABLE_ELECTRODE_WEIGHT ||
x.Name == plantName + "." + Constants.PROCESS_VARIABLE_INGOT_WEIGHT ||
x.Name == plantName + "." + Constants.PROCESS_VARIABLE_MELTRATE ||
x.Name == plantName + "." + Constants.PROCESS_VARIABLE_POWER ||
x.Name == plantName + "." + Constants.PROCESS_VARIABLE_RESISTANCE ||
x.Name == plantName + "." + Constants.PROCESS_VARIABLE_SWING ||
x.Name == plantName + "." + Constants.PROCESS_VARIABLE_VOLTAGE
)
.Select(x => x.ID)
.ToList());
}
}
catch (Exception e)
{ throw Oops.Rewrap(e); }
}
public async Task BatchAddUser()
{
var user = await _repository.InsertNowAsync(new Core.SysUser
{
CreateUserId = 0,
CreateUserName = "",
IsSystem = Core.IsSystemEnum.否,
Password = "",
SecretKey = "111",
State = 0,
TrueName = "core-test" + System.Guid.NewGuid(),
UserName = "******"
});
var use1r = await _repository.InsertNowAsync(new Core.SysUser
{
CreateUserId = 0,
CreateUserName = "",
IsSystem = Core.IsSystemEnum.否,
Password = "",
SecretKey = "111",
State = 0,
TrueName = "core-test" + System.Guid.NewGuid(),
UserName = "******"
});
throw Oops.Oh(ErrorCodes.z1000);
}
/// <summary>
/// 查找系别
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
/// <exception cref="Exception"></exception>
public async Task <DeptDto> FindDeptById(int id)
{
var dept = await _deptRepository
.Entities
.Select(u => new TbDept
{
Id = u.Id,
DeptName = u.DeptName,
CreateTime = u.CreateTime,
Classes = u.Classes.Select(c => new TbClass
{
Id = c.Id,
ClassesName = c.ClassesName,
CreateTime = c.CreateTime,
}).ToList()
})
.FirstOrDefaultAsync(x => x.Id == id);
if (dept == null)
{
throw Oops.Oh(DeptErrorCodes.d1301);
}
return(dept.Adapt <DeptDto>());
}
/// <summary>
/// 根据id查询是非题
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
/// <exception cref="Exception"></exception>
public async Task <JudgeDto> FindJudgeById(int id)
{
var judgeEntity = await _judgeRepository
.Entities
.Select(u => new TbJudge
{
Id = u.Id,
Question = u.Question,
Answer = u.Answer,
CourseId = u.CourseId,
ChapterId = u.ChapterId,
TeacherId = u.TeacherId,
Ideas = u.Ideas,
CreateTime = u.CreateTime,
Chapter = new TbChapter
{
Id = u.Chapter.Id,
ChapterName = u.Chapter.ChapterName,
},
Course = new TbCourse
{
Id = u.Course.Id,
CourseName = u.Course.CourseName
},
})
.FirstOrDefaultAsync(u => u.Id == id);
if (judgeEntity == null)
{
throw Oops.Oh(JudgeErrorCodes.s1801);
}
return(judgeEntity.Adapt <JudgeDto>());
}
/// <summary>
/// 检查是否支持存储过程
/// </summary>
/// <param name="providerName">数据库提供器名词</param>
/// <param name="commandType">命令类型</param>
internal static void CheckStoredProcedureSupported(string providerName, CommandType commandType)
{
if (commandType == CommandType.StoredProcedure && NotSupportStoredProcedureDatabases.Contains(providerName))
{
throw Oops.Oh(NotSupportException, typeof(NotSupportedException), "stored procedure");
}
}
public async Task DeleteAsync([Required, MinLength(1), MaxLength(20)] int[] userIds)
{
// 判断用户Id中是否有重复项
var isRepeat = userIds.GroupBy(i => i).Any(g => g.Count() > 1);
if (isRepeat)
{
throw Oops.Oh(SystemErrorCodes.u1011);
}
// 禁止删除自己
if (userIds.Contains(_userManager.UserId))
{
throw Oops.Oh(SystemErrorCodes.u1001);
}
// 查询所有存在且不被引用的用户
var users = await _userRepository.Include(u => u.Roles)
.Where(u => userIds.Contains(u.Id) && !u.Roles.Any())
.ToListAsync();
// 判断要操作的数据长度是是否等于传入数据的长度
if (userIds.Length != users.Count)
{
throw Oops.Oh(SystemErrorCodes.u1007);
}
var nowTime = DateTimeOffset.Now;
users.ForEach(u =>
{
u.UpdatedTime = nowTime;
u.IsDeleted = true;
});
}
