Exemplo n.º 1
0
        public void Delete(PurchaseOrderContract purchaseOrderContract)
        {
            var PurchaseOrderContract = IPurchaseOrderRepository.Get(purchaseOrderContract.Id);

            IPurchaseOrderRepository.Delete(PurchaseOrderContract);
        }
Exemplo n.º 2
0
        public void CreateAndUpdatePurchaseOrder(PurchaseOrderContract purchaseOrderContract)
        {
            var purchaseorder = IPurchaseOrderRepository.Get(purchaseOrderContract.Id);

            if (purchaseorder != null)
            {
                purchaseorder.Code = purchaseOrderContract.Code;
                //purchaseorder.CreationDate = purchaseOrderContract.CreationDate;
                purchaseorder.Title = purchaseOrderContract.Title;
                for (int i = 0; i < purchaseOrderContract.PurchaseOrderItemContracts.Count; i++)
                {
                    var Temp = purchaseOrderContract.PurchaseOrderItemContracts[i];
                    if (purchaseorder.purchaseOrderItems.Any(s => s.Id == Temp.Id))
                    {
                        var Inpurchaseorderitem = purchaseorder.purchaseOrderItems.FirstOrDefault(s => s.Id == Temp.Id);
                        Inpurchaseorderitem.NetPrice   = Temp.NetPrice;
                        Inpurchaseorderitem.Quantity   = Temp.Quantity;
                        Inpurchaseorderitem.TotalPrice = Temp.TotalPrice;
                        Inpurchaseorderitem.UnitPrice  = Temp.UnitPrice;
                        Inpurchaseorderitem.Rack       = IRackRepository.Get(Temp.RackId);
                        Inpurchaseorderitem.Item       = IItemRepository.Get(Temp.ItemId);
                    }
                    else
                    {
                        Inpurchaseorderitem            = new PurchaseOrderItem();
                        Inpurchaseorderitem.NetPrice   = Temp.NetPrice;
                        Inpurchaseorderitem.Quantity   = Temp.Quantity;
                        Inpurchaseorderitem.TotalPrice = Temp.TotalPrice;
                        Inpurchaseorderitem.UnitPrice  = Temp.UnitPrice;
                        Inpurchaseorderitem.Rack       = IRackRepository.Get(Temp.RackId);
                        Inpurchaseorderitem.Item       = IItemRepository.Get(Temp.ItemId);


                        purchaseorder.purchaseOrderItems.Add(Inpurchaseorderitem);
                    }
                }

                for (int i = 0; i < purchaseorder.purchaseOrderItems.Count; i++)
                {
                    var Temp = purchaseorder.purchaseOrderItems.ToArray()[i];
                    if (!purchaseOrderContract.PurchaseOrderItemContracts.Any(s => s.Id == Temp.Id))
                    {
                        purchaseorder.purchaseOrderItems.Remove(Temp);
                    }
                }

                IPurchaseOrderRepository.Update(purchaseorder);
            }
            else
            {
                purchaseorder              = new PurchaseOrder();
                purchaseorder.Code         = purchaseOrderContract.Code;
                purchaseorder.CreationDate = purchaseOrderContract.CreationDate;
                purchaseorder.Title        = purchaseOrderContract.Title;
                for (int i = 0; i < purchaseOrderContract.PurchaseOrderItemContracts.Count; i++)
                {
                    var Temp = purchaseOrderContract.PurchaseOrderItemContracts[i];
                    Inpurchaseorderitem            = new PurchaseOrderItem();
                    Inpurchaseorderitem.NetPrice   = Temp.NetPrice;
                    Inpurchaseorderitem.Quantity   = Temp.Quantity;
                    Inpurchaseorderitem.TotalPrice = Temp.TotalPrice;
                    Inpurchaseorderitem.UnitPrice  = Temp.UnitPrice;
                    Inpurchaseorderitem.Item       = IItemRepository.Get(Temp.ItemId);
                    Inpurchaseorderitem.Rack       = IRackRepository.Get(Temp.RackId);
                }
            }


            IPurchaseOrderRepository.Insert(purchaseorder);
        }
