コード例 #1
0
        public CustomerDto GetCustomerDtoByID(string customerId, ServicesController services)
        {
            try
            {
                var customer = services.customerServices.customerRepository.Set().ToList()
                               .FirstOrDefault(c => c.CustomerID == customerId);

                if (customer == null)
                {
                    NewLine();
                    Console.WriteLine("No existe el Cliente!");

                    return(null);
                }

                var customerDto = new CustomerDto()
                {
                    CustomerID  = customer.CustomerID,
                    ContactName = customer.ContactName,
                    CompanyName = customer.CompanyName,
                };

                return(customerDto);
            }
            catch
            {
                Console.WriteLine($"Se produjo un ERROR al intentar recuperar el Cliente con ID : '{customerId}'...");

                return(null);
            }
        }
コード例 #2
0
        public List <BestSellerProductDto> GetBestSellProduct(ServicesController services)
        {
            try
            {
                var customers = services.customerServices.GetAll();

                var bestSellerProducts = customers
                                         .Where(c => (c.CustomerID != null && c.Country != null))
                                         .GroupBy(c => c.Country)
                                         .Select(k => new BestSellerProductDto
                {
                    Country = k.Key,
                    Name    = k
                              .SelectMany(p => p.Orders)
                              .SelectMany(d => d.Order_Details)
                              .GroupBy(d => d.ProductID)
                              .OrderByDescending(d => d.Count())
                              .FirstOrDefault()
                              .Select(d => d.Product.ProductName)
                              .FirstOrDefault()
                }).ToList();

                return(bestSellerProducts);
            }
            catch
            {
                NewLine();
                Console.WriteLine($"Se produjo un ERROR al intentar obtener el Producto más vendido por País.");

                return(null);
            }
        }
コード例 #3
0
        public Employee GetEmployeeByID(Nullable <int> employeeId, ServicesController services)
        {
            try
            {
                var employee = services.employeeServices.employeeRepository.Set().ToList()
                               .FirstOrDefault(e => e.EmployeeID == employeeId);

                if (employee == null)
                {
                    NewLine();
                    Console.WriteLine("No existe el Empleado!");

                    return(null);
                }

                return(employee);
            }
            catch
            {
                NewLine();
                Console.WriteLine($"Se produjo un ERROR al intentar obtener el Empleado con ID : '{employeeId}'.");

                return(null);
            }
        }
コード例 #4
0
        public void Update(OrderDto orderDto, ServicesController services)
        {
            try
            {
                var order = this.orderRepository.Set()
                            .FirstOrDefault(x => x.OrderID == orderDto.OrderID);

                if (order == null)
                {
                    //throw new Exception("La orden no existe");
                    NewLine();
                    Console.WriteLine($"La Orden : {orderDto.OrderID} NO ha sido encontrada!.");
                }

                order.CustomerID     = orderDto.CustomerID;
                order.EmployeeID     = orderDto.EmployeeID;
                order.Freight        = orderDto.Freight;
                order.OrderDate      = orderDto.OrderDate;
                order.RequiredDate   = orderDto.RequiredDate;
                order.ShipAddress    = orderDto.ShipAddress;
                order.ShipCity       = orderDto.ShipCity;
                order.ShipCountry    = orderDto.ShipCountry;
                order.ShipName       = orderDto.ShipName;
                order.ShippedDate    = orderDto.ShippedDate;
                order.ShipPostalCode = orderDto.ShipPostalCode;
                order.ShipRegion     = orderDto.ShipRegion;
                order.ShipVia        = orderDto.ShipVia;
                //order.Order_Details = orderDto.Order_Details;

                NewLine();
                Console.WriteLine($"La Orden con ID : '{orderDto.OrderID}' ha sido modificada.");
                this.orderRepository.Update(order);
                this.orderRepository.SaveChanges();
            }
            catch
            {
                NewLine();
                Console.WriteLine($"Se produjo un ERROR al intentar Modificar la Orden con ID : '{orderDto.OrderID}'.");

                return;
            }
        }
