public Order CreateOrder(Order newOrder, string userId) { var cart = GetCart(); newOrder.OrderDate = DateTime.Now; // newOrder.userId = userId; _db.Orders.Add(newOrder); if (newOrder.OrderPositions == null) { newOrder.OrderPositions = new List <OrderPosition>(); } decimal cartValue = 0; foreach (var cartItem in cart) { var newOrderPosition = new OrderPosition() { SupplementId = cartItem.Supplement.SupplementId, Amount = cartItem.Amount, PurchasePrice = cartItem.Supplement.Price, }; cartValue += (cartItem.Amount * cartItem.Supplement.Price); newOrder.OrderPositions.Add(newOrderPosition); } newOrder.OrderValue = cartValue; _db.SaveChanges(); return(newOrder); }
// GET: OrderPositions/CreateModal public async Task <ActionResult> CreateModal(int?orderId) { var order = await _repository.Order.Find(orderId); if (order == null) { return(HttpNotFound()); } var position = new OrderPosition(); position.OrderId = order.OrderId; if (order.Positions.Count == 0) { position.Position = 1; } else { position.Position = order.Positions.Last().Position + 1; } ViewBag.ProductId = new SelectList(await _repository.Product.GetAll(), "ProductId", "Name"); return(PartialView("Partials/AddModal", position)); }
public Order CreateOrder(Order newOrder, string userId) { List <ShoppingCartPosition> shoppingCarts = GetShoppingCart(); newOrder.AddingDate = clock.Now; newOrder.UserId = userId; db.Orders.Add(newOrder); if (newOrder.OrderPositions == null) { newOrder.OrderPositions = new List <OrderPosition>(); } foreach (var shoppingCartElement in shoppingCarts) { OrderPosition newOrderPosition = new OrderPosition() { ProductVariantId = shoppingCartElement.ProductVariant.ProductVariantId, Quantity = shoppingCartElement.Quantity, Price = shoppingCartElement.Price }; newOrder.OrderPositions.Add(newOrderPosition); } newOrder.Price = GetValueOfShoppingCart(); db.SaveChangesWrapped(); return(newOrder); }
//Metoda tworzenia nowe zamowienie public Order CreateOrder(Order newOrder, string userId) { var cart = GetCart(); newOrder.DateOfAddition = DateTime.Now; newOrder.UserId = userId; //dodanie zamówienia db.Orders.Add(newOrder); //dodanie pozycji zamowienia if (newOrder.OrderPosition == null) { newOrder.OrderPosition = new List <OrderPosition>(); } decimal cartValue = 0; foreach (var cartElement in cart) { //tworzenie nowej pozycji zamowienia var newPositionOrder = new OrderPosition() { ProductId = cartElement.Product.ProductId, Amount = cartElement.Amount, PurchasePrice = cartElement.Product.Price }; cartValue += (cartElement.Amount * cartElement.Product.Price); newOrder.OrderPosition.Add(newPositionOrder); } newOrder.OrderValue = cartValue; db.SaveChanges(); return(newOrder); }
public async Task <IActionResult> Edit(Guid id, [Bind("Title,Quantity,Price,OrderID,AttachmentPath,Description,ID,NrIntern,UserID,CreateBy,UpdateBy,CreateDate,UpdateDate,OrganizationID,Remark,Deleted")] OrderPosition orderPosition) { if (id != orderPosition.ID) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(orderPosition); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!OrderPositionExists(orderPosition.ID)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } ViewData["OrderID"] = new SelectList(_context.Orders, "ID", "NrIntern", orderPosition.OrderID); return(View(orderPosition)); }
private string GetPricePositionName(OrderPosition orderPosition) { var builder = new StringBuilder(); builder.Append(orderPosition.PricePosition.Name); if (orderPosition.PricePosition.PricePositionTypeId == 26) { return(builder.ToString()); } if (orderPosition.PricePosition.PricePositionType.EnableSecondSize) { builder.Append( string.Format(" ({0}x{1} {2})", orderPosition.PricePosition.FirstSize, orderPosition.PricePosition.SecondSize, orderPosition.PricePosition.Unit.Name) ); } else { builder.Append( string.Format(" ({0} {1})", orderPosition.PricePosition.FirstSize, orderPosition.PricePosition.Unit.Name) ); } builder.Append(string.Format(" {0}", orderPosition.PricePosition.Description)); return(builder.ToString().Trim()); }
public Order CreateOrder(Order newOrder, string userId) { var cart = DownloadCart(); newOrder.DateAdded = DateTime.Now; newOrder.UserId = userId; db.Orders.Add(newOrder); if (newOrder.OrderPosition == null) { newOrder.OrderPosition = new List <OrderPosition>(); } decimal cartValue = 0; foreach (var item in cart) { var newOrderPosition = new OrderPosition() { CourseId = item.Course.CourseId, Volume = item.Number, OrderCost = item.Value }; cartValue += (item.Number * item.Course.CoursePrice); newOrder.OrderPosition.Add(newOrderPosition); } newOrder.OrderValue = cartValue; db.SaveChanges(); return(newOrder); }
private string GetAccountNumenclature(OrderPosition orderPosition) { string nomenclature; if (orderPosition.PricePosition.IsShowSize) { nomenclature = orderPosition.PricePosition.PricePositionType.EnableSecondSize ? string.Format("{0} - {1} {2} ({3}x{4} {5}) {6}", orderPosition.Supplier.Company.Name, orderPosition.Supplier.City.Name, orderPosition.PricePosition.Name, orderPosition.PricePosition.FirstSize, orderPosition.PricePosition.SecondSize, orderPosition.PricePosition.Unit.Name, orderPosition.PricePosition.Description ?? string.Empty) : string.Format("{0} - {1} {2} ({3} {4}) {5}", orderPosition.Supplier.Company.Name, orderPosition.Supplier.City.Name, orderPosition.PricePosition.Name, orderPosition.PricePosition.FirstSize, orderPosition.PricePosition.Unit.Name, orderPosition.PricePosition.Description ?? string.Empty); } else { nomenclature = string.Format("{0} - {1} {2} {3}", orderPosition.Supplier.Company.Name, orderPosition.Supplier.City.Name, orderPosition.PricePosition.Name, orderPosition.PricePosition.Description ?? string.Empty); } return(nomenclature); }
public OrderPosition SetOrderPosition(OrderPosition orderPosition, bool isUnloaded, bool isActual, DbTransaction dbTran) { var orderPositionId = orderPosition.Id; var lastEditDate = orderPosition.BeginDate; SetOrderPosition( dbTran: dbTran, id: ref orderPositionId, orderId: orderPosition.OrderId, parentOrderPositionId: orderPosition.ParentOrderPositionId, supplierId: orderPosition.SupplierId, priceId: orderPosition.PriceId, pricePositionId: orderPosition.PricePositionId, pricePositionVersionDate: orderPosition.PricePositionVersion, clientDiscount: orderPosition.Discount, markup: orderPosition.Markup, nds: orderPosition.Nds, compensation: orderPosition.Compensation, description: orderPosition.Description, clientPackageDiscount: orderPosition.ClientPackageDiscount, editUserId: _editUserId, isActual: isActual, lastEditDate: ref lastEditDate, isUnloaded: isUnloaded, needConfirmation: orderPosition.NeedConfirmation); orderPosition.Id = orderPositionId; orderPosition.BeginDate = lastEditDate; _context.Entry(orderPosition).Reload(); return(orderPosition); }
internal void StoreToXml( Project project, XmlElement parentNode) { if (parentNode.OwnerDocument != null) { var a = parentNode.OwnerDocument.CreateAttribute(@"name"); a.Value = Name; parentNode.Attributes.Append(a); a = parentNode.OwnerDocument.CreateAttribute(@"projectFolderUniqueID"); a.Value = _projectFolderUniqueID.ToString(); parentNode.Attributes.Append(a); a = parentNode.OwnerDocument.CreateAttribute(@"orderPosition"); a.Value = OrderPosition.ToString(); parentNode.Attributes.Append(a); a = parentNode.OwnerDocument.CreateAttribute(@"viewMode"); a.Value = Mode.ToString(); parentNode.Attributes.Append(a); var remarksNode = parentNode.OwnerDocument.CreateElement(@"remarks"); parentNode.AppendChild(remarksNode); remarksNode.InnerText = Remarks; if (parentNode.OwnerDocument != null) { a = parentNode.OwnerDocument.CreateAttribute(@"uniqueID"); a.Value = _uniqueID.ToString(); parentNode.Attributes.Append(a); } } }
public static void UpdateOrder(this Order entity, OrderModel viewModel) { entity.CustomerNumber = viewModel.CustomerNumber; entity.OrderDate = viewModel.OrderDate; entity.DeliveryDate = viewModel.DeliveryDate; if (viewModel.OrderPositions != null) { if (entity.OrderPositions == null) { entity.OrderPositions = new List <OrderPosition>(); } foreach (OrderPositionModel pos in viewModel.OrderPositions) { var posEntity = entity.OrderPositions.SingleOrDefault(x => x.ID == pos.PositionOrderId); if (posEntity == null || posEntity.ID == 0) { posEntity = new OrderPosition(); posEntity.UpdateOrderPosition(pos); entity.OrderPositions.Add(posEntity); } else { posEntity.UpdateOrderPosition(pos); } } } entity.TotalPrice = entity.OrderPositions.Sum(x => x.Total); }
public Order CreateOrder(Order newOrder, string userId) { var basket = DownloadBasket(); newOrder.DateAdded = DateTime.Now; newOrder.UserId = userId; db.Orders.Add(newOrder); if (newOrder.OrderPositions == null) { newOrder.OrderPositions = new List <OrderPosition>(); } decimal basketValue = 0; foreach (var basketItem in basket) { var newOrderPosition = new OrderPosition() { ProductID = basketItem.Product.ProductID, Quantity = basketItem.Quantity, PurchasePrice = basketItem.Product.Price }; basketValue += (basketItem.Quantity * basketItem.Product.Price); newOrder.OrderPositions.Add(newOrderPosition); } newOrder.OrderValue = basketValue; db.SaveChanges(); return(newOrder); }
public Order CreateOrder(Order neworder, string userId) { var cart = GetCart(); neworder.OrderTime = DateTime.Now; neworder.UserId = userId; _db.Orders.Add(neworder); if (neworder.OrderPositions == null) { neworder.OrderPositions = new List <OrderPosition>(); } decimal cartValue = 0; foreach (var cartElement in cart) { var newOrderPosition = new OrderPosition() { ProductId = cartElement.Product.ProductId, Amount = cartElement.Amount, OrderPrice = cartElement.Product.Price }; cartValue += cartElement.Amount * cartElement.Product.Price; neworder.OrderPositions.Add(newOrderPosition); } neworder.OrderValue = cartValue; _db.SaveChanges(); return(neworder); }
public static void UpdateOrderPosition(this OrderPosition entity, OrderPositionModel model) { entity.PositionNumber = model.PositionNumber; entity.Pieces = model.Pieces; entity.Text = model.Text; entity.Price = model.Price; entity.Total = model.PositionNumber * model.Price; }
public async Task <ActionResult <OrderPosition> > PostOrderPosition(CreateOrderPositionDTO orderpositionDTO) { var orderposition = new OrderPosition(orderpositionDTO.OrderId, orderpositionDTO.ProductId, orderpositionDTO.Quantity); _context.OrderPosition.Add(orderposition); _context.SaveChanges(); return(CreatedAtAction("GetPosition", new { id = orderposition.Id }, orderposition)); }
public static int GetQuantity(this OrderPosition orderPosition) { var quantity = orderPosition.GraphicPositions .Where(gp => gp.Id == gp.ParenGraphicPositiontId) .Sum(gp => gp.Count); return(quantity); }
public AccountPosition CreateAccountPosition(int accountId, OrderPosition orderPosition, List <OrderPosition> packagePositions, DbTransaction dbTran) { var accountPosition = _accountPositionFactory.Create(accountId, orderPosition, packagePositions); accountPosition = _repository.SetAccountPosition(accountPosition, isActual: true, dbTran); return(accountPosition); }
public ActionResult DeleteConfirmed(int id) { OrderPosition orderPosition = db.OrderPositions.Find(id); db.OrderPositions.Remove(orderPosition); db.SaveChanges(); return(RedirectToAction("Index")); }
private DateTime GetFirstOutDate(OrderPosition orderPosition) { var firstOutDate = orderPosition.GraphicPositions .Select(gp => gp.Graphic.OutDate) .Min(); return(firstOutDate); }
private int GetPositionsCount(OrderPosition orderPosition) { var count = orderPosition.GraphicPositions .Where(gp => gp.Id == gp.ParenGraphicPositiontId) .Sum(gp => gp.Count); return(count); }
public static float GetClientPrice(this OrderPosition orderPosition) { var price = orderPosition.Price.Value * (1 + orderPosition.Markup / 100) * (1 + orderPosition.Nds / 100) * (1 - orderPosition.Discount / 100); return((float)Math.Round(price, 2)); }
public static float GetClientNds(this OrderPosition orderPosition) { var nds = orderPosition.GraphicPositions.Sum(gp => gp.Count) * orderPosition.Price.Value * (1 + orderPosition.Markup / 100) * (orderPosition.Nds / 100) * (1 - orderPosition.Discount / 100); return(nds); }
private static void CheckResultOrder(Order order, OrderPosition orderPosition, StoreItem storeItem, Person person, SinglePositionOrder resultOrder) { Assert.AreEqual(order.Id, resultOrder.Id); Assert.AreEqual(person.Address, resultOrder.Address); Assert.AreEqual(orderPosition.Amount, resultOrder.Amount); Assert.AreEqual(storeItem.Name, resultOrder.Name); Assert.AreEqual(order.OrderNumber, resultOrder.OrderNumber); Assert.AreEqual(order.Recipient, resultOrder.Recipient); }
public async Task <DestinationNode> GetDestination(OrderPosition orderPosition) { Argument.ThrowIfNull(nameof(orderPosition), orderPosition); Argument.ThrowIfNull(nameof(orderPosition.Order), orderPosition.Order); // TODO: This is wrong return(_destinationNodes.FirstOrDefault(n => n.Location.PostCode == orderPosition.Order.Location.PostCode && n.AcceptedProducts.Any(p => p.Id == orderPosition.Product.Id))); }
public override Neighbour RndNeighbour(Solution solution) { int rnd = (int)(Util.Rnd * Program.allPositions.Length); OrderPosition op = Program.allPositions[rnd]; if (op.Active) { return(new DisableNeighbour(solution, op)); } return(new ActivateNeighbour(solution, op)); }
public static Position Position(OrderPosition pos) { var repo = new ProductRepository(); var result = new Position { Lp = pos.Lp, Count = pos.Count, Product = repo.GetById(pos.ProductId.Id.ToString()) }; return result; }
public OrderPosition DeleteOrderPosition(OrderPosition orderPosition) { OrderPosition dbEntry = context.OrderPositions.FirstOrDefault(p => p.OrderPositionId == orderPosition.OrderPositionId); if (dbEntry != null) { context.OrderPositions.Remove(dbEntry); context.SaveChanges(); } return(dbEntry); }
public OperationResult AddProductToCart(string userId, int productId, int selectedQuantity) { Product productToAdd = _productRepository.GetProductById(productId); if (selectedQuantity > productToAdd.Quantity) { return(OperationResult.Error("Error! Selected quantity is less than state of the warehouse.")); } if (selectedQuantity <= 0) { return(OperationResult.Error("Error! Selected quantity is too little.")); } var order = GetCartOrRestoreToCart(userId); if (order == null) { order = CreateNewOrder(userId); } var listOfOrderPositions = _orderRepository.GetOrderById(order.OrderId).OrderPositions; var existedProductInOrder = listOfOrderPositions .Where(o => o.ProductId == productId) .SingleOrDefault(); if (existedProductInOrder == null) { OrderPosition orderPosition = new OrderPosition { NameOfProduct = productToAdd.Name, Price = productToAdd.Price, Quantity = selectedQuantity, TotalPrice = selectedQuantity * productToAdd.Price, ProductId = productId, OrderId = order.OrderId }; _orderRepository.AddOrderPosition(orderPosition); } else { existedProductInOrder.Quantity = existedProductInOrder.Quantity + selectedQuantity; existedProductInOrder.TotalPrice = existedProductInOrder.Quantity * existedProductInOrder.Price; } var product = _productRepository.GetProductById(productId); product.Quantity = product.Quantity - selectedQuantity; _productRepository.UpdateProduct(product); _orderRepository.Submit(); return(OperationResult.Success()); }
public async Task <ActionResult> Order() { var userId = User.Identity.GetUserId(); var user = await _repository.User.Find(userId); if (user.BasketItems.Count == 0) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } var order = new Order { // Customer = user.Customer, CustomerId = 1, OrderDate = DateTime.Now, Discount = 0 }; _repository.Order.Add(order); await _repository.Commit(); var position = 1; foreach (var basketItem in user.BasketItems) { var orderPosition = new OrderPosition { Position = position, Order = order, Amount = basketItem.Amount, Product = basketItem.Product, Price = basketItem.Product.Price, Discount = 0 }; _repository.OrderPosition.Add(orderPosition); position++; } var basketItems = user.BasketItems.ToList(); for (int i = basketItems.Count - 1; i >= 0; i--) { _repository.BasketItem.Remove(basketItems[i]); } await _repository.Commit(); return(RedirectToAction("Details", "Orders", new { id = order.OrderId })); }
public void DeleteFullOrderPosition(OrderPosition orderPosition, DbTransaction dbTran) { _positionImProcessor.DeletePositionIm(orderPosition.PositionIm, dbTran); _rubricProcessor.DeleteRubricPositions(orderPosition.RubricPositions, dbTran); _graphicProcessor.DeleteGraphicPositions(orderPosition.GraphicPositions, dbTran); var isUnloaded = IsUnloaded(orderPosition); _repository.SetOrderPosition(orderPosition, isUnloaded, isActual: false, dbTran); _context.Entry(orderPosition).Reload(); }
public static Position Position(OrderPosition pos) { var repo = new ProductRepository(); var result = new Position { Lp = pos.Lp, Count = pos.Count, Product = repo.GetById(pos.ProductId.Id.ToString()) }; return(result); }
public void AddProduct(OrderPosition position) { var id = position.ProductId.Id.ToString(); var item = Products.Find(x => x.ProductId == id); if (item == null) { var repo = new ProductRepository(); var product = repo.GetById(id); var productSum = new ProductSum(position.ProductId.Id.ToString(), product.Name, product.Ean, position.Count); Products.Add(productSum); } else { item.ProductCount += position.Count; } }
public static List<OrderPosition> CreateOrderPosition() { var productRepository = new ProductRepository(); var products = productRepository.GetItemsList().ToList(); var radProduct = new Random(DateTime.Now.Millisecond); var productCount = radProduct.Next(1, 10); var result = new List<OrderPosition>(); for (int i = 0; i <= productCount; i++) { var j = radProduct.Next(products.Count()); var item = new OrderPosition(i + 1, products[j].Id.ToString(), radProduct.Next(1, 10)); result.Add(item); } return result; }
public void CreateData() { pos1 = new OrderPosition(1, "55ddaa59546c56237464705f", 2); pos2 = new OrderPosition(2, "55ddaa59546c56237464705f", 1); pos3 = new OrderPosition(3, "55ddaa59546c56237464705f", 3); }