Ejemplo n.º 1
0
        public async Task CancelOrder(int id)
        {
            await StatusService.CheckRightsForOrderAddDelete();

            await ModifyOrder(id, new StatusModModel()
            {
                Status = nameof(OrderStatus.Cancelled)
            });
        }
Ejemplo n.º 2
0
        public async Task <OrderDataModel> GetOrderDetails(int id)
        {
            var order = await DbContext.Orders
                        .Include(o => o.OrderSession)
                        .ThenInclude(os => os.Table)
                        .Include(o => o.OrderSession.Customer)
                        .Include(o => o.Waiter)
                        .Include(o => o.Items)
                        .ThenInclude(oi => oi.MenuItem)
                        .ThenInclude(mi => mi.Category)
                        .Where(o => o.Id == id).SingleOrDefaultAsync();

            if (order == null)
            {
                throw new RestaurantNotFoundException("Nem létező rendelés!");
            }

            await StatusService.CheckRightsForStatus(order.OrderSession.Status, order.Status);

            List <OrderItemListModel> items = new List <OrderItemListModel>();

            order.Items.ForEach(oi =>
            {
                items.Add(new OrderItemListModel()
                {
                    OrderItemId          = oi.Id,
                    MenuItemId           = oi.MenuItemId,
                    Name                 = oi.MenuItem.Name,
                    Quantity             = oi.Quantity,
                    Price                = oi.MenuItem.Price,
                    Comment              = oi.Comment,
                    MenuItemCategoryId   = oi.MenuItem.CategoryId,
                    MenuItemCategoryName = oi.MenuItem.Category.Name
                });
            });

            return(new OrderDataModel()
            {
                Id = order.Id,
                OrderSessionId = order.OrderSessionId,
                WaiterId = order.WaiterUserId,
                WaiterName = order.Waiter.Name,
                TableId = order.OrderSession.TableId,
                TableCode = order.OrderSession.Table?.Code,
                CustomerId = order.OrderSession.CustomerId,
                CustomerName = order.OrderSession.Customer?.Name,
                CustomerPhoneNumber = order.OrderSession.Customer?.PhoneNumber,
                CustomerAddress = order.OrderSession.Customer?.Address,
                Status = Enum.GetName(typeof(OrderStatus), order.Status),
                OpenedAt = order.OpenedAt,
                ClosedAt = order.ClosedAt,
                Price = order.CalculatePrice(),
                Items = items
            });
        }
        public async Task <OrderSessionDataModel> GetOrderSessionDetails(int id)
        {
            var orderSession = await DbContext.OrderSessions
                               .Include(os => os.Customer)
                               .Include(os => os.Voucher)
                               .Include(os => os.Table)
                               .Include(os => os.Orders)
                               .ThenInclude(o => o.Items)
                               .ThenInclude(oi => oi.MenuItem)
                               .Where(os => os.Id == id).SingleOrDefaultAsync();

            if (orderSession == null)
            {
                throw new RestaurantNotFoundException("Nem létező rendelési folyamat!");
            }

            await StatusService.CheckRightsForStatus(orderSession.Status);

            var orders = new List <OrderListModel>();

            orderSession.Orders.ForEach(order =>
            {
                orders.Add(new OrderListModel()
                {
                    Id       = order.Id,
                    WaiterId = order.WaiterUserId,
                    Status   = Enum.GetName(typeof(OrderStatus), order.Status),
                    OpenedAt = order.OpenedAt,
                    ClosedAt = order.ClosedAt,
                    Price    = order.CalculatePrice()
                });
            });

            return(new OrderSessionDataModel()
            {
                Id = orderSession.Id,
                TableId = orderSession.TableId,
                TableCode = orderSession.Table?.Code,
                CustomerId = orderSession.CustomerId,
                CustomerName = orderSession.Customer?.Name,
                CustomerPhoneNumber = orderSession.Customer?.PhoneNumber,
                CustomerAddress = orderSession.Customer?.Address,
                VoucherId = orderSession.VoucherId,
                VoucherCode = orderSession.Voucher?.Code,
                VoucherDiscountPercentage = orderSession.Voucher?.DiscountPercentage,
                VoucherDiscountAmount = orderSession.Voucher?.DiscountAmount,
                InvoiceId = orderSession.InvoiceId,
                Status = Enum.GetName(typeof(OrderSessionStatus), orderSession.Status),
                OpenedAt = orderSession.OpenedAt,
                ClosedAt = orderSession.ClosedAt,
                FullPrice = CalculatePrice(orderSession),
                Orders = orders
            });
        }
        public async Task <OrderSessionPayResultModel> PayOrders(int id, OrderSessionPayModel model)
        {
            if (!Enum.IsDefined(typeof(PaymentMethod), model.PaymentMethod))
            {
                throw new RestaurantNotFoundException("Nem létező fizetési mód!");
            }

            var orderSession = await DbContext.OrderSessions.Include(os => os.Orders)
                               .ThenInclude(o => o.Items)
                               .ThenInclude(oi => oi.MenuItem)
                               .Where(os => os.Id == id && (os.Status == OrderSessionStatus.Active || os.Status == OrderSessionStatus.Delivering))
                               .SingleOrDefaultAsync();

            if (orderSession == null)
            {
                throw new RestaurantNotFoundException("A rendelési folyamat nem létezik vagy a fizetése nem lehetséges!");
            }

            await StatusService.CheckRightsForStatus(orderSession.Status);

            var summary = await GetPaymentSummary(orderSession, model);

            //Generate invoice
            var invoiceModel = new InvoiceCreationModel()
            {
                FullPrice             = summary.FullPrice,
                FinalPrice            = summary.FinalPrice,
                VoucherCode           = model.VoucherCode,
                VoucherDiscountAmount = summary.VoucherTotalDiscountAmount,
                RedeemedLoyaltyPoints = summary.UsedLoyaltyPoints ?? 0,
                CustomerName          = model.CustomerName,
                CustomerTaxNumber     = model.CustomerTaxNumber,
                CustomerAddress       = model.CustomerAddress,
                CustomerPhoneNumber   = model.CustomerPhoneNumber,
                CustomerEmail         = model.CustomerEmail,
                PaymentMethod         = model.PaymentMethod,
                OrderSession          = orderSession
            };

            var invoiceId = await InvoiceService.CreateInvoice(invoiceModel);

            orderSession.InvoiceId = invoiceId;

            //Close order
            orderSession.Status   = OrderSessionStatus.Paid;
            orderSession.ClosedAt = DateTime.Now;

            await DbContext.SaveChangesAsync();

            return(new OrderSessionPayResultModel()
            {
                InvoiceId = invoiceId
            });                                                                              //Invoice id
        }
        public async Task <OrderSessionPaySummaryModel> GetPaymentSummary(int orderSessionId, OrderSessionPaySummaryRequestModel model)
        {
            var orderSession = await DbContext.OrderSessions.Include(os => os.Orders)
                               .ThenInclude(o => o.Items)
                               .ThenInclude(oi => oi.MenuItem)
                               .Where(os => os.Id == orderSessionId && (os.Status == OrderSessionStatus.Active || os.Status == OrderSessionStatus.Delivering))
                               .SingleOrDefaultAsync();

            if (orderSession == null)
            {
                throw new RestaurantNotFoundException("A rendelési folyamat nem létezik vagy a fizetése nem lehetséges!");
            }

            await StatusService.CheckRightsForStatus(orderSession.Status);

            return(await GetPaymentSummary(orderSession, model));
        }