コード例 #5
0
        public Customer GetCustomerByID(string customerId, ServicesController services)
        {
            var customer = services.customerServices.customerRepository.Set().ToList()
                           .FirstOrDefault(c => c.CustomerID == customerId);

            if (customer == null)
            {
                Console.WriteLine("No existe el Cliente!");
                return(null);
            }

            var customerByID = new Customer()
            {
                CustomerID  = customer.CustomerID,
                ContactName = customer.ContactName,
                CompanyName = customer.CompanyName,
            };

            return(customerByID);
        }
コード例 #6
0
        public List <BestCustomerDto> GetBestCostumer(ServicesController services)
        {
            try
            {
                var customers = services.customerServices.GetAll();

                var bestCostumers = customers
                                    .Where(c => c.Country != null)
                                    .GroupBy(c => c.Country)
                                    .Select(k => new BestCustomerDto
                {
                    Country = k.Key,

                    Name = k
                           .OrderByDescending(c => c.Orders
                                              .Sum(o => o.Order_Details
                                                   .Sum(d => d.Quantity * d.Product.UnitPrice)))
                           .Select(c => c.ContactName)
                           .FirstOrDefault(),

                    TotalPurchased = k.Select(v => v.Orders
                                              .Where(c => c.CustomerID == k
                                                     .OrderByDescending(b => b.Orders
                                                                        .Sum(o => o.Order_Details
                                                                             .Sum(d => d.Quantity * d.Product.UnitPrice)))
                                                     .Select(b => b.CustomerID)
                                                     .FirstOrDefault())
                                              .Sum(g => g.Order_Details
                                                   .Sum(d => d.Quantity * d.Product.UnitPrice)))
                                     .Sum()
                }).ToList();

                return(bestCostumers);
            }
            catch
            {
                Console.WriteLine("Se produjo un ERROR al intentar obtener el mejor Cliente por País...");

                return(null);
            }
        }
コード例 #7
0
        public ICollection <OrderDto> GetAll(ServicesController services)
        {
            try
            {
                return(this.orderRepository.Set()
                       .ToList()
                       .Select(o => new OrderDto
                {
                    OrderID = o.OrderID,
                    CustomerID = o.CustomerID,
                    EmployeeID = o.EmployeeID,
                    ShipName = o.ShipName,
                }).ToList());
            }
            catch
            {
                Console.WriteLine("Se produjo un ERROR al intentar obtener todas las Ordenes...");

                return(null);
            }
        }
コード例 #8
0
        //public EmployeeDto GetEmployeeByID(Nullable<int> employeeId)
        public EmployeeDto GetEmployeeDtoByID(Nullable <int> employeeId, ServicesController services)
        {
            var employee = services.employeeServices.employeeRepository.Set().ToList()
                           .FirstOrDefault(e => e.EmployeeID == employeeId);

            if (employee == null)
            {
                Console.WriteLine("No existe el Empleado!");
                return(null);
            }

            //var employeeDto = new EmployeeDto()
            var employeeDto = new EmployeeDto()
            {
                EmployeeID = employee.EmployeeID,
                //ContactName = employee.ContactName,
                //CompanyName = employee.CompanyName,
            };

            return(employeeDto);
        }
コード例 #9
0
        public ICollection <Order> GetAllByIDOfCustomer(string customerID, ServicesController services)
        {
            try
            {
                return(this.orderRepository.Set()
                       .Where(o => o.CustomerID == customerID)
                       .Select(o => new Order
                {
                    OrderID = o.OrderID,
                    CustomerID = o.CustomerID,
                    ShipCountry = o.ShipCountry,
                    Order_Details = o.Order_Details,
                }).ToList());
            }
            catch
            {
                NewLine();
                Console.WriteLine("Se produjo un ERROR al intentar obtener todas las ");
                Console.WriteLine($"ordenes del Cliente con ID: '{customerID}'.");

                return(null);
            }
        }
