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; }