public HttpResponseMessage UpdateOrder([FromBody] ModifyOrderRequest request)
{
_logInfo.Info("更新订单请求" + request.ToJson());
var viewModel = new CreateOrderViewMode();
if (!ModelState.IsValid)
{
viewModel.BusinessStatus = -10000;
viewModel.StatusMessage = "输入参数错误，请检查您输入的参数是否有空或者长度不符合要求等";
return(viewModel.ResponseToJson());
}
var response = _orderService.UpdateOrder(request);
_logInfo.Info("更新订单返回值" + response.ToJson());
if (response.Status == HttpStatusCode.BadRequest || response.Status == HttpStatusCode.Forbidden)
{
viewModel.BusinessStatus = -10001;
viewModel.StatusMessage = "参数校验错误，请检查您的校验码";
return(viewModel.ResponseToJson());
}
if (response.Count > 0)
{
viewModel.OrderId = response.Count;
viewModel.BusinessStatus = 1;
}
else
{
viewModel.BusinessStatus = -10002;
viewModel.StatusMessage = "更新订单失败";
}
return(viewModel.ResponseToJson());
}
public ModifyOrderResponse ModifyOrder(ModifyOrderRequest request)
{
ModifyOrderResponse response = new ModifyOrderResponse();
Order order = _orderRepository
.FindBy(request.OrderID);
order.Id = request.OrderID;
order.OrderDate = request.OrderDate;
order.RequiredDate = request.RequiredDate;
order.ShippedDate = request.ShippedDate;
order.Freight = request.Freight;
order.ShipName = request.ShipName;
order.ShipAddress = request.ShipAddress;
order.ShipCity = request.ShipCity;
order.ShipRegion = request.ShipRegion;
order.ShipPostalCode = request.ShipPostalCode;
order.ShipCountry = request.ShipCountry;
order.Products = request.Products.ConvertToProducts();
order.Employee = request.Employee.ConvertToEmployee();
order.Customer = request.Customer.ConvertToCustomer();
order.Shipper = request.Shipper.ConvertToShipper();
if (order.GetBrokenRules().Count() > 0)
{
response.Errors = order.GetBrokenRules().ToList();
}
else
{
try {
_orderRepository.Save(order);
_uow.Commit();
response.Errors = new List <BusinessRule>();
} catch (Exception ex)
{
response.Errors = new List <BusinessRule>();
response.Errors.Add(new BusinessRule("DAL", "DAL_ERROR: " + ex.Message));
}
}
return(response);
}
public ModifyOrderResponse ModifyOrder(ModifyOrderRequest request)
{
Platform.CheckForNullReference(request, "request");
Platform.CheckMemberIsSet(request.Requisition, "Requisition");
Platform.CheckMemberIsSet(request.Requisition.OrderRef, "OrderRef");
var order = this.PersistenceContext.Load <Order>(request.Requisition.OrderRef);
var assembler = new OrderEntryAssembler();
assembler.UpdateOrderFromRequisition(order, request.Requisition, this.CurrentUserStaff, this.PersistenceContext);
UpdateProceduresHelper(order, request.Requisition.Procedures, request);
ValidateVisitsExist(order);
this.PersistenceContext.SynchState();
var orderAssembler = new OrderAssembler();
return(new ModifyOrderResponse(orderAssembler.CreateOrderSummary(order, this.PersistenceContext)));
}
public JsonResult Update(OrderDetailView vm)
{
GetOrderRequest request = new GetOrderRequest();
request.OrderID = vm.OrderID;
ModifyOrderRequest updateRequest = _orderService.GetOrder(request).Order.ConvertToModifyOrderRequest();
updateRequest.OrderID = vm.OrderID;
GetCustomerRequest customerRequest = new GetCustomerRequest();
customerRequest.CustomerID = vm.CustomerCustomerID;
updateRequest.Customer = _customerService.GetCustomer(customerRequest).Customer;
GetEmployeeRequest employeeRequest = new GetEmployeeRequest();
employeeRequest.EmployeeID = vm.EmployeeEmployeeID;
updateRequest.Employee = _employeeService.GetEmployee(employeeRequest).Employee;
updateRequest.OrderDate = vm.OrderDate;
updateRequest.RequiredDate = vm.RequiredDate;
updateRequest.ShippedDate = vm.ShippedDate;
GetShipperRequest shipperRequest = new GetShipperRequest();
shipperRequest.ShipperID = vm.ShipperShipperID;
updateRequest.Shipper = _shipperService.GetShipper(shipperRequest).Shipper;
updateRequest.Freight = vm.Freight;
updateRequest.ShipName = vm.ShipName;
updateRequest.ShipAddress = vm.ShipAddress;
updateRequest.ShipCity = vm.ShipCity;
updateRequest.ShipRegion = vm.ShipRegion;
updateRequest.ShipPostalCode = vm.ShipPostalCode;
updateRequest.ShipCountry = vm.ShipCountry;
ModifyOrderResponse response = _orderService.ModifyOrder(updateRequest);
return(Json(response));
}
private void UpdateProceduresHelper(Order order, IEnumerable <ProcedureRequisition> procedureReqs, ModifyOrderRequest request)
{
// do not update the procedures if the order is completed
if (order.IsTerminated)
{
return;
}
var assembler = new OrderEntryAssembler();
// if any procedure is in downtime recovery mode, assume the entire order is a "downtime order"
var isDowntime = CollectionUtils.Contains(order.Procedures, p => p.DowntimeRecoveryMode);
// separate the list into additions and updates
var existingReqs = new List <ProcedureRequisition>();
var addedReqs = new List <ProcedureRequisition>();
foreach (var req in procedureReqs)
{
if (CollectionUtils.Contains(order.Procedures, x => req.ProcedureNumber == x.Number))
{
existingReqs.Add(req);
}
else
{
addedReqs.Add(req);
}
}
// process the additions first, so that we don't accidentally cancel an order (if all its procedures are cancelled momentarily)
var procedureNumberBroker = PersistenceContext.GetBroker <IProcedureNumberBroker>();
var dicomUidBroker = PersistenceContext.GetBroker <IDicomUidBroker>();
foreach (var req in addedReqs)
{
var requestedType = this.PersistenceContext.Load <ProcedureType>(req.ProcedureType.ProcedureTypeRef);
// create a new procedure for this requisition
var procedure = new Procedure(requestedType, procedureNumberBroker.GetNext(), dicomUidBroker.GetNewUid())
{
DowntimeRecoveryMode = isDowntime
};
order.AddProcedure(procedure);
// note: need to lock the new procedure now, prior to creating the procedure steps
// otherwise may get exceptions saying the Procedure is a transient object
this.PersistenceContext.Lock(procedure, DirtyState.New);
// create the procedure steps
procedure.CreateProcedureSteps();
// apply the requisition information to the actual procedure
assembler.UpdateProcedureFromRequisition(procedure, req, this.CurrentUserStaff, this.PersistenceContext);
LogicalHL7Event.ProcedureCreated.EnqueueEvents(procedure);
}
// process updates
foreach (var req in existingReqs)
{
var requestedType = this.PersistenceContext.Load <ProcedureType>(req.ProcedureType.ProcedureTypeRef);
var procedure = CollectionUtils.SelectFirst(order.Procedures, x => req.ProcedureNumber == x.Number);
// validate that the type has not changed
if (!procedure.Type.Equals(requestedType))
{
throw new RequestValidationException("Order modification must not modify the type of a requested procedure.");
}
// If the procedure is already terminated, just move on to the next one since procedures cannot be "un-terminated".
if (procedure.IsTerminated)
{
continue;
}
// apply the requisition information to the actual procedure
assembler.UpdateProcedureFromRequisition(procedure, req, this.CurrentUserStaff, this.PersistenceContext);
(req.Cancelled ? LogicalHL7Event.ProcedureCancelled : LogicalHL7Event.ProcedureModified).EnqueueEvents(procedure);
}
}