Exemplo n.º 3
0
        public void CreateAndDelete(PurchaseOrderContract purchaseOrderContract)
        {
            var PurchaseOrder = IPurchaseOrderRepository.Get(purchaseOrderContract.Id);

            if (PurchaseOrder != null)
            {
                PurchaseOrder.CreationDate = DateTime.Now;
                PurchaseOrder.Title        = purchaseOrderContract.Title;
                PurchaseOrder.Code         = purchaseOrderContract.Code;

                for (int i = 0; i < purchaseOrderContract.PurchaseOrderItems.Count; i++)

                {
                    var temp = purchaseOrderContract.PurchaseOrderItems[i];
                    if (PurchaseOrder.PurchaseOrderItems.Any(p => p.Id == temp.Id))
                    {
                        var Porderitem = PurchaseOrder.PurchaseOrderItems.FirstOrDefault(p => p.Id == temp.Id);

                        Porderitem.QTY        = temp.QTY;
                        Porderitem.Name       = temp.Name;
                        Porderitem.NetPrice   = temp.NetPrice;
                        Porderitem.TotalPrice = temp.TotalPrice;
                        Porderitem.UnitPrice  = temp.UnitPrice;
                        Porderitem.Item1      = iitemRepository.Get(temp.ItemId);
                        Porderitem.Rack1      = iRackRepository.Get(temp.RackId);
                    }


                    else
                    {
                        var res = new PurchaseOrderItem();
                        res.QTY        = temp.QTY;
                        res.Name       = temp.Name;
                        res.NetPrice   = temp.NetPrice;
                        res.TotalPrice = temp.TotalPrice;
                        res.UnitPrice  = temp.UnitPrice;
                        res.Item1      = iitemRepository.Get(temp.ItemId);
                        res.Rack1      = iRackRepository.Get(temp.RackId);

                        PurchaseOrder.PurchaseOrderItems.Add(res);
                    }
                }

                foreach (var item in PurchaseOrder.PurchaseOrderItems)
                {
                    if (PurchaseOrder.PurchaseOrderItems.Any(s => s.Id != item.Id))
                    {
                        PurchaseOrder.PurchaseOrderItems.Remove(item);
                    }
                }
                IPurchaseOrderRepository.Update(PurchaseOrder);
            }
            else
            {
                PurchaseOrder.CreationDate = purchaseOrderContract.CreationDate;
                PurchaseOrder.Title        = purchaseOrderContract.Title;
                PurchaseOrder.Code         = purchaseOrderContract.Code;

                for (int i = 0; i < purchaseOrderContract.PurchaseOrderItems.Count; i++)
                {
                    var temp = purchaseOrderContract.PurchaseOrderItems[i];
                    if (PurchaseOrder.PurchaseOrderItems.Any(p => p.Id == temp.Id))
                    {
                        var Porderitem = PurchaseOrder.PurchaseOrderItems.FirstOrDefault(p => p.Id == temp.Id);

                        Porderitem.QTY        = temp.QTY;
                        Porderitem.Name       = temp.Name;
                        Porderitem.NetPrice   = temp.NetPrice;
                        Porderitem.TotalPrice = temp.TotalPrice;
                        Porderitem.UnitPrice  = temp.UnitPrice;
                        Porderitem.Item1      = iitemRepository.Get(temp.ItemId);
                        Porderitem.Rack1      = iRackRepository.Get(temp.RackId);
                    }
                }

                IPurchaseOrderRepository.Insert(PurchaseOrder);
            }
        }