コード例 #10
0
        public Order GetOrderByID(int orderId, ServicesController services)
        {
            try
            {
                var order = this.orderRepository.Set().ToList()
                            .FirstOrDefault(c => c.OrderID == orderId);

                if (order == null)
                {
                    NewLine();
                    Console.WriteLine("No existe la orden!");

                    return(null);
                }


                var orderDetails = new HashSet <Order_Detail>();

                foreach (var orderDetail in order.Order_Details)
                {
                    orderDetails.Add(new Order_Detail()
                    {
                        Discount  = orderDetail.Discount,
                        OrderID   = orderDetail.OrderID,
                        ProductID = orderDetail.ProductID,
                        Quantity  = orderDetail.Quantity,
                        UnitPrice = orderDetail.UnitPrice,
                    });
                }


                var orderByID = new Order()
                {
                    OrderID        = order.OrderID,
                    CustomerID     = order.CustomerID,
                    EmployeeID     = order.EmployeeID,
                    OrderDate      = order.OrderDate,
                    RequiredDate   = order.RequiredDate,
                    ShippedDate    = order.ShippedDate,
                    Freight        = order.Freight,
                    ShipName       = order.ShipName,
                    ShipCity       = order.ShipCity,
                    ShipRegion     = order.ShipRegion,
                    ShipPostalCode = order.ShipPostalCode,
                    ShipCountry    = order.ShipCountry,

                    //Customer
                    Customer = services.customerServices.GetCustomerByID(order.CustomerID, services),
                    //Employee
                    Employee = services.employeeServices.GetEmployeeByID(order.EmployeeID, services),

                    Order_Details = orderDetails,

                    //Shipper
                };

                return(orderByID);
            }
            catch
            {
                Console.WriteLine($"Se produjo un ERROR al intentar obtener la Orden con ID : '{orderId}'...");

                return(null);
            }
        }
コード例 #11
0
        public void Remove(OrderDto orderDto, ServicesController services)
        {
            try
            {
                var deletedOrderId = orderDto.OrderID;

                var orderRemove = this.orderRepository.Set()
                                  .FirstOrDefault(x => x.OrderID == orderDto.OrderID);

                if (orderRemove == null)
                {
                    throw new Exception("La Orden no existe!");
                }

                using (var detailsServices = new OrderDetailsServices())
                {
                    if (orderRemove.Order_Details.Any())
                    {
                        var detailsRemove = detailsServices.GetAll()
                                            .Where(d => d.OrderID == orderRemove.OrderID)
                                            .Select(d => new Order_Detail
                        {
                            OrderID = d.OrderID,
                            Order   = new Order
                            {
                                OrderID = d.OrderID
                            },
                            Discount  = d.Discount,
                            Product   = services.productServices.GetProductByID(d.ProductID),
                            ProductID = d.ProductID,
                            Quantity  = d.Quantity,
                            UnitPrice = d.UnitPrice,
                        });

                        foreach (var detail in orderRemove.Order_Details)
                        {
                            var detailRemove = this.orderDetailsRepository.Set()
                                               .FirstOrDefault(x => x.OrderID == orderRemove.OrderID);

                            if (detailRemove == null)
                            {
                                throw new Exception("No hay Detalle de Orden.");
                            }

                            NewLine();
                            Console.WriteLine($"El Detalle con ID de Orden : {detail.OrderID}, Producto : {detail.Product.ProductName}, Cantidad : {detail.Quantity} será eliminado.");

                            this.orderDetailsRepository.Remove(detailRemove);
                            this.orderDetailsRepository.SaveChanges();
                        }

                        NewLine();
                        Console.WriteLine($"Detalles eliminados.");
                    }
                    else
                    {
                        NewLine();
                        Console.WriteLine($"La Orden no tenía Detalles asociados.");
                    }

                    var order = this.orderRepository.Set()
                                .FirstOrDefault(x => x.OrderID == deletedOrderId);

                    if (order == null)
                    {
                        throw new Exception("El cliente no existe");
                    }

                    this.orderRepository.Remove(order);
                    this.orderRepository.SaveChanges();

                    NewLine();
                    Console.WriteLine($"La Orden con ID : {deletedOrderId} ha sido eliminada con éxito.");
                }
            }
            catch
            {
                NewLine();
                Console.WriteLine($"Se produjo un ERROR al intentar Eliminar la Orden con ID: '{orderDto.OrderID}'.");

                return;
            }
        }
