/// <summary>
/// 新增医护人员
/// </summary>
/// <param name="input">医护人员信息</param>
/// <returns>是否成功</returns>
public async Task <OutputBase> Add(AdminDoctorDto input)
{
if (await _repository.GetDoctorByPhone(input.Phone) != null)
{
return(OutputBase.Fail("该手机号已经注册"));
}
var doctor = new Doctor
{
Brithdate = input.Brithdate,
DeptId = input.DeptId,
HospitalId = input.HospitalId,
Name = input.Name,
Phone = input.Phone,
SelfDesc = input.SelfDesc,
Sex = input.Sex,
UserType = input.UserType,
TitleId = input.TitleId,
DialysisDoctorId = string.Empty,//默认
IsDelete = false
};
_repository.Add(doctor);
return(_unitWork.Commit() ? OutputBase.Success("新增成功") : OutputBase.Fail("新增失败"));
}
/// <summary>
/// 更新患者
/// </summary>
/// <param name="input">患者信息</param>
/// <returns>是否成功</returns>
public async Task <OutputBase> Update(AdminPatientDto input)
{
var patientContact = await _repository.GetPatientCotactById(input.Id);
if (input.Phone != patientContact.MobilePhone && await _repository.GetPatientCotactByPhone(input.Phone) != null)
{
return(OutputBase.Fail("该手机号已经注册"));
}
var patient = new Patient
{
Id = input.Id,
Brithdate = input.Brithdate,
DoctorId = input.DoctorId == -1 ? null : input.DoctorId,
HospitalId = input.HospitalId,
PatientName = input.PatientName,
PinyinCode = Utility.GetFirstPY(input.PatientName),
Remark = input.Remark,
Sex = input.Sex,
UserStatus = input.UserStatus
};
await _repository.UpdatePatient(patient);
var contact = new PatientContact
{
MobilePhone = input.Phone,
ContatctName = input.PatientName,
//Password = input.Password,
PatientId = input.Id
};
await _patientContactRepository.Update(contact);
return(_unitWork.Commit() ? OutputBase.Success("更新成功") : OutputBase.Fail("更新失败"));
}
/// <summary>
/// 同步患者联系人(新增或修改)
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <OutputBase> AddOrUpdate(AddPatientContactSync sync)
{
var patient = await _patientRepository.Get(sync.DialysisPatientId, sync.HospitalId);
if (patient == null)
{
return(OutputBase.Fail("不存在该患者"));
}
var patientContact = await _repository.Get(sync.DialysisContactId, sync.HospitalId);
if (patientContact == null)
{
var entity = Mapper.Map <AddPatientContactSync, PatientContact>(sync);
entity.PatientId = patient.Id;
_repository.Add(entity);
}
else
{
patientContact.PatientId = patient.Id;
patientContact.UpdateTime = DateTime.Now;
Mapper.Map(sync, patientContact);
}
return(_unitWork.Commit() ? OutputBase.Success("保存成功") : OutputBase.Fail("保存失败"));
}
/// <summary>
/// 新增血压
/// </summary>
/// <param name="input">新增血压请求</param>
/// <returns></returns>
public async Task <OutputBase> Add(AddBloodPressureInput input)
{
var patient = await _patientRepository.Get((int)input.PatientId);
if (patient == null)
{
return(OutputBase.Fail("该患者不存在"));
}
var entity = new BloodPressure
{
DataSource = input.DataSource,
PatientId = input.PatientId,
DiastolicPressure = input.DiastolicPressure,
DiastolicPressureIsNormal = ChronicDiseaseUtility.IsDiastolicPressureNormal(input.DiastolicPressure),
SystolicPressure = input.SystolicPressure,
SystolicPressureIsNormal = ChronicDiseaseUtility.IsSystolicPressureNormal(input.SystolicPressure),
HeartRate = input.HeartRate,
HeartRateIsNormal = ChronicDiseaseUtility.IsHeartRateNormal(input.HeartRate)
};
_bloodPressureRepository.Add(entity);
return(_unitWork.Commit() ? OutputBase.Success("已成功录入血压") : OutputBase.Fail("录入血压失败"));
}
/// <summary>
/// 同步体重
/// </summary>
/// <param name="sync"></param>
/// <returns></returns>
public async Task <OutputBase> Add(AddWeightSync sync)
{
if (await _repository.IsExist(sync.DialysisWeightId, sync.HospitalId))
{
return(OutputBase.Fail("此体重数据已存在"));
}
var patient = await _patientRepository.Get(sync.DialysisPatientId, sync.HospitalId);
if (patient == null)
{
return(OutputBase.Fail("此患者不存在"));
}
var weight = Mapper.Map <AddWeightSync, Weight>(sync);
#region 兼容华墨数据，华墨数据库中测量方式透后为1，我们平台统一为2
if (sync.MeasureType == 1)
{
weight.MeasureType = (int)MeasureTypeEnum.透后;
}
#endregion
weight.PatientId = patient.Id;
_repository.Add(weight);
return(_unitWork.Commit() ? OutputBase.Success("保存成功") : OutputBase.Fail("保存失败"));
}
/// <summary>
/// 新增患者
/// </summary>
/// <param name="input">患者信息</param>
/// <returns>是否成功</returns>
public async Task <OutputBase> Add(AdminPatientDto input)
{
if (await _repository.GetPatientCotactByPhone(input.Phone) != null)
{
return(OutputBase.Fail("该手机号已经注册"));
}
var patient = new Patient
{
Brithdate = input.Brithdate,
DialysisPatientId = 0,//默认
DoctorId = input.DoctorId == -1 ? null : input.DoctorId,
HospitalId = input.HospitalId,
PatientName = input.PatientName,
PinyinCode = Utility.GetFirstPY(input.PatientName),
Remark = input.Remark,
Sex = input.Sex,
UserStatus = input.UserStatus
};
var patientId = _repository.Add(patient);
var contact = new PatientContact
{
MobilePhone = input.Phone,
Relationship = CommConstant.OneselfRelationship,
ContatctName = input.PatientName,
DialysisContactId = 0,//默认
HospitalId = input.HospitalId,
PatientId = patientId
};
_patientContactRepository.Add(contact);
return(_unitWork.Commit() ? OutputBase.Success("新增成功") : OutputBase.Fail("新增失败"));
}
/// <summary>
/// 添加手环数据
/// </summary>
/// <param name="input">输入</param>
/// <returns></returns>
public async Task <OutputBase> Add(AddHandRingInput input)
{
if (await _patientRepository.GetPatientById(input.PatientId) == null)
{
return(OutputBase.Fail("患者不存在"));
}
foreach (var item in input.HandRingList)
{
if (!await _repository.IsExsit(input.PatientId, item.Date))
{
var entity = new HandRing
{
Date = item.Date,
Distance = item.Distance,
Energy = item.Energy,
SleepTime = item.SleepTime,
Steps = item.Steps,
PatientId = input.PatientId
};
_repository.Add(entity);
}
}
return(_unitWork.Commit() ? OutputBase.Success("保存成功") : OutputBase.Fail("保存失败"));
}
/// <summary>
/// 更新医护人员
/// </summary>
/// <param name="input">医护人员信息</param>
/// <returns>是否成功</returns>
public async Task <OutputBase> Update(AdminDoctorDto input)
{
var doctor = await _repository.GetDoctorById(input.Id);
if (doctor == null)
{
return(OutputBase.Fail("该医护人员不存在"));
}
if (doctor.Phone != input.Phone && await _repository.GetDoctorByPhone(input.Phone) != null)
{
return(OutputBase.Fail("该手机号已经注册"));
}
var entity = new Doctor
{
Id = input.Id,
Brithdate = input.Brithdate,
DeptId = input.DeptId,
HospitalId = input.HospitalId,
Name = input.Name,
Phone = input.Phone,
SelfDesc = input.SelfDesc,
Sex = input.Sex,
UserType = input.UserType,
TitleId = input.TitleId
};
await _repository.Update(entity);
return(_unitWork.Commit() ? OutputBase.Success("更新成功") : OutputBase.Fail("更新失败"));
}
/// <summary>
/// 删除医院
/// </summary>
/// <param name="id">医院Id</param>
/// <returns>是否成功</returns>
public OutputBase Delete(long id)
{
//if (await _repository.GetHospitalById(id) == null)
// return OutputBase.Fail("该医院已删除");
_repository.Delete(id);
return _unitWork.Commit() ? OutputBase.Success("删除成功") : OutputBase.Fail("删除失败");
}
/// <summary>
/// 新增血压
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public OutputBase Add(AddBloodPressureInput input)
{
var bloodPressure = Mapper.Map <AddBloodPressureInput, BloodPressure>(input);
bloodPressure.MeasureType = (int)MeasureTypeEnum.日常;
bloodPressure.MeasureMethod = (int)MeasureMethodEnum.App;
_repository.Add(bloodPressure);
return(_unitWork.Commit() ? OutputBase.Success("保存成功") : OutputBase.Fail("保存失败"));
}
/// <summary>
/// 新增体重
/// </summary>
/// <param name="input">体重输入</param>
/// <returns>是否成功</returns>
public OutputBase Add(AddWeightInput input)
{
var weight = Mapper.Map <AddWeightInput, Weight>(input);
var measureTime = DateTime.Now;
weight.MeasureTime = measureTime;
_repository.Add(weight);
return(_unitWork.Commit() ? OutputBase.Success("新增报警记录成功") : OutputBase.Fail("新增报警记录失败"));
}
/// <summary>
/// 删除医护人员
/// </summary>
/// <param name="dialysisDoctorId">透析医护人员Id（华墨系统Id）</param>
/// <param name="hospitalId">医院Id</param>
/// <returns>是否保存成功</returns>
public async Task <OutputBase> DeleteDoctor(long hospitalId, string dialysisDoctorId)
{
var doctor = await _repository.Get(dialysisDoctorId, hospitalId);
if (doctor == null)
{
return(OutputBase.Fail("该医生不存在"));
}
_repository.Delete(doctor);
return(_unitWork.Commit() ? OutputBase.Success("删除成功") : OutputBase.Fail("该医生不存在"));
}
/// <summary>
/// 保存患教
/// </summary>
/// <param name="input">患教输入</param>
/// <returns>是否保存成功</returns>
public async Task <OutputBase> Add(AddPatientEduInput input)
{
var doctor = await _doctorRepository.GetDoctorById(input.DoctorId);
if (doctor == null)
{
return(OutputBase.Fail("医生Id参数不正确，该医护人员不存在"));
}
if (input.PatientIds.Count < 1)
{
return(OutputBase.Fail("患者Id数组参数个数不能为0"));
}
if (input.CourseList.Count < 1)
{
return(OutputBase.Fail("课程列表参数个数不能为0"));
}
string content = string.Format("{0}医生向您发送了新的课程", doctor.Name);
var patientEduList = new List <PatientEducation>();
foreach (var patientId in input.PatientIds)
{
var batchNumber = DateTime.Now.ToString(CommConstant.FullTimeFormatString);
foreach (var course in input.CourseList)
{
_repository.Add(course, patientId, input.DoctorId, batchNumber);
}
var messageEntity = new Message
{
IsRead = false,
OuterId = batchNumber + input.DoctorId.ToString().PadLeft(18, '0') + patientId.ToString().PadLeft(18, '0'),
Content = content,
ReceiveId = patientId,
Title = "患教课程",
Type = (int)MessageTypeEnum.患教课程,
SendId = input.DoctorId,
SendName = doctor.Name,
Url = string.Empty,
AppType = (int)AppTypeEnum.Patient
};
_messageRepository.Add(messageEntity);
#region 异步发送JPush Notification、Message
ThreadPool.QueueUserWorkItem(delegate
{
new JPushMessage(AppTypeEnum.Patient, (int)JPushKeyEnum.PatientEducation, patientId.ToString(), content, messageEntity.OuterId, _optionsAccessor.IsDevModel).SendPush();
new JPushNotification(AppTypeEnum.Patient, (int)JPushKeyEnum.PatientEducation, patientId.ToString(), content, messageEntity.OuterId, _optionsAccessor.IsDevModel).SendPush();
});
#endregion
}
return(_unitWork.Commit() ? OutputBase.Success("保存成功") : OutputBase.Fail("保存失败"));
}
/// <summary>
/// 同步透析下机
/// </summary>
/// <param name="sync"></param>
/// <returns></returns>
public async Task <OutputBase> AddDialysisOff(AddDialysisOffSync sync)
{
var dialysis = await _repository.Get(sync.DialysisRecordId, sync.HospitalId);
if (dialysis == null)
{
return(OutputBase.Fail("不存在透析上机记录"));
}
dialysis.ConfirmedUFV = sync.ConfirmedUFV;
dialysis.StartTime = sync.StartTime;
dialysis.OffSystolicPressure = sync.OffSystolicPressure;
dialysis.OffDiastolicPressure = sync.OffDiastolicPressure;
dialysis.OffPulseRate = sync.OffPulseRate;
dialysis.OffBreath = sync.OffBreath;
dialysis.PostWeight = sync.PostWeight;
dialysis.ActualUFV = sync.ActualUFV;
dialysis.EndTime = sync.EndTime;
dialysis.OffNurse = sync.OffNurse;
dialysis.Summary = sync.Summary;
#region 添加下机Message
var endTime = sync.EndTime.GetValueOrDefault();
var content = string.Format("下机时间： {0}", endTime.ToString(CommConstant.TimeFormatString));
var message = new Domain.Models.Message
{
AppType = (int)AppTypeEnum.Patient,
Content = content,
IsRead = false,
ReceiveId = dialysis.PatientId,
SendId = 0,
SendName = "系统",
Title = "透析前下机测量",
Type = (int)MessageTypeEnum.透析下机,
OuterId = dialysis.Id.ToString()
};
_messageRepository.Add(message);
#endregion
if (!_unitWork.Commit())
{
OutputBase.Fail("保存失败");
}
#region 向患者端异步发送下机JPush
ThreadPool.QueueUserWorkItem(delegate
{
new JPushMessage(AppTypeEnum.Patient, (int)JPushKeyEnum.DialysisOff, dialysis.PatientId.ToString(), content, dialysis.Id.ToString(), _optionsAccessor.IsDevModel).SendPush();
new JPushNotification(AppTypeEnum.Patient, (int)JPushKeyEnum.DialysisOff, dialysis.PatientId.ToString(), content, dialysis.Id.ToString(), _optionsAccessor.IsDevModel).SendPush();
});
#endregion
return(OutputBase.Success("保存成功"));
}
/// <summary>
/// 更新课程类别
/// </summary>
/// <param name="model">课程类别信息</param>
/// <returns>是否成功</returns>
public async Task <OutputBase> Update(AdminCourseCategoryDto model)
{
var entity = new Dictionary
{
Description = model.Description,
Name = model.Name,
Id = model.Id
};
await _systemRepository.UpdateDictionary(entity);
return(_unitWork.Commit() ? OutputBase.Success("更新课程类别成功") : OutputBase.Fail("更新课程类别失败"));
}
/// <summary>
/// 同步透析小结
/// </summary>
/// <param name="sync"></param>
/// <returns></returns>
public async Task <OutputBase> AddDialysisSummary(AddDialysisSummarySync sync)
{
var dialysis = await _repository.Get(sync.DialysisRecordId, sync.HospitalId);
if (dialysis == null)
{
return(OutputBase.Fail("不存在透析记录"));
}
dialysis.Summary = sync.Summary;
return(_unitWork.Commit() ? OutputBase.Success("保存成功") : OutputBase.Fail("保存失败"));
}
/// <summary>
/// 新增患者
/// </summary>
/// <param name="input">患者信息</param>
/// <returns>是否成功</returns>
public OutputBase Add(AdminPatientDto input)
{
var patient = new Patient
{
Brithdate = input.Brithdate,
PatientName = input.PatientName,
Sex = input.Sex,
};
var patientId = _repository.Add(patient);
return(_unitWork.Commit() ? OutputBase.Success("新增成功") : OutputBase.Fail("新增失败"));
}
/// <summary>
/// 更新课程信息
/// </summary>
/// <param name="model">课程信息</param>
/// <returns>是否成功</returns>
public async Task <OutputBase> Update(AdminCourseDto model)
{
var entity = new Course
{
Content = model.Content,
Title = model.Title,
Type = model.Category,
Id = model.Id
};
await _repository.Update(entity);
return(_unitWork.Commit() ? OutputBase.Success("更新课程成功") : OutputBase.Fail("更新课程失败"));
}
/// <summary>
/// 新增后台用户
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public OutputBase Add(AdministratorDto model)
{
var administator = new Administrator
{
LoginName = model.LoginName,
IsSuperManager = model.IsSuperManager,
HospitalId = model.HospitalId,
};
_repository.AddUser(administator);
return(_unitWork.Commit() ? OutputBase.Success("新增成功") : OutputBase.Fail("新增失败"));
}
/// <summary>
/// 更新患者
/// </summary>
/// <param name="input">患者信息</param>
/// <returns>是否成功</returns>
public async Task <OutputBase> Update(AdminPatientDto input)
{
var patient = new Patient
{
Id = input.Id,
Brithdate = input.Brithdate,
PatientName = input.PatientName,
Sex = input.Sex
};
await _repository.UpdatePatient(patient);
return(_unitWork.Commit() ? OutputBase.Success("更新成功") : OutputBase.Fail("更新失败"));
}
/// <summary>
/// 新增医院
/// </summary>
/// <param name="model">医院信息</param>
/// <returns>是否成功</returns>
public async Task<OutputBase> Add(AdminHospitalDto model)
{
if (await _repository.GetHospitalByName(model.HospitalName) != null)
return OutputBase.Fail("同名医院已存在");
var entity = new Hospital
{
CityId = model.CityId,
HospitalName = model.HospitalName
};
_repository.Add(entity);
return _unitWork.Commit() ? OutputBase.Success("新增成功") : OutputBase.Fail("新增失败");
}
/// <summary>
/// 修改后台用户
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task <OutputBase> Update(AdministratorDto model)
{
var administrator = await _repository.GetAdministratorById(model.Id);
if (administrator == null)
{
return(OutputBase.Fail("该用户不存在"));
}
administrator.LoginName = model.LoginName;
administrator.IsSuperManager = model.IsSuperManager;
administrator.HospitalId = model.HospitalId;
administrator.UpdateTime = DateTime.Now;
return(_unitWork.Commit() ? OutputBase.Success("更新成功") : OutputBase.Fail("更新失败"));
}
/// <summary>
/// 同步排班(新增或修改)
/// </summary>
/// <param name="sync"></param>
/// <returns></returns>
public async Task <OutputBase> AddOrUpdate(AddShiftSync sync)
{
var shift = await _repository.Get(sync.DialysisShiftId, sync.HospitalId);
if (shift == null)
{
_repository.Add(Mapper.Map <AddShiftSync, Shift>(sync));
}
else
{
Mapper.Map(sync, shift);
}
return(_unitWork.Commit() ? OutputBase.Success("保存成功") : OutputBase.Fail("保存失败"));
}
/// <summary>
/// 新建课程
/// </summary>
/// <param name="model">课程信息</param>
/// <returns>是否成功</returns>
public async Task <OutputBase> Add(AdminCourseDto model)
{
var sortId = await _repository.GetCourseMaxSortId(model.Category);
var entity = new Course
{
Content = model.Content,
SortId = sortId == 0 ? 1 : (sortId + 1),
Title = model.Title,
Type = model.Category
};
_repository.Add(entity);
return(_unitWork.Commit() ? OutputBase.Success("新增课程成功") : OutputBase.Fail("新增课程失败"));
}
/// <summary>
/// 同步医护人员（新增或修改）
/// </summary>
/// <param name="sync"></param>
/// <returns>是否保存成功</returns>
public async Task <OutputBase> AddOrUpdate(AddDoctorSync sync)
{
var doctor = await _repository.Get(sync.DialysisDoctorId, sync.HospitalId);
if (doctor == null)
{
_repository.Add(Mapper.Map <AddDoctorSync, Doctor>(sync));
}
else
{
Mapper.Map <AddDoctorSync, Doctor>(sync, doctor);
doctor.UpdateTime = DateTime.Now;
}
return(_unitWork.Commit() ? OutputBase.Success("保存成功") : OutputBase.Fail("保存失败"));
}
/// <summary>
/// 调用Action前验证Model
/// </summary>
/// <param name="context"></param>
public override void OnActionExecuting(ActionExecutingContext context)
{
if (!context.ModelState.IsValid)
{
string errorMessage;
var firstValue = context.ModelState.Where(m => m.Value.Errors.Count > 0).FirstOrDefault().Value; //取出第一个错误信息
if (firstValue.Errors.Count > 0)
{
errorMessage = firstValue.Errors.FirstOrDefault().ErrorMessage;
}
else
{
errorMessage = "参数错误";
}
context.Result = new OkObjectResult(OutputBase.Fail(errorMessage));
}
}
/// <summary>
/// 更新医院
/// </summary>
/// <param name="model">医院信息</param>
/// <returns>是否成功</returns>
public async Task<OutputBase> Update(AdminHospitalDto model)
{
var hospital = await _repository.GetHospitalById(model.Id);
if (hospital == null)
return OutputBase.Fail("该医院不存在");
if (model.HospitalName != hospital.HospitalName && await _repository.GetHospitalByName(model.HospitalName) != null)
return OutputBase.Fail("同名医院已存在");
var entity = new Hospital
{
Id = model.Id,
CityId = model.CityId,
HospitalName = model.HospitalName
};
await _repository.Update(entity);
return _unitWork.Commit() ? OutputBase.Success("更新成功") : OutputBase.Fail("更新失败");
}
/// <summary>
/// 确认报警记录
/// </summary>
/// <param name="input">确认报警记录输入</param>
/// <returns>是否成功</returns>
public async Task <OutputBase> ConfirmAlarm(ConfirmAlarmInput input)
{
var alarm = await _repository.GetAlarmById(input.AlarmId);
if (alarm == null)
{
return(OutputBase.Fail("该报警记录不存在"));
}
var doctor = await _doctorRepository.GetDoctorById(input.DoctorId);
if (doctor == null)
{
return(OutputBase.Fail("确认的医护人员不存在"));
}
await _repository.ConfirmAlarm(input.AlarmId);
string content = string.Format("{0}医生确认了您的体重预警", doctor.Name);
var entity = new Message
{
IsRead = false,
Content = content,
ReceiveId = alarm.PatientId,
Title = "确认体重预警",
Type = (int)MessageTypeEnum.确认体重预警,
SendId = input.DoctorId,
SendName = doctor.Name,
Url = string.Empty,
OuterId = input.AlarmId.ToString(),
AppType = (int)AppTypeEnum.Patient
};
_messageRepository.Add(entity);
if (!_unitWork.Commit())
{
return(OutputBase.Fail("确认失败"));
}
#region 异步发送JPush Notification、Message
ThreadPool.QueueUserWorkItem(delegate
{
new JPushMessage(AppTypeEnum.Patient, (int)JPushKeyEnum.ConfirmAlarm, alarm.PatientId.ToString(), content, entity.OuterId, _optionsAccessor.IsDevModel).SendPush();
new JPushNotification(AppTypeEnum.Patient, (int)JPushKeyEnum.ConfirmAlarm, alarm.PatientId.ToString(), content, entity.OuterId, _optionsAccessor.IsDevModel).SendPush();
});
#endregion
return(OutputBase.Success("确认成功"));
}
/// <summary>
/// 患者微信绑定
/// </summary>
/// <param name="input">绑定输入</param>
/// <returns></returns>
public async Task <OutputBase> BindWeixin(BindWeixinInput input)
{
var patient = await _repository.GetByIdNo(input.IdNo);
if (patient == null)
{
return(OutputBase.Fail("不存在该患者"));
}
if (!string.IsNullOrEmpty(patient.WxOpenId))
{
return(OutputBase.Fail("此患者已绑定微信"));
}
patient.WxOpenId = input.OpenId;
patient.UpdateTime = DateTime.Now;
return(_unitWork.Commit() ? OutputBase.Success("绑定成功") : OutputBase.Fail("绑定失败"));
}
/// <summary>
/// 新建课程类别
/// </summary>
/// <param name="model">课程类别信息</param>
/// <returns>是否成功</returns>
public async Task <OutputBase> Add(AdminCourseCategoryDto model)
{
int value = await _systemRepository.GetMaxIdByParentValue(CommConstant.PatientEduParentValue);
int sortId = await _systemRepository.GetMaxSortIdByParentValue(CommConstant.PatientEduParentValue);
var entity = new Dictionary
{
Id = value == 0 ? 1 : (value + 1),
Description = model.Description,
Name = model.Name,
ParentValue = CommConstant.PatientEduParentValue,
SortId = sortId == 0 ? 1 : (sortId + 1)
};
_systemRepository.AddDictionary(entity);
return(_unitWork.Commit() ? OutputBase.Success("新增课程类别成功") : OutputBase.Fail("新增课程类别失败"));
}