public static void AddOrder(DTO.Order newOrder)
{
PBPizzaDBEntities db = new PBPizzaDBEntities();
var orders = db.Orders;
var order = new Order
{
Size = newOrder.Size,
Crust = newOrder.Crust,
Sausage = newOrder.Sausage,
Pepperoni = newOrder.Pepperoni,
Onions = newOrder.Onions,
GreenPeppers = newOrder.GreenPeppers,
TotalCost = newOrder.TotalCost,
Name = newOrder.Name,
Address = newOrder.Address,
ZipCode = newOrder.ZipCode,
PhoneNumber = newOrder.PhoneNumber,
PaymentType = newOrder.PaymentType,
Completed = newOrder.Completed
};
orders.Add(order);
db.SaveChanges();
}
public DTO.Order MapOrderModel(Models.Order orderDb)
{
DTO.Order output = new DTO.Order()
{
Id = orderDb.Id,
DeliveryAddress = orderDb.DeliveryAddress,
IdRestaurant = orderDb.IdRestaurant,
IdStatus = DTO.Status.Inserted,
IdUser = orderDb.IdUser,
OrderItem = orderDb.OrderItem
.Select(item => new DTO.OrderItem()
{
IdMenuItem = item.IdMenuItem,
MenuItemName = item.MenuItemName,
Price = item.Price,
Quantity = item.Quantity
})
.ToList(),
Price = orderDb.Price, // non calcolo somma degli item per permettere eventuali sconti
RestaurantAddress = orderDb.RestaurantAddress,
RestaurantName = orderDb.RestaurantName,
UserName = orderDb.UserName
};
return(output);
}
private void _UpdateOrderList(RequestNS.RequestOrderStatus orderStatus)
{
try {
lock (this._LockCurrentOrders) {
DTO.Order editOrder = this._CurrentOrders.FirstOrDefault(x => x.OrderId == orderStatus.OrderId);
if (editOrder == null)
{
editOrder = new DTO.Order();
editOrder.OrderId = orderStatus.OrderId;
this._CurrentOrders.Add(editOrder);
}
DTO.Order updatedOrder = orderStatus.GetOrder();
editOrder.DrinkId = updatedOrder.DrinkId;
editOrder.ExpectedSecondsToDeliver = updatedOrder.ExpectedSecondsToDeliver;
editOrder.OrderStatus = updatedOrder.OrderStatus;
editOrder.OrderStateId = updatedOrder.OrderStateId;
this._CleanupCompletedOrders();
this._NotifyOrderChanged((DTO.Order)editOrder.Clone());
}
} catch (InvalidOperationException) {
} catch (ArgumentNullException) {
}
}
public static List <DTO.Order> GetOrders()
{
var db = new PapaBobsDbEntities();
var dbOrders = db.OrderEntities.ToList();
var dtoOrders = new List <DTO.Order>();
foreach (var dbOrder in dbOrders)
{
var dtoOrder = new DTO.Order();
dtoOrder.OrderId = dbOrder.OrderId;
dtoOrder.Size = dbOrder.Size;
dtoOrder.Crust = dbOrder.Crust;
dtoOrder.Sausage = dbOrder.Sausage;
dtoOrder.Pepperoni = dbOrder.Pepperoni;
dtoOrder.Onions = dbOrder.Onions;
dtoOrder.GreenPeppers = dbOrder.GreenPeppers;
dtoOrder.TotalCost = dbOrder.TotalCost;
dtoOrder.Name = dbOrder.Name;
dtoOrder.Address = dbOrder.Address;
dtoOrder.Zip = dbOrder.Zip;
dtoOrder.Phone = dbOrder.Phone;
dtoOrder.PaymentType = dbOrder.PaymentType;
dtoOrder.Completed = dbOrder.Completed;
dtoOrders.Add(dtoOrder);
}
return(dtoOrders);
}
internal static Models.Order MapOrderDTO(DTO.Order input)
{
Models.Order output = new Models.Order()
{
CreateDate = DateTime.UtcNow,
DeliveryAddress = input.DeliveryAddress,
DeliveryRequestedDate = input.DeliveryRequestedDate,
IdRestaurant = input.IdRestaurant,
IdStatus = (int)DTO.Status.Inserted,
IdUser = input.IdUser,
OrderItem = input.OrderItem
.Select(item => new Models.OrderItem()
{
IdMenuItem = item.IdMenuItem,
MenuItemName = item.MenuItemName,
Price = item.Price,
Quantity = item.Quantity
})
.ToList(),
Price = input.Price, // non calcolo somma degli item per permettere eventuali sconti
RestaurantAddress = input.RestaurantAddress,
RestaurantName = input.RestaurantName,
UserName = input.UserName
};
return(output);
}
private static void CreateNewOrder(DTO.Order current_order, out Persistence.Order new_order)
{
new_order = new Persistence.Order();
OrderMapper(current_order, out new_order);
System.Guid order_id = Guid.NewGuid();
new_order.order_id = order_id;
}
public async Task <IActionResult> GetOrder([FromRoute] int idOrder)
{
var orderDb = await ordersService.GetOrder(idOrder);
DTO.Order orderDto = ordersService.MapOrderModel(orderDb);
return(Ok(orderDto));
}
public static void AddOrder(DTO.Order current_order, DTO.Customer current_customer)
{
PapaBobEntities db = new PapaBobEntities();
System.Data.Entity.DbSet <Order> dbOrders = db.Orders;
var dbCustomers = db.Customers;
var new_order = new Persistence.Order();
CreateNewOrder(current_order, out new_order);
var dbCustomersList = db.Customers.ToList();
bool check_if_customer_exits = CustomerRepository.CustomerExists(dbCustomersList, current_customer);
if (!check_if_customer_exits)
{
var new_customer = new Customer();
CustomerRepository.CreateNewCustomer(current_customer, out new_customer);
new_order.customer_id = new_customer.customer_id;
new_customer.amount_owing = current_order.payment_type != DTO.Payment.Cash ? current_order.cost : 0;
new_order.Customer = new_customer;
dbCustomers.Add(new_customer);
}
else
{
var existing_customer = dbCustomersList?.Find(p => p.phone_number == current_customer.phone_number);
new_order.customer_id = existing_customer.customer_id;
existing_customer.amount_owing += current_order.payment_type != DTO.Payment.Cash ? current_order.cost : 0;
}
dbOrders.Add(new_order);
db.SaveChanges();
}
public async Task <Order> Create(DTO.Order order)
{
Models.Order orderDB = new Models.Order()
{
UserId = Guid.Parse(order.UserId)
};
var d = await _StoreContext.AddAsync(orderDB);
await _StoreContext.SaveChangesAsync();
order = d.Entity.ToDTO();
/*
* foreach (DTO.OrderProduct orderProduct in order.OrderProducts)
* {
* Models.OrderProduct orderProductDB = new Models.OrderProduct()
* {
* Quantity = orderProduct.Quantity,
* ProductId = Guid.Parse(orderProduct.Product.Id),
* OrderId = Guid.Parse(order.Id),
* };
*
* await _StoreContext.AddAsync(orderProductDB);
* await _StoreContext.SaveChangesAsync();
* }
*/
return(order);
}
//VERIFY ORDER OBJECT MEETS VALIDATION REQUIREMENTS,
//SEND TO PERSISTENCE LAYER TO BE STORED IN DB
public static void ProcessOrder(DTO.Order order)
{
if (order.Size == "choose")
{
throw new InvalidSubmission();
}
if (order.Crust == "choose")
{
throw new InvalidSubmission();
}
if (order.Name == "")
{
string error = "You must enter a name.";
throw new FormatException(error);
}
if (order.Address == "")
{
string error = "You must enter an address.";
throw new FormatException(error);
}
if (!int.TryParse(order.Zip, out parsedZip))
{
string error = "You must enter a valid zip code.";
throw new FormatException(error);
}
if (!long.TryParse(order.Phone, out parsedPhone))
{
string error = "You must enter a valid phone number with digits only.";
throw new FormatException(error);
}
Persistence.OrdersRepository.StoreOrder(order);
}
//ACCEPT VALIDATED ORDER FROM DOMAIN LAYER,
//FORMAT DATA AND PASS INTO DATABASE
public static void StoreOrder(DTO.Order submittedOrder)
{
OrdersEntities db = new OrdersEntities();
var dbOrders = db.Orders;
var order = new Order();
string toppings = "";
foreach (var topping in submittedOrder.Toppings)
{
toppings += topping + ", ";
}
order.Id = Guid.NewGuid();
order.Size = submittedOrder.Size;
order.Crust = submittedOrder.Crust;
order.Toppings = toppings;
order.Name = submittedOrder.Name;
order.Address = submittedOrder.Address;
order.Zip = submittedOrder.Zip;
order.Phone = submittedOrder.Phone;
order.Payment = submittedOrder.Payment;
dbOrders.Add(order);
db.SaveChanges();
}
public int createAOrder(DTO.Order dto_PDH, DTO.OrderDetails[] dto_CT, int so_nl)
{
try
{
if (MessageBox.Show("Bạn có chắc chắn muốn lưu phiếu đặt hàng?", "Xác nhận!", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
DAO.Order dao_PKH = new DAO.Order();
int maphieu = dao_PKH.createAOrder(dto_PDH);
BUS.OrderDetails bus = new BUS.OrderDetails();
for (int i = 0; i < so_nl; i++)
{
bus.addOrderDetails(dto_CT[i], maphieu);
}
MessageBox.Show("Lưu phiếu đặt hàng thành công!", "Thông báo!", MessageBoxButtons.OK, MessageBoxIcon.Information);
return(1);
}
return(0);
}
catch (Exception e)
{
MessageBox.Show("Thêm phiếu đặt thất bại!", "Thông báo!", MessageBoxButtons.OK, MessageBoxIcon.Information);
throw e;
return(0);
}
}
public static List <DTO.Order> DisplayOrders()
{
var db = new OrdersDBEntities();
var dbOrders = db.Orders;
var dtoOrders = new List <DTO.Order>();
foreach (var order in dbOrders)
{
var newOrder = new DTO.Order();
newOrder.OrderId = order.OrderId;
newOrder.Size = order.Size;
newOrder.Crust = order.Crust;
newOrder.Extras = order.Extras;
newOrder.Name = order.Name;
newOrder.Address = order.Address;
newOrder.Zip = order.Zip;
newOrder.Phone = order.Phone;
newOrder.PayType = order.PayType;
newOrder.Price = order.Price;
dtoOrders.Add(newOrder);
}
return(dtoOrders);
}
public static List <DTO.Order> GetOrders()
{
PBPizzaDBEntities db = new PBPizzaDBEntities();
var dbOrders = db.Orders.Where(p => p.Completed == false).ToList();
var dtoOrders = new List <DTO.Order>();
foreach (var dbOrder in dbOrders)
{
var dtoOrder = new DTO.Order
{
OrderId = dbOrder.OrderId,
Size = dbOrder.Size,
Crust = dbOrder.Crust,
Sausage = dbOrder.Sausage,
Pepperoni = dbOrder.Pepperoni,
Onions = dbOrder.Onions,
GreenPeppers = dbOrder.GreenPeppers,
TotalCost = dbOrder.TotalCost,
Name = dbOrder.Name,
Address = dbOrder.Address,
ZipCode = dbOrder.ZipCode,
PhoneNumber = dbOrder.PhoneNumber,
PaymentType = dbOrder.PaymentType,
Completed = dbOrder.Completed
};
dtoOrders.Add(dtoOrder);
}
return(dtoOrders);
}
public static Models.Order ToDatabaseModel(this DTO.Order o)
{
return(new Models.Order
{
Id = o.Id,
UserId = o.UserID
});
}
public async Task <int> AddOrder(DTO.Order order)
{
Models.Order newOrder = OrdersMapper.MapOrderDTO(order);
ordersDbContext.Order.Add(newOrder);
await ordersDbContext.SaveChangesAsync();
return(newOrder.Id);
}
private void _NotifyOrderChanged(DTO.Order order)
{
if (this.OnOrderChanged != null)
{
Task.Factory.StartNew(() => {
this.OnOrderChanged(this, new OrderChangedEventArgs(order));
});
}
}
public static void CreateOrder(DTO.Order orderDTO)
{
var db = new PapaBobsDbEntities();
var order = converToEntity(orderDTO);
db.OrderEntities.Add(order);
db.SaveChanges();
}
public static Models.Order ToDatabaseModel(this DTO.Order order)
{
return(new Models.Order
{
Id = order.Id,
UserId = order.user,
Status = order.status,
Created_at = order.created_at
});
}
public static Models.Order ToDatabaseModel(this DTO.Order o)
{
return(new Models.Order
{
Id = o.Id,
UserId = o.UserId,
// Status = o.Status,
// CreatedAt= o.CreatedAt
});
}
public static Models.Order ToModel(this DTO.Order DTOObject)
{
var model = DTOObject.ParseObject <DTO.Order, Models.Order>();
foreach (var item in DTOObject.orderDetailList)
{
model.OrderDetails.Add(item.ToModel());
}
return(model);
}
public static decimal CalculateCost(DTO.Order order)
{
decimal cost = 0;
DTO.PizzaPriceDTO prices = GetPizzaPrices();
cost += calculateSizeCost(order, prices);
cost += calculateCrustCost(order, prices);
cost += calculateToppingsCost(order, prices);
return(cost);
}
public DTO.OrderItem[] GetOrderItems(DTO.Order order)
{
CheckHelper.ArgumentNotNull(order, "order");
CheckHelper.ArgumentWithinCondition(!order.IsNew(), "Order is new.");
CheckHelper.WithinCondition(SecurityService.IsLoggedIn, "User is not logged in.");
CheckHelper.WithinCondition(
SecurityService.IsCurrentUserSeller ||
SecurityService.IsCurrentUserPurchaser ||
SecurityService.IsCurrentUserDistributor,
"Only seller, purchaser and distributor can get all order items.");
var orderId = order.Id;
var currentOrder =
Container
.Get <IPersistentService>()
.GetEntityById <DataAccess.Order>(orderId);
CheckHelper.NotNull(currentOrder, "Order does not exist.");
var currentParcel = currentOrder.Parcel;
var currentUserId = SecurityService.CurrentUser.Id;
CheckHelper.WithinCondition(
SecurityService.IsCurrentUserPurchaser ||
(SecurityService.IsCurrentUserDistributor && currentParcel != null && currentParcel.Distributor != null && currentParcel.DistributorId == currentUserId) ||
(SecurityService.IsCurrentUserSeller && currentOrder.CreateUserId == currentUserId),
"Current user is either distributor and order is not included in parcel assigned to him or seller and order is not created by him.");
var dtoService = Container.Get <IDtoService>();
Func <DataAccess.Order, bool> predicate = null;
if (SecurityService.IsCurrentUserSeller &&
!SecurityService.IsCurrentUserPurchaser &&
!(SecurityService.IsCurrentUserDistributor && currentParcel != null && currentParcel.Distributor != null && currentParcel.DistributorId == currentUserId))
{
predicate = o => o.CreateUserId == currentUserId;
}
return
(Container
.Get <IPersistentService>()
.GetEntitySet <OrderItem>()
.Where(oi => oi.OrderId == orderId)
.OrderBy(oi => oi.Id)
.AsEnumerable()
.Select(oi => dtoService.CreateOrderItem(oi, false, predicate))
.ToArray());
}
private static void OrderMapper(DTO.Order current_order, out Persistence.Order new_order)
{
new_order = new Persistence.Order();
new_order.completed = false;
new_order.cost = current_order.cost;
new_order.crust = (Persistence.Crust)current_order.crust;
new_order.payment_type = (Persistence.Payment)current_order.payment_type;
new_order.size = (Persistence.Size)current_order.size;
new_order.onions = current_order.onions;
new_order.green_peppers = current_order.green_peppers;
new_order.sausage = current_order.sausage;
new_order.pepperoni = current_order.pepperoni;
}
public DTO.Order CreateOrder(DataAccess.Order order, bool includeOnlyActive = false, Func <DataAccess.Order, bool> predicate = null)
{
CheckHelper.ArgumentNotNull(order, "order");
CheckHelper.ArgumentWithinCondition(!order.IsNew(), "!order.IsNew()");
return
(_dtoCache.Get(
order,
o =>
{
var result =
new DTO.Order
{
Id = o.Id,
OrderDate = o.OrderDate,
CustomerFirstName = o.CustomerFirstName,
CustomerLastName = o.CustomerLastName,
CustomerAddress = o.CustomerAddress,
CustomerCity = o.CustomerCity,
CustomerCountry = o.CustomerCountry,
CustomerPostalCode = o.CustomerPostalCode,
CustomerPhoneNumber = o.CustomerPhoneNumber,
CustomerEmail = o.CustomerEmail,
Active = o.Active,
Comments = o.Comments,
RublesPerDollar = o.RublesPerDollar,
CustomerPaid = o.CustomerPaid,
CustomerPrepaid = o.CustomerPrepaid,
DistributorSpentOnDelivery = o.DistributorSpentOnDelivery,
TrackingNumber = o.TrackingNumber,
CreateUserId = o.CreateUserId
};
CopyTrackableFields(result, o);
return result;
},
(oDto, o) =>
{
oDto.Parcel = o.Parcel != null ? CreateParcel(o.Parcel, includeOnlyActive, predicate) : null;
oDto.OrderItems =
o.OrderItems
.Where(oi => oi.Active || !includeOnlyActive)
.OrderBy(oi => oi.ProductSize.Product.Name)
.ThenBy(oi => oi.ProductSize.Size.Name)
.Select(oi => CreateOrderItem(oi, includeOnlyActive))
.ToArray();
}));
}
private void _HandleFailedOrderRequest(RequestNS.RequestOrderStatus failedRequest)
{
DTO.Order failedOrder = null;
lock (this._LockCurrentOrders) {
failedOrder = this._CurrentOrders.FirstOrDefault(x => x.OrderId == failedRequest.OrderId);
if (failedOrder != null)
{
this._CurrentOrders.Remove(failedOrder);
}
}
failedOrder.OrderStateId = DTO.StateId.Failed;
this._NotifyOrderChanged(failedOrder);
return;
}
public DTO.Order GetOrder()
{
DTO.Order order = new DTO.Order();
var rawOrder = JObject.Parse(this.Response);
int seconds = 0;
order.DrinkId = rawOrder["drink_id"].ToString();
order.OrderStatus = rawOrder["status"].ToString();
order.OrderStateId = this._OrderStatusToStateId(order.OrderStatus);
int.TryParse(rawOrder["expected_time_to_completion"].ToString(), out seconds);
order.ExpectedSecondsToDeliver = seconds;
return(order);
}
public async Task <Order> Create(DTO.Order order)
{
Models.Order orderDB = new Models.Order()
{
UserId = Guid.Parse(order.UserId)
};
var d = await _StoreContext.AddAsync(orderDB);
await _StoreContext.SaveChangesAsync();
order = d.Entity.ToDTO();
return(order);
}
void orderRequest_OnRequestCompleted(object sender, RequestNS.RequestCompletedEventArgs e)
{
RequestNS.RequestOrderDrink orderResponse = e.Request as RequestNS.RequestOrderDrink;
if (e.Request.State != RequestNS.RequestStates.Successful)
{
return;
}
DTO.Order order = new DTO.Order();
order.OrderId = orderResponse.GetOrderAmount();
lock (this._LockCurrentOrders) {
this._CurrentOrders.Add(order);
}
this.UpdateOrderStatus(order.OrderId);
}
public async Task <HttpResponseMessage> OrderFromBazzasBazaar(DTO.Order Order)
{
BazzasBazaarService.StoreClient svc = new BazzasBazaarService.StoreClient();
BazzasBazaarService.Order order = await svc.CreateOrderAsync(Order.AccountName, Order.CardNumber, Order.ProductID, Order.Quantity);
#pragma warning disable CS0618 // Type or member is obsolete
var returnOrder = await JsonConvert.SerializeObjectAsync(order);
#pragma warning restore CS0618 // Type or member is obsolete
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(returnOrder, System.Text.Encoding.UTF8, "application/json")
});
}
private DTO.Order[] MakeOrderDTOArray(IList orders)
{
if(orders == null)
return null;
DTO.Order[] dtos = new DTO.Order[orders.Count];
IEnumerator ordersEnum = orders.GetEnumerator();
for(int i = 0; i < orders.Count; i++)
{
ordersEnum.MoveNext();
dtos[i] =
DTO.DTOAssembler.AssembleOrder((DomainModel.Order)ordersEnum.Current);
}
return dtos;
}