コード例 #12
0
        public void Create(OrderDto orderDto, ServicesController services)
        {
            var OrderDetails = new HashSet <Order_Detail>();

            try
            {
                foreach (var orderDetail in orderDto.Order_Details)
                {
                    OrderDetails.Add(new Order_Detail
                    {
                        Discount  = orderDetail.Discount,
                        OrderID   = orderDetail.OrderID,
                        ProductID = orderDetail.ProductID,
                        Product   = services.productServices.GetProductByID(orderDetail.ProductID),
                        Quantity  = orderDetail.Quantity,
                        UnitPrice = orderDetail.UnitPrice,
                    });
                }
            }
            catch
            {
                NewLine();
                Console.WriteLine("Se produjo un ERROR al agregar los Detalles de Orden ");
                Console.WriteLine("al intentar Crear una nueva Orden...");

                return;
            }

            try
            {
                this.orderRepository.Persist(new Order
                {
                    OrderID        = orderDto.OrderID,
                    CustomerID     = orderDto.CustomerID,
                    EmployeeID     = orderDto.EmployeeID,
                    OrderDate      = orderDto.OrderDate,
                    RequiredDate   = orderDto.RequiredDate,
                    ShippedDate    = orderDto.ShippedDate,
                    Freight        = orderDto.Freight,
                    ShipName       = orderDto.ShipName,
                    ShipCity       = orderDto.ShipCity,
                    ShipRegion     = orderDto.ShipRegion,
                    ShipPostalCode = orderDto.ShipPostalCode,
                    ShipAddress    = orderDto.ShipAddress,
                    ShipCountry    = orderDto.ShipCountry,
                    ShipVia        = orderDto.ShipVia,
                    //Customer
                    //Customer = services.customerServices.GetCustomerByID(orderDto.CustomerID,services),
                    //Employee = orderDto.Employee,
                    //Employee = services.employeeServices.GetEmployeeByID(orderDto.EmployeeID,services),
                    //Shipper
                    Order_Details = OrderDetails,
                });

                this.orderRepository.SaveChanges();
            }
            catch
            {
                NewLine();
                Console.WriteLine($"Se produjo un ERROR de guardado al intentar Crear la nueva Orden.");

                return;
            }
        }
コード例 #13
0
        public Order GetOrderByID(int orderId, ServicesController services)
        {
            var order = orderRepository.Set().ToList()
                        .FirstOrDefault(c => c.OrderID == orderId);

            if (order == null)
            {
                Console.WriteLine("No existe la orden!");
                return(null);
            }

            //CARGO LAS ORDENES EN UNA LISTA
            var orderDetails = new HashSet <Order_Detail>();

            foreach (var orderDetail in order.Order_Details)
            {
                orderDetails.Add(new Order_Detail()
                {
                    Discount = orderDetail.Discount,
                    //Order = orderDetail.Order,
                    OrderID = orderDetail.OrderID,
                    //Product = orderDetail.Product,
                    ProductID = orderDetail.ProductID,
                    Quantity  = orderDetail.Quantity,
                    UnitPrice = orderDetail.UnitPrice,
                });
            }


            var orderByID = new Order()
            {
                OrderID        = order.OrderID,
                CustomerID     = order.CustomerID,
                EmployeeID     = order.EmployeeID,
                OrderDate      = order.OrderDate,
                RequiredDate   = order.RequiredDate,
                ShippedDate    = order.ShippedDate,
                Freight        = order.Freight,
                ShipName       = order.ShipName,
                ShipCity       = order.ShipCity,
                ShipRegion     = order.ShipRegion,
                ShipPostalCode = order.ShipPostalCode,
                ShipCountry    = order.ShipCountry,

                //Customer
                Customer = services.customerServices.GetCustomerByID(order.CustomerID, services),
                //Employee = orderDto.Employee,
                Employee = services.employeeServices.GetEmployeeByID(order.EmployeeID, services),

                Order_Details = orderDetails,

                /*Order_Details = new HashSet<Order_Detail>()
                 * {
                 *  foreach (var order in orderDto.Order_Details)
                 *  {
                 *  new Order_Detail()
                 *  {
                 *      Discount = order.Discount,
                 *      //Order = order.Order,
                 *      OrderID = order.OrderID,
                 *      //Product = order.Product,
                 *      ProductID = order.ProductID,
                 *      Quantity = order.Quantity,
                 *      UnitPrice = order.UnitPrice,
                 *  };
                 * } });
                 */

                //Shipper
            };



            return(orderByID);
        }