Ejemplo n.º 6
0
        public async Task RemoveOrderItem(int orderId, int itemId)
        {
            var order = await DbContext.Orders
                        .Include(o => o.OrderSession)
                        .Include(o => o.Items)
                        .Where(o => o.Id == orderId && o.Status == OrderStatus.Ordering && o.OrderSession.Status == OrderSessionStatus.Active)
                        .SingleOrDefaultAsync();

            if (order == null)
            {
                throw new RestaurantNotFoundException("A rendelés nem létezik vagy nem lehetséges a módosítása!");
            }

            await StatusService.CheckRightsForStatus(order.OrderSession.Status, order.Status);

            DbContext.OrderItems.Remove(order.Items.Find(oi => oi.Id == itemId));

            await DbContext.SaveChangesAsync();
        }
Ejemplo n.º 7
0
        public async Task <AddResult> AddOrder(OrderAddModel model)
        {
            if (model.TableId == null && model.CustomerId == null)
            {
                throw new RestaurantBadRequestException("Asztal/kiszállítási adatok nélküli rendelés nem vehető fel!");
            }

            var waiter = await DbContext.Users.FindAsync(model.WaiterId);

            if (waiter == null)
            {
                throw new RestaurantNotFoundException("A megadott pincér nem létezik!");
            }

            await StatusService.CheckRightsForOrderAddDelete();

            OrderSession orderSession = null;

            if (model.TableId != null)
            {
                orderSession = await DbContext.OrderSessions.Where(os => os.TableId == model.TableId && os.Status == OrderSessionStatus.Active).SingleOrDefaultAsync();
            }

            if (orderSession == null)
            {
                orderSession = await OrderSessionService.CreateNewSession(model);
            }

            var order = DbContext.Orders.Add(new Order()
            {
                WaiterUserId   = model.WaiterId,
                Status         = OrderStatus.Ordering,
                OrderSessionId = orderSession.Id,
                OpenedAt       = DateTime.Now
            });

            await DbContext.SaveChangesAsync();

            return(new AddResult(order.Entity.Id));
        }
Ejemplo n.º 8
0
        public async Task <AddResult> AddOrderItem(int orderId, OrderItemAddModel model)
        {
            if (model.Quantity < 1)
            {
                throw new RestaurantBadRequestException("A mennyiségnek pozitív számnak kell lennie!");
            }

            var menuItem = await DbContext.MenuItems.FindAsync(model.MenuItemId);

            if (menuItem == null)
            {
                throw new RestaurantNotFoundException("A megadott étel/ital nem létezik!");
            }

            var order = await DbContext.Orders.Include(o => o.OrderSession)
                        .Where(o => o.Id == orderId && o.Status == OrderStatus.Ordering && o.OrderSession.Status == OrderSessionStatus.Active)
                        .SingleOrDefaultAsync();

            if (order == null)
            {
                throw new RestaurantNotFoundException("A rendelés nem létezik vagy nem lehetséges új tételek hozzáadása!");
            }

            await StatusService.CheckRightsForStatus(order.OrderSession.Status, order.Status);

            var orderItem = DbContext.OrderItems.Add(new OrderItem()
            {
                OrderId    = orderId,
                MenuItemId = model.MenuItemId,
                Quantity   = model.Quantity,
                Comment    = model.Comment
            });

            await DbContext.SaveChangesAsync();

            return(new AddResult(orderItem.Entity.Id));
        }