Exemplo n.º 4
0
        public void CreateOrUpdate(PurchaseOrderContract purchaseOrderContract)
        {
            var PurchaseOrder = IPurchaseOrderRepository.Get(purchaseOrderContract.Id);

            if (PurchaseOrder != null)
            {
                PurchaseOrder.CreationDate = DateTime.Now;
                PurchaseOrder.Title        = purchaseOrderContract.Title;
                PurchaseOrder.Code         = purchaseOrderContract.Code;

                for (int i = 0; i < purchaseOrderContract.PurchaseOrderItems.Count; i++)
                {
                    var temp = purchaseOrderContract.PurchaseOrderItems[i];
                    if (PurchaseOrder.PurchaseOrderItems.Any(p => p.Id == temp.Id))
                    {
                        var Porderitem = PurchaseOrder.PurchaseOrderItems.FirstOrDefault(p => p.Id == temp.Id);

                        Porderitem.Quantity = temp.Quantity;

                        Porderitem.NetPrice   = temp.NetPrice;
                        Porderitem.TotalPrice = temp.TotalPrice;
                        Porderitem.UnitPrice  = temp.UnitPrice;
                        Porderitem.Item       = IItemRepository.Get(temp.ItemId);
                        Porderitem.Rack       = IRackRepository.Get(temp.RackId);
                    }


                    else
                    {
                        var Porderitem = new PurchaseOrderItem();
                        Porderitem.Quantity = temp.Quantity;

                        Porderitem.NetPrice   = temp.NetPrice;
                        Porderitem.TotalPrice = temp.TotalPrice;
                        Porderitem.UnitPrice  = temp.UnitPrice;
                        Porderitem.Item       = IItemRepository.Get(temp.ItemId);
                        Porderitem.Rack       = IRackRepository.Get(temp.RackId);
                        PurchaseOrder.PurchaseOrderItems.Add(Porderitem);
                    }
                }

                foreach (var item in PurchaseOrder.PurchaseOrderItems)
                {
                    if (!purchaseOrderContract.PurchaseOrderItems.Any(p => p.Id == item.Id))
                    {
                        PurchaseOrder.PurchaseOrderItems.Remove(item);
                    }
                }

                IPurchaseOrderRepository.Update(PurchaseOrder);
            }



            else
            {
                PurchaseOrder = new PurchaseOrder();
                PurchaseOrder.CreationDate = purchaseOrderContract.CreationDate;
                PurchaseOrder.Title        = purchaseOrderContract.Title;
                PurchaseOrder.Code         = purchaseOrderContract.Code;

                for (int i = 0; i < purchaseOrderContract.PurchaseOrderItems.Count; i++)
                {
                    var temp       = purchaseOrderContract.PurchaseOrderItems[i];
                    var Porderitem = new PurchaseOrderItem();
                    Porderitem.NetPrice   = temp.NetPrice;
                    Porderitem.TotalPrice = temp.TotalPrice;
                    Porderitem.UnitPrice  = temp.UnitPrice;
                    Porderitem.Item       = IItemRepository.Get(temp.ItemId);
                    Porderitem.Rack       = IRackRepository.Get(temp.RackId);
                    PurchaseOrder.PurchaseOrderItems.Add(Porderitem);
                }

                IPurchaseOrderRepository.Insert(PurchaseOrder);
            }
        }
        public void Delete(PurchaseOrderContract purchaseOrderContract)
        {
            var purchaseorder = PurchaseOrderRepository.Get(purchaseOrderContract.Id);

            PurchaseOrderRepository.Delete(purchaseorder);
        }
        public void CreateOrUpdate(PurchaseOrderContract purchaseOrderContract)
        {
            var purchaseorder = PurchaseOrderRepository.Get(purchaseOrderContract.Id);

            if (purchaseorder != null)
            {
                purchaseorder.Code = purchaseOrderContract.Code;
                //purchaseorder.CreationDate = purchaseOrderContract.CreationDate;
                purchaseorder.Title = purchaseOrderContract.Title;
                for (int i = 0; i < purchaseOrderContract.PurchaseOrderItems.Count; i++)
                {
                    var temp = purchaseOrderContract.PurchaseOrderItems[i];
                    if (purchaseorder.PurcahseOrderItems.Any(p => p.Id == temp.Id))
                    {
                        var indatabasepurchaseorder = purchaseorder.PurcahseOrderItems.FirstOrDefault(p => p.Id == temp.Id);
                        indatabasepurchaseorder.NetPrice   = temp.NetPrice;
                        indatabasepurchaseorder.Quantity   = temp.Quantity;
                        indatabasepurchaseorder.TotalPrice = temp.TotalPrice;
                        indatabasepurchaseorder.UnitPrice  = temp.UnitPrice;
                        indatabasepurchaseorder.Item       = ItemRepository.Get(temp.ItemId);
                        indatabasepurchaseorder.Rack       = RackRepository.Get(temp.RackId);
                    }
                    else
                    {
                        var purchaseorderitem = new PurchaseOrderItem();
                        purchaseorderitem.NetPrice   = temp.NetPrice;
                        purchaseorderitem.Quantity   = temp.Quantity;
                        purchaseorderitem.TotalPrice = temp.TotalPrice;
                        purchaseorderitem.UnitPrice  = temp.UnitPrice;
                        purchaseorderitem.Item       = ItemRepository.Get(temp.ItemId);
                        purchaseorderitem.Rack       = RackRepository.Get(temp.RackId);


                        purchaseorder.PurcahseOrderItems.Add(purchaseorderitem);
                    }
                }
                for (int i = 0; i < purchaseorder.PurcahseOrderItems.Count; i++)
                {
                    var temp = purchaseorder.PurcahseOrderItems.ToArray()[i];
                    if (!purchaseOrderContract.PurchaseOrderItems.Any(p => p.Id == temp.Id))
                    {
                        purchaseorder.PurcahseOrderItems.Remove(temp);
                    }
                }

                PurchaseOrderRepository.Update(purchaseorder);
            }
            else
            {
                purchaseorder              = new PurchaseOrder();
                purchaseorder.Code         = purchaseOrderContract.Code;
                purchaseorder.CreationDate = purchaseOrderContract.CreationDate;
                purchaseorder.Title        = purchaseOrderContract.Title;
                for (int i = 0; i < purchaseOrderContract.PurchaseOrderItems.Count; i++)
                {
                    var temp = purchaseOrderContract.PurchaseOrderItems[i];

                    var indatabaepurchaseorder = purchaseorder.PurcahseOrderItems.FirstOrDefault(p => p.Id == temp.Id);
                    indatabaepurchaseorder.NetPrice   = temp.NetPrice;
                    indatabaepurchaseorder.Quantity   = temp.Quantity;
                    indatabaepurchaseorder.TotalPrice = temp.TotalPrice;
                    indatabaepurchaseorder.UnitPrice  = temp.UnitPrice;
                    indatabaepurchaseorder.Item       = ItemRepository.Get(temp.ItemId);
                    indatabaepurchaseorder.Rack       = RackRepository.Get(temp.RackId);
                }

                PurchaseOrderRepository.Insert(purchaseorder);
            }
        }
        public void CreateAndUpdatePurchaseOrder(PurchaseOrderContract purchaseOrderContract)
        {
            //db
            var purchaseOrder = PurchaseOrderRepository.Get(purchaseOrderContract.Id);

            if (purchaseOrder != null)
            {
                // Update Order
                purchaseOrder.Title = purchaseOrderContract.Title;

                for (int i = 0; i < purchaseOrderContract.PurchaseOrderItemContracts.Count; i++)
                {
                    var temp = purchaseOrderContract.PurchaseOrderItemContracts[i];
                    if (purchaseOrder.PurchaseOrderItems.Any(x => x.Id == temp.Id))
                    {
                        //Update OrderItem
                        var InDatabaseOrderItem = purchaseOrder.PurchaseOrderItems.FirstOrDefault(x => x.Id == temp.Id);
                        InDatabaseOrderItem.NetPrice   = temp.NetPrice;
                        InDatabaseOrderItem.Quantity   = temp.Quantity;
                        InDatabaseOrderItem.UnitPrice  = temp.UnitPrice;
                        InDatabaseOrderItem.TotalPrice = temp.TotalPrice;
                        InDatabaseOrderItem.Item       = IitemRepository.Get(temp.ItemId);
                        InDatabaseOrderItem.Rack       = IRackRepository.Get(temp.RackId);
                    }
                    else
                    {
                        //Create OrderItem
                        var InDatabaseOrderItem = new PurchaseOrderItem();

                        InDatabaseOrderItem.NetPrice   = temp.NetPrice;
                        InDatabaseOrderItem.Quantity   = temp.Quantity;
                        InDatabaseOrderItem.UnitPrice  = temp.UnitPrice;
                        InDatabaseOrderItem.TotalPrice = temp.TotalPrice;
                        InDatabaseOrderItem.Item       = IitemRepository.Get(temp.ItemId);
                        InDatabaseOrderItem.Rack       = IRackRepository.Get(temp.RackId);

                        purchaseOrder.PurchaseOrderItems.Add(InDatabaseOrderItem);
                    }
                }

                for (int i = 0; i < purchaseOrder.PurchaseOrderItems.Count; i++) //db
                {
                    var temp = purchaseOrder.PurchaseOrderItems[i];
                    //Delete extra orderItems in order(DB)
                    if (!purchaseOrderContract.PurchaseOrderItemContracts.Any(x => x.Id == temp.Id))
                    {
                        ;
                    }
                    {
                        //if (purchaseOrderContract.PurchaseOrderItemContracts.Exists(d => d.Id != temp.Id))
                        purchaseOrder.PurchaseOrderItems.Remove(temp);
                    }
                }

                PurchaseOrderRepository.Update(purchaseOrder);
            }
            else
            {
                // Create Order
                purchaseOrder              = new PurchaseOrder();
                purchaseOrder.Code         = purchaseOrderContract.Code;
                purchaseOrder.CreationDate = purchaseOrderContract.CreationDate;
                purchaseOrder.Title        = purchaseOrderContract.Title;

                for (int i = 0; i < purchaseOrderContract.PurchaseOrderItemContracts.Count; i++)
                {
                    var temp = purchaseOrderContract.PurchaseOrderItemContracts[i];

                    var InDatabaseOrderItem = new PurchaseOrderItem();

                    InDatabaseOrderItem.NetPrice   = temp.NetPrice;
                    InDatabaseOrderItem.Quantity   = temp.Quantity;
                    InDatabaseOrderItem.UnitPrice  = temp.UnitPrice;
                    InDatabaseOrderItem.TotalPrice = temp.TotalPrice;
                    InDatabaseOrderItem.Item       = IitemRepository.Get(temp.ItemId);
                    InDatabaseOrderItem.Rack       = IRackRepository.Get(temp.RackId);

                    purchaseOrder.PurchaseOrderItems.Add(InDatabaseOrderItem);
                }

                PurchaseOrderRepository.Insert(purchaseOrder);
            }
        }
