/// <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("保存失败"));
}
public void AddCategory(CategoryDto categoryDto)
{
var category = Mapper.Map <CategoryDto, Category>(categoryDto);
Database.CategoryRepo.Insert(category);
Database.Commit();
}
/// <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="header">上传的附件头</param>
/// <param name="path">附件所在的路径</param>
/// <returns></returns>
public CommandResult Upload(AttachmentHeader header, string path)
{
try
{
if (!File.Exists(path))
{
return(new CommandResult(ResultCode.Fail, string.Format("文件\"{0}\"不存在", path)));
}
byte[] bs = null;
using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read))
{
if (fs.Length <= MAXFILENAME)
{
bs = new byte[fs.Length];
fs.Position = 0;
fs.Read(bs, 0, (int)fs.Length);
IUnitWork unitWork = ProviderFactory.Create <IUnitWork>(_RepoUri);
ProviderFactory.Create <IProvider <AttachmentHeader, Guid> >(_RepoUri).Insert(header, unitWork); //插入附件头
Attachment a = new Attachment();
a.ID = header.ID;
a.Value = bs;
ProviderFactory.Create <IProvider <Attachment, Guid> >(_RepoUri).Insert(a, unitWork); //插入附件内容
return(unitWork.Commit());
}
else
{
return(new CommandResult(ResultCode.Fail, string.Format("文件\"{0}\" 太大，不能上传,如果要上传此文件，请先更改系统最大上传文件大小", path)));
}
}
}
catch (Exception ex)
{
return(new CommandResult(ResultCode.Fail, ex.Message));
}
}
public override CommandResult Add(InventoryCheckRecord info)
{
IUnitWork unitWork = ProviderFactory.Create <IUnitWork>(RepoUri);
ProductInventorySearchCondition con = new ProductInventorySearchCondition();
con.ProductID = info.ProductID;
con.WareHouseID = info.WarehouseID;
List <ProductInventory> items = ProviderFactory.Create <IProvider <ProductInventory, Guid> >(RepoUri).GetItems(con).QueryObjects;
if (items == null || items.Count == 0)
{
throw new Exception("没有该产品的库存项");
}
ProductInventory pi = items[0];
if (info.Inventory != pi.Count)
{
throw new Exception("产品库存有改动，请重新操作");
}
if (info.CheckCount > pi.Count) //盘盈
{
InventoryIn(info, unitWork);
}
else if (info.CheckCount < pi.Count) //盘亏
{
InventoryOut(info, UserSettings.Current.InventoryOutType, unitWork);
}
ProviderFactory.Create <IProvider <InventoryCheckRecord, Guid> >(RepoUri).Insert(info, unitWork);
return(unitWork.Commit());
}
public CommandResult ShiftArrange(int staffID, DateTime dt, List <Shift> shifts)
{
IShiftArrangeProvider provider = ProviderFactory.Create <IShiftArrangeProvider>(_RepoUri);
ShiftArrangeSearchCondition con = new ShiftArrangeSearchCondition();
con.StaffID = staffID;
con.ShiftDate = new DatetimeRange(dt, dt);
List <ShiftArrange> items = provider.GetItems(con).QueryObjects;
IUnitWork unitWork = ProviderFactory.Create <IUnitWork>(_RepoUri);
foreach (ShiftArrange item in items)
{
provider.Delete(item, unitWork);
}
if (shifts != null && shifts.Count > 0)
{
foreach (Shift item in shifts)
{
ShiftArrange sa = new Model.ShiftArrange()
{
StaffID = staffID,
ShiftID = item.ID,
ShiftDate = dt
};
provider.Insert(sa, unitWork);
}
}
return(unitWork.Commit());
}
/// <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="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>
public CommandResult DeleteCard(CardInfo info)
{
if (info.Status == CardStatus.Enabled && !info.IsTempCard && !info.IsManagedCard)
{
throw new InvalidOperationException(Resource1.CardBll_CannotDelete);
}
else
{
string op = OperatorInfo.CurrentOperator.OperatorName;
string station = WorkStationInfo.CurrentStation.StationName;
IUnitWork unitWork = ProviderFactory.Create <IUnitWork>(_RepoUri);
CardDeleteRecord record = new CardDeleteRecord
{
CardID = info.CardID,
OwnerName = info.OwnerName,
CardCertificate = info.CardCertificate,
CarPlate = info.CarPlate,
DeleteDateTime = DateTime.Now,
CardType = info.CardType,
Balance = info.Balance,
ValidDate = info.ValidDate,
Deposit = info.Deposit,
OperatorID = op,
StationID = station
};
ICardDeleteRecordProvider icdp = ProviderFactory.Create <ICardDeleteRecordProvider>(_RepoUri);
icdp.Insert(record, unitWork);
_Provider.Delete(info, unitWork);
return(unitWork.Commit());
}
}
public CommandResult AddReadLog(string deviceID, DateTime dt, decimal value)
{
var device = GetByID(deviceID).QueryObject;
if (device != null)
{
var provider = ProviderFactory.Create <IProvider <Device, string> >(RepoUri);
IUnitWork unitWork = provider.CreateUnitWork();
DeviceReadLog log = null;
if (device.LastDate.HasValue && device.LastValue < value)
{
log = new DeviceReadLog()
{
ID = Guid.NewGuid(),
DeviceID = device.ID,
DeviceName = device.Name,
DeviceType = device.DeviceType,
ReadDate = dt,
ReadValue = value,
LastDate = device.LastDate.Value,
LastValue = device.LastValue.Value,
Amount = value - device.LastValue.Value
};
ProviderFactory.Create <IProvider <DeviceReadLog, Guid> >(RepoUri).Insert(log, unitWork);
}
var clone = device.Clone();
clone.LastDate = dt;
clone.LastValue = log != null ? (clone.LastValue + log.Amount) : value; //记录设备上次的读数时以记录里实际扣除的数为准
provider.Update(clone, device, unitWork);
return(unitWork.Commit());
}
return(new CommandResult(ResultCode.Fail, "没有找到符合条件的设备"));
}
/// <summary>
/// 卡片延期
/// </summary>
/// <param name="info"></param>
/// <param name="newValidDate"></param>
/// <param name="paymentMode"></param>
/// <param name="money"></param>
/// <param name="memo"></param>
/// <param name="keepParkingStatus">是否保持卡片运行状态</param>
/// <returns></returns>
public CommandResult CardDefer(CardInfo info, DateTime newValidDate, PaymentMode paymentMode, decimal money, string memo, bool keepParkingStatus)
{
string op = OperatorInfo.CurrentOperator.OperatorName;
string station = WorkStationInfo.CurrentStation.StationName;
IUnitWork unitWork = ProviderFactory.Create <IUnitWork>(_RepoUri);
CardDeferRecord record = new CardDeferRecord
{
CardID = info.CardID,
OwnerName = info.OwnerName,
CardCertificate = info.CardCertificate,
CarPlate = info.CarPlate,
OriginalDate = info.ValidDate,
CurrentDate = newValidDate,
DeferDateTime = DateTime.Now,
PaymentMode = paymentMode,
DeferMoney = money,
OperatorID = op,
StationID = station,
Memo = memo
};
ICardDeferRecordProvider recordProvider = ProviderFactory.Create <ICardDeferRecordProvider>(_RepoUri);
recordProvider.Insert(record, unitWork);
info.ValidDate = newValidDate;
if (keepParkingStatus)
{
UpdateCard(info, unitWork);
}
else
{
//写卡模式以卡片运行状态为准
UpdateCardAll(info, unitWork);
}
return(unitWork.Commit());
}
/// <summary>
/// 卡片挂失
/// </summary>
/// <param name="info"></param>
/// <param name="reason"></param>
/// <param name="lostCardCost"></param>
/// <param name="paymode"></param>
/// <param name="keepParkingStatus">是否保持数据库中的卡片运行状态</param>
public CommandResult CardLoss(CardInfo info, string reason, decimal lostCardCost, PaymentMode paymode, bool keepParkingStatus)
{
string op = OperatorInfo.CurrentOperator.OperatorName;
string station = WorkStationInfo.CurrentStation.StationName;
IUnitWork unitWork = ProviderFactory.Create <IUnitWork>(_RepoUri);
CardLostRestoreRecord record = new CardLostRestoreRecord
{
CardID = info.CardID,
OwnerName = info.OwnerName,
CardCertificate = info.CardCertificate,
CarPlate = info.CarPlate,
CardStatus = (byte)info.Status, //保存卡片的原有卡状态
LostDateTime = DateTime.Now,
LostOperator = op,
LostStation = station,
LostMemo = reason,
LostCardCost = lostCardCost,
PaymentMode = paymode
};
ICardLostRestoreRecordProvider lostProvider = ProviderFactory.Create <ICardLostRestoreRecordProvider>(_RepoUri);
info.Lost();
lostProvider.Insert(record, unitWork);
if (keepParkingStatus)
{
UpdateCard(info, unitWork);
}
else
{
UpdateCardAll(info, unitWork);
}
return(unitWork.Commit());
}
/// <summary>
/// 卡片解禁
/// </summary>
/// <param name="info"></param>
/// <param name="reason"></param>
/// <param name="keepParkingStatus">是否保持卡片运行状态</param>
/// <returns></returns>
public CommandResult CardEnable(CardInfo info, string reason, bool keepParkingStatus)
{
string op = OperatorInfo.CurrentOperator.OperatorName;
string station = WorkStationInfo.CurrentStation.StationName;
IUnitWork unitWork = ProviderFactory.Create <IUnitWork>(_RepoUri);
CardDisableEnableRecord record = new CardDisableEnableRecord
{
CardID = info.CardID,
EnableDateTime = DateTime.Now,
EnableOperator = op,
EnableStationID = station,
EnableMemo = reason,
};
ICardDisableEnableRecordProvider recordProvider = ProviderFactory.Create <ICardDisableEnableRecordProvider>(_RepoUri);
recordProvider.Insert(record, unitWork);
info.Enable();
if (keepParkingStatus)
{
UpdateCard(info, unitWork);
}
else
{
UpdateCardAll(info, unitWork);
}
return(unitWork.Commit());
}
/// <summary>
/// 取消客户收款和应收款已核销项
/// </summary>
/// <param name="assign"></param>
/// <returns></returns>
public CommandResult UndoAssign(CustomerPaymentAssign assign)
{
if (assign == null)
{
return(new CommandResult(ResultCode.Fail, "没有分配项"));
}
IUnitWork unitWork = ProviderFactory.Create <IUnitWork>(RepoUri);
CustomerPayment cp = ProviderFactory.Create <IProvider <CustomerPayment, string> >(RepoUri).GetByID(assign.PaymentID).QueryObject;
if (cp != null && cp.Assigned >= assign.Amount)
{
CustomerReceivable cr = ProviderFactory.Create <IProvider <CustomerReceivable, Guid> >(RepoUri).GetByID(assign.ReceivableID).QueryObject;
if (cr != null && cr.Haspaid >= assign.Amount)
{
CustomerPayment cp1 = cp.Clone() as CustomerPayment;
CustomerReceivable cr1 = cr.Clone() as CustomerReceivable;
cp.Assigned -= assign.Amount;
cr.Haspaid -= assign.Amount;
ProviderFactory.Create <IProvider <CustomerPayment, string> >(RepoUri).Update(cp, cp1, unitWork);
ProviderFactory.Create <IProvider <CustomerReceivable, Guid> >(RepoUri).Update(cr, cr1, unitWork);
ProviderFactory.Create <IProvider <CustomerPaymentAssign, Guid> >(RepoUri).Delete(assign, unitWork);
}
}
return(unitWork.Commit());
}
/// <summary>
/// 优惠券使用
/// </summary>
/// <param name="id"></param>
/// <param name="proxyID"></param>
/// <returns></returns>
public CommandResult AssignTo(string id, string proxyID)
{
YouhuiQuan item = GetByID(id).QueryObject;
if (item == null)
{
return(new CommandResult(ResultCode.Fail, string.Format("ID={0} 的优惠券不存在", id)));
}
if (!string.IsNullOrEmpty(item.Proxy))
{
return(new CommandResult(ResultCode.Fail, string.Format("ID={0} 的优惠券已经被使用", id)));
}
CompanyInfo proxy = ProviderFactory.Create <IProvider <CompanyInfo, string> >(RepoUri).GetByID(proxyID).QueryObject;
if (proxy == null)
{
return(new CommandResult(ResultCode.Fail, string.Format("ID={0} 的代理商不存在", proxyID)));
}
YouhuiQuan original = item.Clone();
item.Proxy = proxyID;
item.ComsumeDate = DateTime.Now;
IUnitWork unitWork = ProviderFactory.Create <IUnitWork>(RepoUri);
ProviderFactory.Create <IProvider <YouhuiQuan, string> >(RepoUri).Update(item, original, unitWork);
return(unitWork.Commit());
}
/// <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="staffID"></param>
/// <param name="range"></param>
/// <param name="arranges"></param>
/// <returns></returns>
public CommandResult Add(int staffID, DatetimeRange range, List <AttendanceResult> arranges)
{
IAttendanceResultProvider provider = ProviderFactory.Create <IAttendanceResultProvider>(_RepoUri);
StaffAttendanceResultSearchCondition con = new StaffAttendanceResultSearchCondition();
con.Staff = new List <int>();
con.Staff.Add(staffID);
con.ShiftDate = range;
List <AttendanceResult> items = provider.GetItems(con).QueryObjects;
IUnitWork unitWork = ProviderFactory.Create <IUnitWork>(_RepoUri);
foreach (AttendanceResult item in items)
{
provider.Delete(item, unitWork);
}
if (arranges != null && arranges.Count > 0)
{
foreach (AttendanceResult item in arranges)
{
if (item.AbsentItems != null && item.AbsentItems.Count > 0)
{
item.AbsentItems.ForEach(it => it.ResultID = item.ID);
}
provider.Insert(item, unitWork);
}
}
return(unitWork.Commit());
}
public void AddError(ErrorDto errorDto)
{
var error = Mapper.Map <ErrorDto, Error>(errorDto);
Database.ErrorRepo.Insert(error);
Database.Commit();
}
/// <summary>
/// 卡片回收
/// </summary>
/// <param name="info"></param>
/// <param name="recycleMoney"></param>
/// <param name="memo"></param>
/// <param name="keepParkingStatus">是否保持卡片运行状态</param>
/// <returns></returns>
public CommandResult CardRecycle(CardInfo info, decimal recycleMoney, string memo, bool keepParkingStatus)
{
string op = OperatorInfo.CurrentOperator.OperatorName;
string station = WorkStationInfo.CurrentStation.StationName;
IUnitWork unitWork = ProviderFactory.Create <IUnitWork>(_RepoUri);
CardRecycleRecord record = new CardRecycleRecord
{
CardID = info.CardID,
OwnerName = info.OwnerName,
CardCertificate = info.CardCertificate,
CarPlate = info.CarPlate,
RecycleDateTime = DateTime.Now,
CardType = info.CardType,
Balance = info.Balance,
ValidDate = info.ValidDate,
Deposit = info.Deposit,
RecycleMoney = recycleMoney,
OperatorID = op,
StationID = station,
Memo = memo
};
ICardRecycleRecordProvider recordProvider = ProviderFactory.Create <ICardRecycleRecordProvider>(_RepoUri);
recordProvider.Insert(record, unitWork);
info.Recycle();
if (keepParkingStatus)
{
UpdateCard(info, unitWork);
}
else
{
UpdateCardAll(info, unitWork);
}
return(unitWork.Commit());
}
/// <summary>
/// 保存卡片以及嵌套车场进出事件
/// </summary>
/// <param name="card"></param>
/// <param name="report"></param>
/// <returns></returns>
public CommandResult SaveCardAndNestedEvent(CardInfo card, CardEventReport report)
{
//内嵌车场事件只改变卡片的停车状态
IUnitWork unitWork = ProviderFactory.Create <IUnitWork>(_RepoUri);
CardInfo info = card.Clone();
//卡片状态保持用数据库中的状态
info.ParkingStatus = report.ParkingStatus;
if (!report.IsExitEvent)
{
info.LastNestParkDateTime = report.EventDateTime; //如果是入场事件，则更新卡片的最后进入内车场时间
}
_Provider.Update(info, card, unitWork);
ICardEventProvider icp = ProviderFactory.Create <ICardEventProvider>(_RepoUri);
if (report.IsExitEvent) //如果是入内车场，则不记录最后刷卡时间，如果是出内车场，则保存上次时间
{
report.LastDateTime = card.LastNestParkDateTime;
}
else
{
report.LastDateTime = null;
}
icp.Insert((new CardEventRecord(report)), unitWork);
CommandResult ret = unitWork.Commit();
if (ret.Result == ResultCode.Successful) //如果成功，则改变卡片状态
{
//卡片状态保持用数据库中的状态
card.ParkingStatus = report.ParkingStatus;
}
return(ret);
}
/// <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("保存失败"));
}
public override CommandResult Delete(CompanyInfo info)
{
StackOutSheetSearchCondition con = new StackOutSheetSearchCondition();
con.CustomerID = info.ID;
List <StackOutSheet> items = (new StackOutSheetBLL(RepoUri)).GetItems(con).QueryObjects;
if (items != null && items.Count > 0)
{
return(new CommandResult(ResultCode.Fail, string.Format("不能删除客户 {0} 的资料，系统中已经存在此客户的送货单", info.Name)));
}
IUnitWork unitWork = ProviderFactory.Create <IUnitWork>(RepoUri);
CustomerPaymentSearchCondition con1 = new CustomerPaymentSearchCondition()
{
CustomerID = info.ID
};
List <CustomerPayment> cps = ProviderFactory.Create <IProvider <CustomerPayment, string> >(RepoUri).GetItems(con1).QueryObjects;
if (cps != null && cps.Count > 0)
{
foreach (CustomerPayment cp in cps)
{
ProviderFactory.Create <IProvider <CustomerPayment, string> >(RepoUri).Delete(cp, unitWork);
}
}
CustomerOtherReceivableSearchCondition con2 = new CustomerOtherReceivableSearchCondition()
{
CustomerID = info.ID
};
List <CustomerOtherReceivable> cds = ProviderFactory.Create <IProvider <CustomerOtherReceivable, string> >(RepoUri).GetItems(con2).QueryObjects;
if (cds != null && cds.Count > 0)
{
foreach (CustomerOtherReceivable cd in cds)
{
ProviderFactory.Create <IProvider <CustomerOtherReceivable, string> >(RepoUri).Delete(cd, unitWork);
}
}
CustomerReceivableSearchCondition con3 = new CustomerReceivableSearchCondition()
{
CustomerID = info.ID
};
List <CustomerReceivable> crs = ProviderFactory.Create <IProvider <CustomerReceivable, Guid> >(RepoUri).GetItems(con3).QueryObjects;
if (crs != null && crs.Count > 0)
{
foreach (CustomerReceivable cr in crs)
{
ProviderFactory.Create <IProvider <CustomerReceivable, Guid> >(RepoUri).Delete(cr, unitWork);
}
}
ProviderFactory.Create <IProvider <CompanyInfo, string> >(RepoUri).Delete(info, unitWork);
return(unitWork.Commit());
}
/// <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("新增课程类别失败"));
}
/// <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="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("保存失败"));
}
public CommandResult Delete(DeviceGroup info)
{
List <DeviceGroup> depts = ProviderFactory.Create <IDeviceGroupProvider>(_RepoUri).GetItems(null).QueryObjects;
IUnitWork unitWork = ProviderFactory.Create <IUnitWork>(_RepoUri);
foreach (DeviceGroup dept in depts.Where(item => item.ID.IndexOf(info.ID, 0) == 0))
{
ProviderFactory.Create <IDeviceGroupProvider>(_RepoUri).Delete(dept, unitWork);
}
return(unitWork.Commit());
}
/// <summary>
/// 同步血压
/// </summary>
/// <param name="sync"></param>
/// <returns></returns>
public async Task <OutputBase> Add(AddBloodPressureSync sync)
{
if (await _repository.IsExist(sync.DialysisBloodPressureId, sync.HospitalId))
{
return(OutputBase.Fail("此血压数据已存在"));
}
var patient = await _patientRepository.Get(sync.DialysisPatientId, sync.HospitalId);
if (patient == null)
{
return(OutputBase.Fail("此患者不存在"));
}
var bloodPressure = Mapper.Map <AddBloodPressureSync, BloodPressure>(sync);
bloodPressure.PatientId = patient.Id;
_repository.Add(bloodPressure);
return(_unitWork.Commit() ? OutputBase.Success("保存成功") : OutputBase.Fail("保存失败"));
}
public CommandResult BatchInsert(List <YCTBlacklist> records)
{
IUnitWork unitWork = ProviderFactory.Create <IUnitWork>(_RepoURI);
IYCTBlacklistProvider provider = ProviderFactory.Create <IYCTBlacklistProvider>(_RepoURI);
foreach (var item in records)
{
provider.Insert(item, unitWork);
}
return(unitWork.Commit());
}
/// <summary>
/// 将库存分配给某个订单项,分配给某个订单项的库存不能再用于其它订单的出货，只能用于该订单项出货
/// </summary>
/// <param name="pi"></param>
/// <param name="orderItem"></param>
/// <param name="count"></param>
/// <returns></returns>
public CommandResult Reserve(string warehouseID, string productID, Guid orderItem, string orderID, decimal count)
{
IUnitWork unitWork = ProviderFactory.Create <IUnitWork>(RepoUri);
ProductInventoryItemSearchCondition con = new ProductInventoryItemSearchCondition();
con.Products = new List <string>();
con.Products.Add(productID);
con.WareHouseID = warehouseID;
con.UnShipped = true; //未发货的库存项
con.UnReserved = true; //未分配给某个特定的订单
List <ProductInventoryItem> items = ProviderFactory.Create <IProvider <ProductInventoryItem, Guid> >(RepoUri).GetItems(con).QueryObjects;
if (items.Sum(item => item.Count) < count)
{
return(new CommandResult(ResultCode.Fail, string.Format("库存不足，预分配失败!", productID)));
}
if (UserSettings.Current.InventoryOutType == InventoryOutType.FIFO) //根据产品的出货方式排序
{
items = (from item in items orderby item.AddDate ascending select item).ToList();
}
else
{
items = (from item in items orderby item.AddDate descending select item).ToList();
}
foreach (ProductInventoryItem pii in items)
{
if (count > 0)
{
ProductInventoryItem pii1 = pii.Clone();
if (pii.Count > count) //对于部分出货的情况，一条库存记录拆成两条，其中一条表示出货的，另一条表示未出货部分，即要保证DelvieryItem不为空的都是未出货的，为空的都是已经出货的
{
pii.OrderItem = orderItem;
pii.OrderID = orderID;
pii.Count = count;
ProviderFactory.Create <IProvider <ProductInventoryItem, Guid> >(RepoUri).Update(pii, pii1, unitWork);
pii1.ID = Guid.NewGuid();
pii1.Count -= count;
ProviderFactory.Create <IProvider <ProductInventoryItem, Guid> >(RepoUri).Insert(pii1, unitWork);
count = 0;
}
else
{
pii.OrderItem = orderItem;
pii.OrderID = orderID;
ProviderFactory.Create <IProvider <ProductInventoryItem, Guid> >(RepoUri).Update(pii, pii1, unitWork);
count -= pii.Count;
}
}
}
return(unitWork.Commit());
}
