public IHttpActionResult Detail(Int32 ID)
        {
            CateringViewModel             viewmodel = new CateringViewModel();
            CateringProductDataController dataCtrl  = new CateringProductDataController();

            try
            {
                viewmodel.Data.FromModel(dataCtrl.GetItem(ID));
            }
            catch (Exception ex)
            {
                return(Error(viewmodel, ex));
            }

            return(Ok(viewmodel));
        }
        public IHttpActionResult Backend_Product_Detail_Update(Int32 id, BackendProductViewModelItem request)
        {
            BackendProductViewModel       viewmodel = new BackendProductViewModel();
            CateringProductDataController dataCtrl  = new CateringProductDataController();
            CateringProductAttributeRelationDataController relDataCtrl = new CateringProductAttributeRelationDataController();

            try
            {
                var result = dataCtrl.Update(request.ToModel());
                relDataCtrl.UpdateProduct(result, request.Attributes);
            }
            catch (Exception ex)
            {
                return(Error(viewmodel, ex));
            }

            return(Ok(viewmodel, "Eintrag wurde gespeichert."));
        }
        public IHttpActionResult Backend_Product_Detail_Insert(BackendProductViewModelItem request)
        {
            BaseViewModel viewmodel = new BaseViewModel();
            CateringProductDataController dataCtrl = new CateringProductDataController();
            CateringProductAttributeRelationDataController relDataCtrl = new CateringProductAttributeRelationDataController();

            try
            {
                var result = dataCtrl.Insert(request.ToModel());
                relDataCtrl.UpdateProduct(result, request.Attributes);
            }
            catch (Exception ex)
            {
                return(Error(viewmodel, ex));
            }

            return(Ok(viewmodel, "Bestellung wurde aufgenommen."));
        }
        public IHttpActionResult Backend_Product_Get()
        {
            BackendProductListViewModel   viewmodel = new BackendProductListViewModel();
            CateringProductDataController dataCtrl  = new CateringProductDataController();
            BackendProductListArgs        args      = new BackendProductListArgs();

            try
            {
                Int32 TotalItemsCount = 0;
                viewmodel.FromModel(dataCtrl.FilterList(args, out TotalItemsCount));
                viewmodel.Pagination.TotalItemsCount = TotalItemsCount;
            }
            catch (Exception ex)
            {
                return(Error(viewmodel, ex));
            }

            return(Ok(viewmodel));
        }
        public IHttpActionResult Get()
        {
            CateringListViewModel         viewmodel     = new CateringListViewModel();
            CateringProductDataController dataCtrl      = new CateringProductDataController();
            SeatDataController            seatDataCtrl  = new SeatDataController();
            EventDataController           eventDataCtrl = new EventDataController();

            try
            {
                var e = eventDataCtrl.GetItems().FirstOrDefault(x => x.Start <= DateTime.Now && x.End >= DateTime.Now);
                if (e == null)
                {
                    return(Warning(viewmodel, "Keine passende Veranstaltung gefunden."));
                }
                else if (!e.IsActiveCatering)
                {
                    return(Warning(viewmodel, "Das Catering ist derzeit deaktiviert."));
                }

                foreach (var model in dataCtrl.GetItems().Where(x => x.IsActive))
                {
                    ProductViewModelItem item = new ProductViewModelItem();

                    item.FromModel(model);
                    viewmodel.Data.Add(item);
                }

                int eventID = e.ID;
                foreach (var model in seatDataCtrl.GetCurrentUserSeats(eventID))
                {
                    CateringSeat item = new CateringSeat();

                    item.FromModel(model);
                    viewmodel.Seats.Add(item);
                }
            }
            catch (Exception ex)
            {
                return(Error(viewmodel, ex));
            }

            return(Ok(viewmodel));
        }
        public IHttpActionResult Backend_FilterList(BackendCateringListArgs args)
        {
            BackendCateringListViewModel  viewmodel        = new BackendCateringListViewModel();
            EventDataController           eventDataCtrl    = new EventDataController();
            CateringOrderDataController   orderDataCtrl    = new CateringOrderDataController();
            CateringProductDataController cateringDataCtrl = new CateringProductDataController();
            UserDataController            userDataCtrl     = new UserDataController();

            try
            {
                var events = eventDataCtrl.GetItems().OrderByDescending(x => x.ID).ToList();
                viewmodel.Filter.EventOptions = events.ConvertAll(x =>
                {
                    return(new BackendCateringFilter.CateringFilterEvent()
                    {
                        ID = x.ID,
                        Name = $"{x.EventType.Name} Vol.{x.Volume}"
                    });
                });

                var products = cateringDataCtrl.GetItems().ToList();
                viewmodel.ProductOptions = products.ConvertAll(x =>
                {
                    return(new BackendCateringProductItem().FromModel(x));
                });

                viewmodel.Filter.Name           = args.Filter.Name;
                viewmodel.Filter.SeatNumber     = args.Filter.SeatNumber;
                viewmodel.Filter.EventSelected  = args.Filter.EventSelected;
                viewmodel.Filter.StatusSelected = args.Filter.StatusSelected;
                viewmodel.Pagination            = args.Pagination;

                Int32 TotalItemsCount = 0;
                viewmodel.FromModel(orderDataCtrl.FilterList(args, out TotalItemsCount));
                viewmodel.Pagination.TotalItemsCount = TotalItemsCount;
            }
            catch (Exception ex)
            {
                return(Error(viewmodel, ex));
            }

            return(Ok(viewmodel));
        }
        public IHttpActionResult Backend_Product_Detail(Int32 id)
        {
            BackendProductViewModel                viewmodel    = new BackendProductViewModel();
            CateringProductDataController          dataCtrl     = new CateringProductDataController();
            CateringProductAttributeDataController attrDataCtrl = new CateringProductAttributeDataController();

            try
            {
                foreach (var option in attrDataCtrl.GetItems().OrderBy(x => x.Name))
                {
                    viewmodel.AttributeOptions.Add(new BackendProductAttributeViewModelItem().FromModel(option));
                }

                viewmodel.Data.FromModel(dataCtrl.GetItem(id));
            }
            catch (Exception ex)
            {
                return(Error(viewmodel, ex));
            }

            return(Ok(viewmodel));
        }