コード例 #14
0
        public void Create(OrderDto orderDto, ServicesController services)
        {
            //CARGO LAS ORDENES EN UNA LISTA
            var OrderDetails = new HashSet <Order_Detail>();

            foreach (var orderDetail in orderDto.Order_Details)
            {
                OrderDetails.Add(new Order_Detail
                {
                    Discount = orderDetail.Discount,
                    //Order = orderDetail.Order,
                    Order   = services.orderServices.GetOrderByID(orderDetail.OrderID, services),
                    OrderID = orderDetail.OrderID,
                    //Product = orderDetail.Product,
                    ProductID = orderDetail.ProductID,
                    Quantity  = orderDetail.Quantity,
                    UnitPrice = orderDetail.UnitPrice,
                });
            }

            orderRepository.Persist(new Order
            {
                OrderID        = orderDto.OrderID,
                CustomerID     = orderDto.CustomerID,
                EmployeeID     = orderDto.EmployeeID,
                OrderDate      = orderDto.OrderDate,
                RequiredDate   = orderDto.RequiredDate,
                ShippedDate    = orderDto.ShippedDate,
                Freight        = orderDto.Freight,
                ShipName       = orderDto.ShipName,
                ShipCity       = orderDto.ShipCity,
                ShipRegion     = orderDto.ShipRegion,
                ShipPostalCode = orderDto.ShipPostalCode,
                ShipAddress    = orderDto.ShipAddress,
                ShipCountry    = orderDto.ShipCountry,
                ShipVia        = orderDto.ShipVia,
                //Customer
                //Customer = services.customerServices.GetCustomerByID(orderDto.CustomerID,services),
                //Employee = orderDto.Employee,
                //Employee = services.employeeServices.GetEmployeeByID(orderDto.EmployeeID,services),
                //Shipper

                Order_Details = OrderDetails,

                /*Order_Details = new HashSet<Order_Detail>()
                 * {
                 *  foreach (var order in orderDto.Order_Details)
                 *  {
                 *  new Order_Detail()
                 *  {
                 *      Discount = order.Discount,
                 *      //Order = order.Order,
                 *      OrderID = order.OrderID,
                 *      //Product = order.Product,
                 *      ProductID = order.ProductID,
                 *      Quantity = order.Quantity,
                 *      UnitPrice = order.UnitPrice,
                 *  };
                 * } });
                 */
            });


            orderRepository.SaveChanges();
        }
コード例 #15
0
        //public void ModifyOrder(string orderId)
        public void Modify(OrderDto orderDto, ServicesController services)
        {
            var order = orderRepository.Set()
                        .FirstOrDefault(x => x.OrderID == orderDto.OrderID);

            if (order == null)
            {
                throw new Exception("La orden no existe");
            }

            Console.WriteLine($"La Orden : {orderDto.OrderID} ha sido encontrada.");
            //Console.WriteLine($"Su Nombre de Contacto es : {orderDto.ContactName}.");

            //OrderID

            var orderId = 0;

            do
            {
                Console.WriteLine("");
                Console.WriteLine("Ingrese el nuevo ID de la Orden:");
            }while (int.TryParse(Console.ReadLine(), out orderId));

            orderDto.OrderID = orderId;


            //ContactName
            Console.WriteLine("");
            Console.WriteLine("Ingrese el País destino de la Orden:");
            orderDto.ShipCountry = Console.ReadLine();

            //Date

            DateTime orderDate;

            do
            {
                Console.WriteLine("");
                Console.WriteLine("Ingrese la fecha de Orden (formato dd/MM/yyyy):");
            }while (!(DateTime.TryParseExact(Console.ReadLine(),
                                             "dd/MM/yyyy",
                                             CultureInfo.InvariantCulture,
                                             DateTimeStyles.None,
                                             out orderDate)));

            /*
             * if (DateTime.TryParseExact(Console.ReadLine(),
             *                          "dd/MM/yyyy",
             *                          CultureInfo.InvariantCulture,
             *                          DateTimeStyles.None,
             *  out dt))
             * {
             *  //valid date
             *
             * }
             * else
             * {
             *  //invalid date
             * }
             */
            orderRepository.Update(order);
            orderRepository.SaveChanges();
        }