public OrderModel(IAccessToken accessToken, IRetailOrder order) : base(order)
{
if (order.Org != null)
{
Org = new OrgModel(order.Org);
Org.Locations = null;
Org.Address = null;
}
Token = accessToken.ToString();
OrderNumber = order.OrderNumber;
OrderedAt = order.OrderedAt;
Discount = order.Discount;
SubTotal = order.SubTotal;
TotalDue = order.TotalDue;
TotalTax = order.TotalTax;
Code = order.Code;
Uri = order.Uri;
ReorderLevel = order.ReorderLevel;
Customer = order.Customer;
if (order.Details != null)
{
Details = order.Details.Select(x => new OrderDetailModel(x)).ToArray();
}
if (order.DeliveryAddress != null)
{
DeliveryAddress = new AddressModel(order.DeliveryAddress);
}
}
public RetailOrder(IRetailOrder order) : base(order)
{
if (order.Org != null)
{
Org = new Org(order.Org);
}
if (order.Customer != null)
{
Customer = new UserAccount(order.Customer);
}
OrderNumber = order.OrderNumber;
OrderedAt = order.OrderedAt;
Discount = order.Discount;
SubTotal = order.SubTotal;
TotalTax = order.TotalTax;
TotalDue = order.TotalDue;
if (order.Details != null && order.Details.Any())
{
Details = order.Details.Select(x => new RetailOrderDetail(x)).ToArray();
}
else
{
Details = new RetailOrderDetail[] { };
}
}
public async Task <IRetailOrder> AddToOrder(IRetailOrder order, Guid locationGuid, string placeCode, Guid productGuid, decimal quantity)
{
ILocation location = await m_org_provider.GetLocation(locationGuid);
IProduct product = await m_catalog_provider.GetProduct(productGuid);
if (product == null || location == null)
{
return(default);
public async Task <IRetailOrder> GetOrder(IUserAccount user, Guid guid)
{
IRetailOrder order = await m_order_repository.Select(guid);
if (order.Customer.Guid == user.Guid)
{
return(new RetailOrder(order).GroupBy(x => m_order_caluclator.CalculateTotalPrice(x)));
}
return(default);
public DataOrderItem(IRetailOrder order, IOrderDetail detail, IOrderItem item)
{
OrderGuid = order.Guid;
LocationGuid = detail.Location.Guid;
PlaceCode = detail.PlaceCode;
ProductGuid = item.Product.Guid;
Quantity = item.Quantity;
UnitPrice = item.UnitPrice;
Discount = item.Discount;
TotalPrice = item.TotalPrice;
TaxValue = item.TaxValue;
}
public async Task <IActionResult> CreateOrder([FromBody] AccessTokenModel model, Guid orgGuid)
{
IAccessToken accessToken = await m_token_service.GetToken(model.Token);
if (accessToken == null || accessToken.HasExpired)
{
return(BadRequest());
}
IRetailOrder order = await m_order_processing.CreateNewOrder(accessToken.User, orgGuid);
return(Ok(new OrderModel(accessToken, order)));
}
public async Task <IActionResult> RemoveFromOrder([FromBody] OrderModel model, Guid locationGuid, string placeCode, Guid productGuid, decimal qty)
{
IAccessToken accessToken = await m_token_service.GetToken(model.Token);
if (accessToken == null || accessToken.HasExpired)
{
return(Forbid());
}
model.Customer = accessToken.User;
IRetailOrder order = await m_order_processing.RemoveFromOrder(model, locationGuid, placeCode, productGuid, Math.Abs(qty));
return(Ok(new OrderModel(accessToken, order)));
}
public async Task <IActionResult> GetActiveOrders([FromBody] AccessTokenModel model, Guid guid)
{
IAccessToken accessToken = await m_token_service.GetToken(model.Token);
if (accessToken == null || accessToken.HasExpired)
{
return(BadRequest());
}
IRetailOrder order = await m_order_provider.GetOrder(accessToken.User, guid);
if (order == null)
{
return(NotFound());
}
return(Ok(new OrderModel(accessToken, order)));
}
public override void Fill(IBussnessEntity obj)
{
base.Fill(obj);
IRetailOrder order = obj as IRetailOrder;
OrgGuid = order.Org.Guid;
CustomerGuid = order.Customer.Guid;
if (order.DeliveryAddress != null)
{
AddressGuid = null;
}
OrderNumber = order.OrderNumber;
OrderedAt = order.OrderedAt;
Discount = order.Discount;
SubTotal = order.SubTotal;
TotalTax = order.TotalTax;
TotalDue = order.TotalDue;
}
public async Task <IActionResult> AddToOrder([FromBody] OrderModel model, Guid locationGuid, string placeCode, Guid productGuid, decimal qty)
{
IAccessToken accessToken = await m_token_service.GetToken(model.Token);
if (accessToken == null || accessToken.HasExpired)
{
return(Forbid());
}
IRetailOrder order = model;
model.Customer = accessToken.User;
if (string.IsNullOrWhiteSpace(order.OrderNumber) || order.OrderedAt == DateTime.MinValue)
{
order = await m_order_processing.CreateNewOrder(accessToken.User, DataOrgMapper.ORG.Guid);
}
order = await m_order_processing.AddToOrder(order, locationGuid, placeCode, productGuid, Math.Abs(qty));
return(Ok(new OrderModel(accessToken, order)));
}
public async Task <IRetailOrder> Calculate(IRetailOrder order)
{
RetailOrder retailOrder = new RetailOrder(order);
Dictionary <Guid, Product> productCache = (await m_catalog_provider.GetProducts(retailOrder.Details.SelectMany(x => x.Items).Select(x => x.Product.Guid).ToArray()))
.Select(x => new Product(null, null, x))
.ToDictionary(x => x.Guid);
retailOrder.SubTotal = decimal.Zero;
foreach (RetailOrderDetail detail in retailOrder.Details)
{
detail.TotalPrice = decimal.Zero;
foreach (RetailOrderItem item in detail.Items)
{
Product product;
if (productCache.TryGetValue(item.Product.Guid, out product))
{
item.Product = product;
}
item.UnitPrice = item.Product.ListPrice;
item.TotalPrice = Math.Round(item.UnitPrice * item.Quantity, 2, MidpointRounding.AwayFromZero);
detail.TotalPrice += item.TotalPrice;
retailOrder.SubTotal += item.TotalPrice;
}
detail.TotalPrice = Math.Round(detail.TotalPrice, 2, MidpointRounding.AwayFromZero);
}
retailOrder.TotalDue = retailOrder.SubTotal = Math.Round(retailOrder.SubTotal, 2, MidpointRounding.AwayFromZero);
return(retailOrder);
}
public DataOrder(IRetailOrder order)
{
Fill(order);
}
