public ActionResult Index()
 {
     return(View(new EventViewModel()
     {
         Events = EventItemModel.GetItems()
     }));
 }
 private static void Map(EventItemModel eventItemModel, EventItem eventItem)
 {
     eventItem.EventId     = eventItemModel.EventId;
     eventItem.EventName   = eventItemModel.EventName;
     eventItem.Description = eventItemModel.Description;
     eventItem.StartDate   = eventItemModel.StartDate;
     eventItem.Duration    = eventItemModel.Duration;
 }
Example #3
0
        private void EditItemCommandExecuted(EventItemModel item)
        {
            RaisePropertyChanged("DisableParentWindow");

            if (item.Instance.GetType() == typeof(EventCateringModel))
            {
                var model = (EventCateringModel)item.Instance;

                var window = new AddCateringItemView(Event, model);
                window.ShowDialog();


                if (window.DialogResult != null && window.DialogResult.Value)
                {
                    _event.Event.LastEditDate = DateTime.Now;
                    _event.RefreshItems();
                }
            }
            else if (item.Instance.GetType() == typeof(EventGolfModel))
            {
                var model = (EventGolfModel)item.Instance;

                var window = new AddEventGolfItemView(Event, model);
                window.ShowDialog();

                if (window.DialogResult != null && window.DialogResult.Value)
                {
                    _event.Event.LastEditDate = DateTime.Now;
                    _event.RefreshItems();
                }
            }
            else if (item.Instance.GetType() == typeof(EventRoomModel))
            {
                var model = (EventRoomModel)item.Instance;

                var window = new AddRoomItemView(Event, model);
                window.ShowDialog();

                if (window.DialogResult != null && window.DialogResult.Value)
                {
                    _event.Event.LastEditDate = DateTime.Now;
                    _event.RefreshItems();
                }
            }
            else if (item.Instance.GetType() == typeof(EventInvoiceModel))
            {
                var model  = (EventInvoiceModel)item.Instance;
                var window = new AddEventInvoiceItemView(Event, model);
                window.ShowDialog();

                if (window.DialogResult != null && window.DialogResult.Value)
                {
                    _event.Event.LastEditDate = DateTime.Now;
                    _event.RefreshItems();
                }
            }
            RaisePropertyChanged("EnableParentWindow");
        }
Example #4
0
        private void EditItemCommandExecuted(EventItemModel item)
        {
            RaisePropertyChanged("DisableParentWindow");

            if (item.Instance.GetType() == typeof(EventCateringModel))
            {
                var model = (EventCateringModel)item.Instance;

                var window = new AddCateringItemView(Event, model, AlreadyBookedCaterings, AlreadyBookedRooms);
                window.ShowDialog();


                if (window.DialogResult != null && window.DialogResult.Value)
                {
                    AlreadyBookedCaterings.Remove(model);
                    EventItemsAlreadyBooked.Remove(item);
                    _event.Event.LastEditDate = DateTime.Now;
                    _event.RefreshItems();
                }
            }
            else if (item.Instance.GetType() == typeof(EventGolfModel))
            {
                var model = (EventGolfModel)item.Instance;

                var window = new AddEventGolfItemView(Event, model, AlreadyBookedGolfs);
                window.ShowDialog();

                if (window.DialogResult != null && window.DialogResult.Value)
                {
                    AlreadyBookedGolfs.Remove(model);
                    EventItemsAlreadyBooked.Remove(item);
                    _event.Event.LastEditDate = DateTime.Now;
                    _event.RefreshItems();
                }
            }
            else if (item.Instance.GetType() == typeof(EventRoomModel))
            {
                var model = (EventRoomModel)item.Instance;

                var window = new AddRoomItemView(Event, model, AlreadyBookedCaterings, AlreadyBookedRooms);
                window.ShowDialog();

                if (window.DialogResult != null && window.DialogResult.Value)
                {
                    AlreadyBookedRooms.Remove(model);
                    EventItemsAlreadyBooked.Remove(item);
                    _event.Event.LastEditDate = DateTime.Now;
                    _event.RefreshItems();
                }
            }

            RaisePropertyChanged("EnableParentWindow");
            if (EventItemsAlreadyBooked.Count == 0)
            {
                RaisePropertyChanged("CloseDialog");
            }
        }
        public ActionResult Index()
        {
            var viewModel = new HomeViewModel();

            (viewModel.PostPageCount, viewModel.Posts) = PostModel.GetPosts(viewModel.PostsPageIndex, viewModel.PostsRecsPerPage);
            viewModel.Events = EventItemModel.GetItems();

            return(View(viewModel));
        }
        public ActionResult IndexByPage(int id)
        {
            var viewModel = new HomeViewModel();

            viewModel.PostsPageIndex = id;
            (viewModel.PostPageCount, viewModel.Posts) = PostModel.GetPosts(id, viewModel.PostsRecsPerPage);
            viewModel.Events = EventItemModel.GetItems();

            return(View("Index", viewModel));
        }
        public async Task <ExecutionResult> CreateEvent([FromBody] EventItemModel model, CancellationToken cancellationToken)
        {
            if (!ModelState.IsValid)
            {
                return(ExecutionResult.From(ModelState.GetValidationResult()));
            }

            var eventItem = Map(model);
            await _myEventsService.CreateEvent(eventItem, cancellationToken);

            return(await GetEvents(cancellationToken));
        }
        private static EventItemModel Map(EventItem eventItem)
        {
            if (eventItem == null)
            {
                return(null);
            }

            var eventItemModel = new EventItemModel();

            Map(eventItem, eventItemModel);

            return(eventItemModel);
        }
        private static EventItem Map(EventItemModel eventItemModel)
        {
            if (eventItemModel == null)
            {
                return(null);
            }

            var eventItem = new EventItem();

            Map(eventItemModel, eventItem);

            return(eventItem);
        }
