public void Order_WhenSingleOrderInputIsNull_ShouldReturnPrimaryQueryable()
{
OrderInput orderInput = null;
var queryable = Mock.QueryableItems.Order(orderInput);
Assert.Equal(queryable, Mock.QueryableItems);
}
public Hash GetIssueOrderId(OrderInput input)
{
var hash1 = Hash.FromMessage(input);
var hash2 = Context.TransactionId;
return(Hash.FromTwoHashes(hash1, hash2));
}
public Hash GetIssueOrderId(OrderInput input)
{
var hash1 = HashHelper.ComputeFrom(input);
var hash2 = Context.TransactionId;
return(HashHelper.ConcatAndCompute(hash1, hash2));
}
public OrderOutput Update(OrderInput input)
{
using (var dbContext = new AllureContext())
{
var order = dbContext.Set <Order>().SingleOrDefault(o => o.Id == input.Id);
if (order == null)
{
throw new HttpException(404, string.Format("order {0} doesn't exist", input.Id.ToString()));
}
order.Status = input.Status;
order.WillCheck = input.WillCheck;
order.CheckAddress = input.CheckAddress;
order.CheckTime = input.CheckTime;
order.CheckContact = input.CheckContact;
order.LogisticCode = input.LogisticCode;
order.LogisticOrderNumber = input.LogisticOrderNumber;
order.Deposit = input.Deposit;
order.DepositReceipt = input.DepositReceipt;
order.Remaining = input.Remaining;
order.RemainingReceipt = input.RemainingReceipt;
order.UpdateTime = DateTime.Now;
if (order.Deposit.HasValue)
{
order.RealCharge = order.OriginalRealCharge - order.Deposit.Value;
}
dbContext.SaveChanges();
return(Id(order.Id));
}
}
/// <summary>
/// 将发货信息同步到租户上
/// 发货成功时调用，每发货调用一次
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
private ServiceResult DeliveryToTenant(OrderInput model)
{
if (TenantContext.CurrentTenant == "master")
{
var order = Resolve <IOrderService>().GetSingle(model.OrderID);
if (order != null)
{
order.OrderExtension = order.Extension.ToObject <OrderExtension>();
var tenant = Resolve <ITenantService>().GetSingle(r => r.UserId == order.UserId);
if (tenant != null)
{
var apiUrl = tenant.ServiceUrl + "/Api/Order/Delivery";
model.OrderID = order.OrderExtension.TenantOrderInfo.OrderId;
// 通过Api请求
var dicHeader = new Dictionary <string, string>
{
{ "zk-tenant", tenant.Sign }
};
apiUrl.Post(model.ToJsons(), dicHeader);
}
}
}
return(ServiceResult.Success);
}
public void AddPrchase(PurchaseOrder order, OrderInput orderInput) //新建入库订单
{
try
{
SQLiteConnection con = new SQLiteConnection(@"Data Source=SQL\GREE.db");
con.Open();
string sql = "INSERT INTO main.PurchaseOrder " +
"(totalNumber,subunitNumber,machineTypeName,machineTypeNumber," +
"machineTypeClass,quantity,purchasePrice,totalPrice," +
"orderDate,remarks,state)VALUES(" +
"\'" + order.TNVal + "\'" + "," +
"\'" + order.SNVal + "\'" + "," +
"\'" + order.MTNameVal + "\'" + "," +
"\'" + order.MTNumberVal + "\'" + "," +
"\'" + order.MTClassVal + "\'" + "," +
"\'" + order.QuantityVal + "\'" + "," +
"\'" + order.PurchasePriceVal + "\'" + "," +
"\'" + order.TotalPriceVal + "\'" + "," +
"\'" + order.OrderDateVal + "\'" + "," +
"\'" + order.RemarksVal + "\'" + "," +
"'待入库'" +
");";
SQLiteCommand command = new SQLiteCommand(sql, con);
command.ExecuteNonQuery();
func.MessageBox_OrderInput(orderInput, true);
command.Dispose();
con.Close();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public void CreateOrder(OrderInput input)
{
if (input.Details == null || !input.Details.Any())
{
throw new KnownException("订单错误找不到详情");
}
var header = _mapper.Map <OrderHeader>(input);
var details = _mapper.Map <List <Data.OrderDetail> >(input.Details);
details.ForEach(x => x.ParentId = header.Id);
header.Amount = details.Sum(x => x.Price * x.Quantity);
var msg = _mapper.Map <OrderCreatedEvent>(header);
msg.Details = _mapper.Map <List <Message.OrderDetail> >(details);
var dbMessage = new MqMessage()
{
Body = JsonConvert.SerializeObject(msg, new JsonSerializerSettings()
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
DateFormatString = "yyyy-MM-dd hh:mm:ss"
}),
MessageAssemblyName = typeof(OrderCreatedEvent).Assembly.GetName().Name,
MessageClassFullName = msg.GetType().FullName
};
_dbContext.Add(dbMessage);
_dbContext.Add(header);
_dbContext.AddRange(details);
_dbContext.SaveChanges();
}
public JsonResult ConfirmFinish(OrderInput orderInput)
{
string msg;
orderInput.OperationID = HttpContext.Session.GetString("UserId");
_orderManageService.confirmFinish(orderInput, out msg);
return(Json(msg));
}
public static IOrderedQueryable <T> Ordering <T>(IQueryable <T> input, OrderInput orderInput)
{
var parameter = Expression.Parameter(typeof(T), "p");
return(orderInput.Order == OrderTypeEnum.Asc
? OrderingHelper.OrderBy(input, orderInput.Property, parameter)
: OrderingHelper.OrderByDescending(input, orderInput.Property, parameter));
}
private AddOrderRecordCommand GenerateOrder(OrderInput input, GoodsInfoDto goods, double discount)
{
var orderNo = OrderHelper.GenerateOrderNo(OrderType.Order, input.SellType);
var orderOriginCost = input.Count * input.UnitPrice;
var orderCost = orderOriginCost * discount;
return(new AddOrderRecordCommand(Guid.NewGuid().ToString(), orderNo, goods.Id, goods.AuthRankId, _lotterySession.SystemTypeId, OrderSourceType.V1,
input.Count, input.UnitPrice, orderOriginCost, orderCost, input.SellType, _lotterySession.UserId));
}
public void Add(OrderInput orderInput)
{
var order = CreateOrder(orderInput);
var lines = CreateLine(orderInput.Lines);
order.AddLine(lines);
_orderRepository.Add(order);
_lineRepository.Add(lines);
}
/// <summary>
/// Creates given Order. Requires authentication.
/// </summary>
/// <param name="orderInput">Order to be created</param>
/// <returns>An object of OrderOutPut for the created order information</returns>
public async Task <ReturnModel <OrderOutput> > CreateOrder(OrderInput orderInput)
{
const string requestUrl = "api/v1/order";
var response = await SendRequest(HttpVerbs.Post, requestUrl, orderInput, requiresAuthentication : true);
var returnModel = response.ToReturnModel <OrderOutput>();
return(returnModel);
}
public ApiResult Delivery([FromBody] OrderInput model)
{
var result = Resolve <IOrderService>().Deliver(model);
if (result.Succeeded)
{
return(ApiResult.Success());
}
return(ApiResult.Failure(result.ReturnMessage));
}
public Orders AddOrders([FromBody] OrderInput Input)
{
var modelInput = new Orders
{
UserId = Input.UserId,
ProductId = Input.ProductId
};
var result = _ordersService.AddOrders(modelInput);
return(result);
}
public OrdersForm(IOrderService service)
{
InitializeComponent();
_service = service;
Order = new OrderInput();
Lines = new ObservableCollection <LineInput>();
FillControls();
SignEvents();
}
// public ActionResult<OrderOutput> Post([FromBody] OrderInput orderInput)
public async Task <IActionResult> Register([FromBody] OrderInput orderInput)
{
var register = _registerServiceLocator.GetService(orderInput.OrderType);
// var register = _serviceLocator.GetService<IRegister>(orderInput.OrderType);
var orderBaseInfo = _map.Map <OrderBaseInfo>(orderInput);
var orderInfo = await register.Execute(orderBaseInfo);
var orderOutput = _map.Map <OrderOutput>(orderInfo);
return(Ok(orderOutput));
}
public async Task <string> Order(OrderInput input)
{
if (input == null)
{
return("Nothing");
}
var order = new Order
{
Email = input.email
};
var ordered = _context.Orders.Add(order);
int result = await _context.SaveChangesAsync();
if (result == 0)
{
return("Failed");
}
var orderedItems = new List <OrderedItems>();
foreach (var movie in input.Movies)
{
orderedItems.Add(new OrderedItems
{
Genre = movie.Genre,
Price = movie.Price,
Title = movie.Title,
OrderId = ordered.Entity.Id
});
}
foreach (var item in orderedItems)
{
_context.OrderItems.Add(item);
}
int check = await _context.SaveChangesAsync();
if (check == 0)
{
return("Failed");
}
if (result == 1)
{
return("Success");
}
return("Nothing Happened");
}
public async Task <IActionResult> Post([FromBody] OrderInput orderInput)
{
try
{
var response = await orderManager.PlaceOrder(orderInput);
return(Ok(response));
}
catch (Exception ex)
{
return(BadRequest());
}
}
/// <summary>
/// 发货
/// 只更改订单状态
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ServiceResult Deliver(OrderInput model)
{
var order = Resolve <IOrderService>().GetSingle(u => u.Id == model.OrderID);
if (order == null)
{
return(ServiceResult.FailedMessage("订单有误"));
}
if (order.OrderStatus != OrderStatus.WaitingSellerSendGoods)
{
if (order.OrderStatus != OrderStatus.Remited)
{
return(ServiceResult.FailedWithMessage("只有待发货的商品可以发货"));
}
}
try
{
order.OrderStatus = OrderStatus.WaitingReceiptProduct;
var deliverRes = Resolve <IOrderService>().Update(order);
if (deliverRes)
{
var store = Resolve <IStoreService>().GetSingle(order.StoreId);
//添加订单操作记录
var orderAction = new OrderAction
{
OrderId = order.Id,
OrderActionType = OrderActionType.AdminDelivery,
ActionUserId = order.UserId,
Intro = $"{store.Name}已发货"
};
var rsAddAction = Resolve <IOrderActionService>().Add(orderAction);
order.OrderExtension = order.Extension.ToObject <OrderExtension>();
// 存在关联TenantOrder才执行.
if (rsAddAction && order?.OrderExtension?.TenantOrderInfo?.OrderId > 0)
{
DeliveryToTenant(model);
}
}
}
catch (Exception e)
{
return(ServiceResult.FailedWithMessage(e.ToString()));
}
return(ServiceResult.Success);
}
public void Order_WhenSingleOrderInputIsPassed_ShouldReturnOrderedQueryable()
{
var orderInput = new OrderInput
{
Property = "Date",
Order = OrderTypeEnum.Desc
};
var filteredResult = Mock.QueryableItems.Order(orderInput);
var normalResult = Mock.QueryableItems.OrderByDescending(p => p.Date);
AssertUtil.EnumarableAreEqual(filteredResult, normalResult);
}
public ContentResult AddOrder(OrderInput inputData)
{
try
{
var order = new Order()
{
OrderId = Guid.NewGuid(),
ProductId = inputData.ProductId,
CustomerId = inputData.CustomerId,
Quantity = inputData.Quantity,
IsCancel = false,
};
dbContext.Orders.Add(order);
var getProduct = dbContext.Products.Where(x => x.ProductId == inputData.ProductId).FirstOrDefault();
if (getProduct is null || inputData.Quantity > getProduct.Quantity)
{
return(new ContentResult
{
Content = JsonConvert.SerializeObject("Product Unavailable"),
ContentType = "application/json",
StatusCode = 204
});
}
else
{
getProduct.Quantity -= inputData.Quantity; //Reduced Product Quantity
dbContext.Products.Update(getProduct); //Update Product
var result = dbContext.SaveChanges();
if (result is 2)
{
return(new ContentResult
{
Content = JsonConvert.SerializeObject("Success"),
ContentType = "application/json",
StatusCode = 200
});
}
return(new ContentResult
{
Content = JsonConvert.SerializeObject("Fail"),
ContentType = "application/json",
StatusCode = 204
});
}
}
public OrdersForm(IOrderService service, OrderInput order)
{
InitializeComponent();
_service = service;
Order = order;
Lines = new ObservableCollection <LineInput>();
foreach (var line in order.Lines)
{
Lines.Add(line);
}
FillControls();
SignEvents();
}
public void TestAddOrderExpectTrue()
{
var order = new OrderInput()
{
OrderId = Guid.NewGuid(),
ProductId = Guid.Parse("157771ae-67a0-46c8-8453-0eafcdf4006a"),
CustomerId = Guid.Parse("a663a20c-4b0d-4e46-88b4-b6d9d932b7b5"),
Quantity = 20
};
var addProduct = orderService.AddOrder(order);
var valConv = JsonConvert.DeserializeObject(addProduct.Content.ToString());
var _result = valConv.ToString() == "Success" ? true : false;
Assert.True(_result);
}
/// <summary>
/// 订单添加
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task AddHouserOrder(OrderInput input)
{
var query = _houseRepository.FirstOrDefault(a => a.Id == input.Houseid);
HOrderInput hOrderInput = new HOrderInput
{
UserId = input.Userid,
houseTitle = query.FloorName,
ImgHeard = query.ImgHeader,
Houseid = input.Houseid,
HousePrice = query.FloorPrice,
HouseType = true
};
var houseorder = ObjectMapper.Map <HOrderInput, HouseOrder>(hOrderInput);
houseorder.Id = GuidGenerator.Create();
await _OrderRepository.InsertAsync(houseorder);
}
public override Empty IssueOrder(OrderInput input)
{
//sent token to contract first
var hash = GetIssueOrderId(input);
//transfer from
State.TokenContract.TransferFrom.Send(new TransferFromInput
{
Symbol = input.SymbolPaid,
Amount = input.BalancePaid,
From = Context.Sender,
To = Context.Self,
Memo = "issue new order"
});
State.AllOrders[hash] = new OrderInfo
{
OrderId = hash,
Issuer = Context.Sender,
SymbolPaid = input.SymbolPaid,
SymbolObtain = input.SymbolObtain,
BalancePaid = input.BalancePaid,
BalanceObtain = input.BalanceObtain,
BalanceAchieved = 0,
Status = OrderStatus.Created
};
Context.Fire(new OrderIssued
{
Issuer = Context.Sender,
SymbolPaid = input.SymbolPaid,
SymbolObtain = input.SymbolObtain,
BalancePaid = input.BalancePaid,
BalanceObtain = input.BalanceObtain
});
Context.Fire(new Transferred
{
From = Context.Sender,
To = Context.Self,
Symbol = input.SymbolPaid,
Amount = input.BalancePaid,
Memo = "Same name event for test" //same with token event transfer
});
return(new Empty());
}
public virtual ActionResult Save(OrderInput input)
{
using (var context = new AllureContext())
{
var order = context.Set <Order>()
.Include(o => o.Details)
.AsNoTracking()
.SingleOrDefault(o => o.Id == input.Id);
if (order == null)
{
throw new Exception(string.Format("order {0} doesn't exist", input.Id.ToString()));
}
var ids = input.Details.Select(d => d.ProductId).ToArray();
var products = context.Set <Product>().Where(p => ids.Contains(p.Id)).ToDictionary(p => p.Id);
var details = input.Details.Where(d => d.Count > 0).Select(d => new OrderDetail
{
ProductId = d.ProductId,
Count = d.Count,
Discount = 0m
});
order.WillCheck = input.WillCheck;
order.CheckTime = input.WillCheck ? input.CheckTime : null;
order.CheckContact = input.CheckContact;
order.CheckAddress = input.CheckAddress;
order.ReceiverName = input.ReceiverName;
order.ReceiverAddress = input.ReceiverAddress;
order.ReceiverPostCode = input.ReceiverPostCode;
order.ReceiverContact = input.ReceiverContact;
order.Details = details.ToList();
order.OriginalRealCharge = order.Details.Sum(d => d.RealCharge);
order.RealCharge = order.OriginalRealCharge;
order.UpdateTime = DateTime.Now;
context.UpdateGraph(order, o => o.OwnedCollection(oo => oo.Details));
context.SaveChanges();
return(Json("ok"));
}
}
// GET: Books
//[UnitOfWork]//启用工作单元
public async Task <ActionResult> Index(string SeachText, string currentFilter, string sortOrder, int?page)
{
ViewBag.NameSortParm = sortOrder;
var pageSize = 3;//页大小
if (SeachText != null)
{
page = 1;
}
else
{
SeachText = currentFilter;
}
var pageNumber = page ?? 1;//第几页
ViewBag.CurrentFilter = SeachText;
PageInput pageInput = new PageInput()
{
pageIndex = pageNumber,
pageMax = pageSize
};
SeachInput seachInput = new SeachInput()
{
SeachBookName = SeachText
};
OrderInput orderInput = new OrderInput()
{
OrderName = ViewBag.NameSortParm
};
var BookList = await _bookAppService.GetAllAsync(pageInput, seachInput, orderInput);
var onePageOfBook = new StaticPagedList <BookListoutput>(BookList.Items, pageNumber, pageSize, BookList.TotalCount); //将分页结果放入ViewBag供View使用 ViewBag.OnePageOfTasks = onePageOfTasks;
//pageNumber, pageSize, counts 页索引 页大小 总数
ViewBag.OnePageOfTasks = onePageOfBook;
return(View());
}
/// <summary>
/// 创建订单
/// </summary>
/// <param name="orderInput"></param>
/// <returns></returns>
public async Task CreateOrder(OrderInput orderInput)
{
var order = new Order
{
Address = orderInput.Address,
Code = orderInput.Code,
Price = 1
};
var product = await _productRepository.GetAsync(1);
if (product != null)
{
product.Quantity -= 1;
}
await _productRepository.UnitOfWork.BeginOrUseTransactionAsync();
await _productRepository.UpdateAsync(product);
_productRepository.UnitOfWork.Commit();
}
public async Task <ApiResponse <Order> > PlaceOrder(OrderInput orderInput)
{
List <PizzaMaking.Pizza> pizzas = new List <PizzaMaking.Pizza>();
if (orderInput.PizzaInputs != null && orderInput.PizzaInputs.Any())
{
foreach (var pizzaInput in orderInput.PizzaInputs)
{
var basePizza = await itemService.GetAsync(pizzaInput.PizzaId);
var pizzaCrust = await crustManager.GetAsync(pizzaInput.CrustId);
var toppings = await toppingManager.QueryAsync(pizzaInput.ToppingIds);
var pizza = pizzaMaker.StartWith(basePizza)
.ChangeCrust(pizzaCrust, pizzaInput.Size)
.AddToppings(toppings)
.Build();
pizzas.Add(pizza);
}
}
var nonPizzaItems = orderInput.NonPizzaItemInputs?.Select(x => x.ItemId).ToList();
var otherItems = await itemService.GetByIds(nonPizzaItems);
var orderPlaced = await orderService.PlaceOrderAsync(pizzas, otherItems, orderInput.CustomerId);
ApiResponse <Order> apiResponse = new ApiResponse <Order>
{
Result = new ApiResult <Order>
{
Data = orderPlaced
}
};
return(apiResponse);
}
public void Update(OrderInput orderInput)
{
var order = _orderRepository.Get(orderInput.Id);
var lines = _lineRepository.GetByOrder(orderInput.Id);
var businessPartner = new BusinessPartner(orderInput.CardCode, orderInput.CardName);
var linesInputToAdd = orderInput.Lines.Where(c => !lines.Any(x => x.Id.ToString().Equals(c.Id))).ToList();
var linesInputToUpdate = orderInput.Lines.Where(c => lines.Any(x => x.Id.ToString().Equals(c.Id))).ToList();
var linesToRemove = lines.Where(c => !orderInput.Lines.Any(x => x.Id.Equals(x.Id.ToString()))).ToList();
var linesToAdd = CreateLine(linesInputToAdd);
var linesToUpdate = CreateLine(linesInputToUpdate);
linesToUpdate.ForEach(l => l.Update(l));
order.AddLine(linesToAdd);
order.RemoveLine(linesToRemove);
order.Update(businessPartner);
_lineRepository.Update(linesToUpdate);
_lineRepository.Add(linesToAdd);
_lineRepository.Delete(linesToRemove);
_orderRepository.Update(order);
}