Exemplo n.º 8
0
 public void Delete(PurchaseOrderContract purchaseOrderContract)
 {
 }
Exemplo n.º 9
0
        public void SaveCreateOrUpdate(PurchaseOrderContract purchaseOrderContract)
        {
            var PurchaseOrderDB = IPurchaseOrderRepository.Get(purchaseOrderContract.Id);

            if (PurchaseOrderDB != null)
            {
                for (int i = 0; i < purchaseOrderContract.PurchaseOrderItemsContracts.Count; i++)
                {
                    var temp = purchaseOrderContract.PurchaseOrderItemsContracts[i];
                    if (PurchaseOrderDB.PurchaseOrderItems.Any(s => s.Id == temp.Id))
                    {
                        var indatabaseorderitem = PurchaseOrderDB.PurchaseOrderItems.FirstOrDefault(s => s.Id == temp.Id);

                        indatabaseorderitem.NetPrice   = temp.NetPrice;
                        indatabaseorderitem.Quantity   = temp.Quantity;
                        indatabaseorderitem.TotalPrice = temp.TotalPrice;
                        indatabaseorderitem.UnitPrice  = temp.UnitPrice;
                        //todo eslah behtar minevisim
                        indatabaseorderitem.Item = IItemRepository.Get(temp.ItemId);
                        indatabaseorderitem.Rack = IRackRepository.Get(temp.RackId);
                    }
                    else
                    {
                        PurchaseOrderItem purchaseorderitem = new PurchaseOrderItem();
                        purchaseorderitem.NetPrice   = temp.NetPrice;
                        purchaseorderitem.Quantity   = temp.Quantity;
                        purchaseorderitem.TotalPrice = temp.TotalPrice;
                        purchaseorderitem.UnitPrice  = temp.UnitPrice;
                        purchaseorderitem.Item       = IItemRepository.Get(temp.ItemId);
                        purchaseorderitem.Rack       = IRackRepository.Get(temp.RackId);
                        PurchaseOrderDB.PurchaseOrderItems.Add(purchaseorderitem);
                    }
                }

                //if you want delete one or more to item deleted
                for (int i = 0; i < PurchaseOrderDB.PurchaseOrderItems.Count; i++)
                {
                    var temp = PurchaseOrderDB.PurchaseOrderItems[i];

                    if (purchaseOrderContract.PurchaseOrderItemsContracts.All(s => s.Id != temp.Id))
                    {
                        PurchaseOrderDB.PurchaseOrderItems.Remove(temp);
                    }
                }
                IPurchaseOrderRepository.Update(PurchaseOrderDB);
            }
            else
            {
                PurchaseOrderDB              = new PurchaseOrder();
                PurchaseOrderDB.Code         = purchaseOrderContract.Code;
                PurchaseOrderDB.CreationDate = purchaseOrderContract.CreationDate;
                PurchaseOrderDB.Title        = purchaseOrderContract.Title;
                for (int i = 0; i < purchaseOrderContract.PurchaseOrderItemsContracts.Count; i++)
                {
                    var temp = purchaseOrderContract.PurchaseOrderItemsContracts[i];

                    PurchaseOrderItem purchaseorderitem = new PurchaseOrderItem();
                    purchaseorderitem.NetPrice   = temp.NetPrice;
                    purchaseorderitem.Quantity   = temp.Quantity;
                    purchaseorderitem.TotalPrice = temp.TotalPrice;
                    purchaseorderitem.UnitPrice  = temp.UnitPrice;
                    purchaseorderitem.Item       = IItemRepository.Get(temp.ItemId);
                    purchaseorderitem.Rack       = IRackRepository.Get(temp.RackId);

                    PurchaseOrderDB.PurchaseOrderItems.Add(purchaseorderitem);
                }
                IPurchaseOrderRepository.Insert(PurchaseOrderDB);
            }
        }