Example #10
0
        private void DeleteItemCommandExecuted(EventItemModel item)
        {
            bool?  dialogResult = null;
            string confirmText  = Properties.Resources.MESSAGE_ASK_BEFORE_DELETING_ITEM;

            RaisePropertyChanged("DisableParentWindow");

            RadWindow.Confirm(new DialogParameters()
            {
                Owner   = Application.Current.MainWindow,
                Content = confirmText,
                Closed  = (sender, args) => { dialogResult = args.DialogResult; }
            });

            RaisePropertyChanged("EnableParentWindow");

            if (dialogResult != true)
            {
                return;
            }

            if (item.Instance.GetType() == typeof(EventCateringModel))
            {
                var model = (EventCateringModel)item.Instance;

                // Remove booked products
                model.EventBookedProducts.ForEach(RemoveEventBookedProductAndCharges);
                _event.EventCaterings.Remove(model);
                _eventsDataUnit.EventCateringsRepository.Delete(model.EventCatering);
            }
            else if (item.Instance.GetType() == typeof(EventGolfModel))
            {
                var model = (EventGolfModel)item.Instance;

                // Remove booked products
                model.EventBookedProducts.ForEach(RemoveEventBookedProductAndCharges);
                if (model.EventGolf.LinkedEventGolfId != null)
                {
                    if (model.EventGolf.EventGolf1 == null)
                    {
                        _eventsDataUnit.EventGolfsRepository.DetachGolfEvent((Guid)model.EventGolf.LinkedEventGolfId);
                    }
                    else
                    {
                        _eventsDataUnit.EventGolfsRepository.Delete(model.EventGolf.EventGolf1);
                    }
                }
                _event.EventGolfs.Remove(model);

                _eventsDataUnit.EventGolfsRepository.Delete(model.EventGolf);
            }
            else if (item.Instance.GetType() == typeof(EventRoomModel))
            {
                var model = (EventRoomModel)item.Instance;

                // Remove booked products
                model.EventBookedProducts.ForEach(RemoveEventBookedProductAndCharges);

                _event.EventRooms.Remove(model);
                _eventsDataUnit.EventRoomsRepository.Delete(model.EventRoom);
            }
            else if (item.Instance.GetType() == typeof(EventInvoiceModel))
            {
                var model = (EventInvoiceModel)item.Instance;

                // Remove booked products
                model.EventBookedProducts.ForEach(RemoveEventBookedProductAndCharges);

                _event.EventInvoices.Remove(model);
                _eventsDataUnit.EventInvoicesRepository.Delete(model.EventInvoice);
            }

            _event.Event.LastEditDate = DateTime.Now;
            _event.RefreshItems();
        }