Example #1
0
        private async void DuplicateEventCommandExecuted()
        {

            RaisePropertyChanged("DisableParentWindow");
            var addDuplicateView = new DuplicateView();
            addDuplicateView.ShowDialog();
            RaisePropertyChanged("EnableParentWindow");

            if (addDuplicateView.DialogResult != null && addDuplicateView.DialogResult == true)
            {
                var addDuplicateViewModel = addDuplicateView.DataContext as DuplicateViewModel;
                if (addDuplicateViewModel != null)
                {
                    IsBusy = true;

                    var fromEvent = SelectedEvent;

                    await LoadLightEventDetails(fromEvent);

                    // General event info
                    var toEvent = new Event()
                    {
                        ID = Guid.NewGuid(),
                        Name = addDuplicateViewModel.EventName,
                        Date = Convert.ToDateTime(addDuplicateViewModel.EventDate),
                        Places = fromEvent.Places,
                        ContactID = fromEvent.Event.ContactID,
                        EventTypeID = fromEvent.Event.EventTypeID,
                        EventType = fromEvent.Event.EventType,
                        EventStatusID = fromEvent.Event.EventStatusID,
                        EventStatus = fromEvent.Event.EventStatus,
                        CreationDate = DateTime.Now,
                        MembersOnly = fromEvent.Event.MembersOnly,
                        ShowInForwardBook = fromEvent.Event.ShowInForwardBook,
                        ShowOnCalendar = fromEvent.Event.ShowOnCalendar,
                        UsedAsTemplate = fromEvent.Event.UsedAsTemplate,
                        InvoiceAddress = fromEvent.Event.InvoiceAddress,
                        StartTime = fromEvent.StartTime,
                        EndTime = fromEvent.EndTime
                    };

                    var toEventModel = new EventModel(toEvent);
                    // Notes
                    if (!fromEvent.EventNotes.Any())
                    {
                        var notes = await _eventsDataUnit.EventNotesRepository.GetAllAsync(x => x.EventID == fromEvent.Event.ID);
                        fromEvent.EventNotes = new ObservableCollection<EventNoteModel>(notes.Select(x => new EventNoteModel(x)));
                    }

                    if (fromEvent.EventNotes.Any())
                    {
                        fromEvent.EventNotes.ForEach(x =>
                        {
                            var note = new EventNote()
                            {
                                ID = Guid.NewGuid(),
                                EventID = toEventModel.Event.ID,
                                EventNoteTypeID = x.EventNote.EventNoteTypeID,
                                UserID = x.EventNote.UserID,
                                Date = DateTime.Now,
                                Note = x.Note
                            };

                            _eventsDataUnit.EventNotesRepository.Add(note);
                            toEventModel.EventNotes.Add(new EventNoteModel(note));
                        });
                    }

                    // Altarnative Contacts
                    if (!fromEvent.EventContacts.Any())
                    {
                        var contacts = await _eventsDataUnit.EventContactsRepository.GetAllAsync(x => x.EventID == fromEvent.Event.ID);
                        fromEvent.EventContacts = new ObservableCollection<EventContact>(contacts);
                    }

                    if (fromEvent.EventContacts.Any())
                    {
                        fromEvent.EventContacts.ForEach(x =>
                        {
                            var contact = new EventContact()
                            {
                                ID = Guid.NewGuid(),
                                EventID = toEventModel.Event.ID,
                                ContactID = x.ContactID
                            };

                            _eventsDataUnit.EventContactsRepository.Add(contact);
                            toEventModel.EventContacts.Add(contact);
                        });
                    }

                    // Event Caterings
                    if (fromEvent.EventCaterings.Any())
                    {
                        fromEvent.EventCaterings.ForEach(x =>
                        {
                            var catering = new EventCatering()
                            {
                                ID = Guid.NewGuid(),
                                EventID = toEventModel.Event.ID,
                                Event = toEventModel.Event,
                                Time = x.EventCatering.Time,
                                RoomID = x.EventCatering.RoomID,
                                StartTime = x.EventCatering.StartTime,
                                EndTime = x.EventCatering.EndTime,
                                Notes = x.EventCatering.Notes,
                                ShowInInvoice = x.EventCatering.ShowInInvoice,
                                IncludeInForwardBook = x.EventCatering.IncludeInForwardBook,
                                IncludeInCorrespondence = x.EventCatering.IncludeInCorrespondence,
                                IsSpecial = x.EventCatering.IsSpecial
                            };

                            var products = fromEvent.EventBookedProducts.Where(y => y.EventBookedProduct.EventBookingItemID == x.EventCatering.ID).ToList();

                            if (products.Any())
                            {
                                products.ForEach(y =>
                                {
                                    var product = new EventBookedProduct()
                                    {
                                        ID = Guid.NewGuid(),
                                        EventID = toEventModel.Event.ID,
                                        ProductID = y.EventBookedProduct.ProductID,
                                        EventBookingItemID = catering.ID,
                                        Quantity = y.EventBookedProduct.Quantity,
                                        Price = y.EventBookedProduct.Price
                                    };

                                    var charge = new EventCharge()
                                    {
                                        ID = product.ID,
                                        EventID = toEventModel.Event.ID,
                                        ProductID = product.ProductID,
                                        Quantity = product.Quantity,
                                        Price = product.Price,
                                        ShowInInvoice = catering.ShowInInvoice
                                    };
                                    product.EventCharge = charge;

                                    _eventsDataUnit.EventBookedProductsRepository.Add(product);
                                    _eventsDataUnit.EventChargesRepository.Add(charge);
                                    toEventModel.EventBookedProducts.Add(new EventBookedProductModel(product));
                                    toEventModel.EventCharges.Add(new EventChargeModel(charge));
                                });
                            }
                            _eventsDataUnit.EventCateringsRepository.Add(catering);
                            toEventModel.EventCaterings.Add(new EventCateringModel(catering));
                        });
                    }

                    // Event Rooms
                    if (fromEvent.EventRooms.Any())
                    {
                        fromEvent.EventRooms.ForEach(x =>
                        {
                            var room = new EventRoom()
                            {
                                ID = Guid.NewGuid(),
                                EventID = toEventModel.Event.ID,
                                Event = toEventModel.Event,
                                RoomID = x.EventRoom.RoomID,
                                StartTime = x.EventRoom.StartTime,
                                EndTime = x.EventRoom.EndTime,
                                Notes = x.EventRoom.Notes,
                                ShowInInvoice = x.EventRoom.ShowInInvoice,
                                IncludeInForwardBook = x.EventRoom.IncludeInForwardBook,
                                IncludeInCorrespondence = x.EventRoom.IncludeInCorrespondence,
                            };

                            var products = fromEvent.EventBookedProducts.Where(y => y.EventBookedProduct.EventBookingItemID == x.EventRoom.ID).ToList();

                            if (products.Any())
                            {
                                products.ForEach(y =>
                                {
                                    var product = new EventBookedProduct()
                                    {
                                        ID = Guid.NewGuid(),
                                        EventID = toEventModel.Event.ID,
                                        ProductID = y.EventBookedProduct.ProductID,
                                        EventBookingItemID = room.ID,
                                        Quantity = y.EventBookedProduct.Quantity,
                                        Price = y.EventBookedProduct.Price
                                    };

                                    var charge = new EventCharge()
                                    {
                                        ID = product.ID,
                                        EventID = toEventModel.Event.ID,
                                        ProductID = product.ProductID,
                                        Quantity = product.Quantity,
                                        Price = product.Price,
                                        ShowInInvoice = room.ShowInInvoice
                                    };
                                    product.EventCharge = charge;

                                    _eventsDataUnit.EventBookedProductsRepository.Add(product);
                                    _eventsDataUnit.EventChargesRepository.Add(charge);
                                    toEventModel.EventBookedProducts.Add(new EventBookedProductModel(product));
                                    toEventModel.EventCharges.Add(new EventChargeModel(charge));
                                });
                            }
                            _eventsDataUnit.EventRoomsRepository.Add(room);
                            toEventModel.EventRooms.Add(new EventRoomModel(room));
                        });
                    }

                    // Event Golfs
                    var fromEventGolfs = fromEvent.EventGolfs.Where(eventGolf => !eventGolf.EventGolf.IsLinked);
                    if (fromEventGolfs.Any())
                    {
                        fromEventGolfs.ForEach(x =>
                        {
                            var golf = new EventGolf()
                            {
                                ID = Guid.NewGuid(),
                                EventID = toEventModel.Event.ID,
                                Event = toEventModel.Event,
                                Time = x.EventGolf.Time,
                                TeeID = x.EventGolf.TeeID,
                                HoleID = x.EventGolf.HoleID,
                                Slots = x.EventGolf.Slots,
                                Notes = x.EventGolf.Notes,
                                ShowInInvoice = x.EventGolf.ShowInInvoice,
                                IncludeInForwardBook = x.EventGolf.IncludeInForwardBook,
                                IncludeInCorrespondence = x.EventGolf.IncludeInCorrespondence,
                                EventGolf1 = x.EventGolf.EventGolf1 != null ? new EventGolf()
                            {
                                ID = Guid.NewGuid(),
                                EventID = toEventModel.Event.ID,
                                Event = toEventModel.Event,
                                Time = x.EventGolf.EventGolf1.Time,
                                TeeID = x.EventGolf.EventGolf1.TeeID,
                                HoleID = x.EventGolf.EventGolf1.HoleID,
                                Slots = x.EventGolf.EventGolf1.Slots,
                                Notes = x.EventGolf.EventGolf1.Notes,
                                ShowInInvoice = x.EventGolf.EventGolf1.ShowInInvoice,
                                IncludeInForwardBook = x.EventGolf.EventGolf1.IncludeInForwardBook,
                                IncludeInCorrespondence = x.EventGolf.EventGolf1.IncludeInCorrespondence,
                                IsLinked = true
                            } : null
                            };

                            var products = fromEvent.EventBookedProducts.Where(y => y.EventBookedProduct.EventBookingItemID == x.EventGolf.ID).ToList();

                            if (products.Any())
                            {
                                products.ForEach(y =>
                                {
                                    var product = new EventBookedProduct()
                                    {
                                        ID = Guid.NewGuid(),
                                        EventID = toEventModel.Event.ID,
                                        ProductID = y.EventBookedProduct.ProductID,
                                        EventBookingItemID = golf.ID,
                                        Quantity = y.EventBookedProduct.Quantity,
                                        Price = y.EventBookedProduct.Price
                                    };

                                    var charge = new EventCharge()
                                    {
                                        ID = product.ID,
                                        EventID = toEventModel.Event.ID,
                                        ProductID = product.ProductID,
                                        Quantity = product.Quantity,
                                        Price = product.Price,
                                        ShowInInvoice = golf.ShowInInvoice
                                    };
                                    product.EventCharge = charge;

                                    _eventsDataUnit.EventBookedProductsRepository.Add(product);
                                    _eventsDataUnit.EventChargesRepository.Add(charge);
                                    toEventModel.EventBookedProducts.Add(new EventBookedProductModel(product));
                                    toEventModel.EventCharges.Add(new EventChargeModel(charge));
                                });
                            }

                            _eventsDataUnit.EventGolfsRepository.Add(golf);
                            toEventModel.EventGolfs.Add(new EventGolfModel(golf));
                        });
                    }

                    // Event Invoices
                    if (fromEvent.EventInvoices.Any())
                    {
                        fromEvent.EventInvoices.ForEach(x =>
                        {
                            var invoice = new EventInvoice()
                            {
                                ID = Guid.NewGuid(),
                                EventID = toEventModel.Event.ID,
                                Event = toEventModel.Event,
                                Notes = x.EventInvoice.Notes,
                                ShowInInvoice = x.EventInvoice.ShowInInvoice,
                                IncludeInForwardBook = x.EventInvoice.IncludeInForwardBook,
                                IncludeInCorrespondence = x.EventInvoice.IncludeInCorrespondence,
                            };

                            var products = fromEvent.EventBookedProducts.Where(y => y.EventBookedProduct.EventBookingItemID == x.EventInvoice.ID).ToList();

                            if (products.Any())
                            {
                                products.ForEach(y =>
                                {
                                    var product = new EventBookedProduct()
                                    {
                                        ID = Guid.NewGuid(),
                                        EventID = toEventModel.Event.ID,
                                        ProductID = y.EventBookedProduct.ProductID,
                                        EventBookingItemID = invoice.ID,
                                        Quantity = y.EventBookedProduct.Quantity,
                                        Price = y.EventBookedProduct.Price
                                    };

                                    var charge = new EventCharge()
                                    {
                                        ID = product.ID,
                                        EventID = toEventModel.Event.ID,
                                        ProductID = product.ProductID,
                                        Quantity = product.Quantity,
                                        Price = product.Price,
                                        ShowInInvoice = invoice.ShowInInvoice
                                    };
                                    product.EventCharge = charge;

                                    _eventsDataUnit.EventBookedProductsRepository.Add(product);
                                    _eventsDataUnit.EventChargesRepository.Add(charge);
                                    toEventModel.EventBookedProducts.Add(new EventBookedProductModel(product));
                                    toEventModel.EventCharges.Add(new EventChargeModel(charge));
                                });
                            }
                            _eventsDataUnit.EventInvoicesRepository.Add(invoice);
                            toEventModel.EventInvoices.Add(new EventInvoiceModel(invoice));
                        });
                    }

                    _eventsDataUnit.EventsRepository.DetectChanges();
                    toEventModel.RefreshItems();
                    RaisePropertyChanged("DisableParentWindow");
                    var bookingView = new BookingView(BookingViews.Event, toEventModel, true);
                    bookingView.ShowDialog();
                    RaisePropertyChanged("EnableParentWindow");

                    // Refresh grid if event was added
                    if (bookingView.DialogResult != null && bookingView.DialogResult == true)
                    {
                        var eventBookingView = bookingView.ViewModel.Content as EventBookingView;
                        _allEvents.Add(eventBookingView.ViewModel.Event);
                        _allEvents = new List<EventModel>(_allEvents.OrderBy(x => x.Date));
                        Events = new ObservableCollection<EventModel>(_allEvents);
                        UpdateEventsDataRange();
                        RefreshAppointments();
                    }
                    IsBusy = false;
                }
            }
        }
        private void OpenEventCommandExecute()
        {
            RaisePropertyChanged("DisableParentWindow");

            var window = new BookingView(BookingViews.Event, new EventModel(EventReminder.EventReminder.Event));
            window.ShowDialog();

            RaisePropertyChanged("EnableParentWindow");
        }
Example #3
0
        private void EditEventCommandExecuted(EventModel item)
        {

            RaisePropertyChanged("DisableParentWindow");

            var bookingView = new BookingView(BookingViews.Event, item);

            bookingView.ShowDialog();

            RaisePropertyChanged("EnableParentWindow");

            if (bookingView.DialogResult != null && bookingView.DialogResult == true)
            {
                item.Refresh();
                item.RefreshItems();
                RefreshAppointments();
            }
            else
            {
                item.Refresh();
            }

            UpdateEventsDataRange();

        }
Example #4
0
        private void AddEventCommandExecuted()
        {
            RaisePropertyChanged("DisableParentWindow");

            var bookingView = new BookingView(BookingViews.Event);
            bookingView.ShowDialog();

            RaisePropertyChanged("EnableParentWindow");

            // Refresh grid if event was added
            if (bookingView.DialogResult != null && bookingView.DialogResult == true)
            {
                var eventBookingView = bookingView.ViewModel.Content as EventBookingView;

                _allEvents.Add(eventBookingView.ViewModel.Event);
                _allEvents = new List<EventModel>(_allEvents.OrderBy(x => x.Date));
                Events = new ObservableCollection<EventModel>(_allEvents);
                UpdateEventsDataRange();
                RefreshAppointments();
            }
        }
Example #5
0
        private async void EditEventCommandExecuted(EventModel item)
        {
            // We should get event from EventDataUnit to use EventBookingView
            var events = await _eventsDataUnit.EventsRepository.GetLightEventsAsync(x => x.ID == item.Event.ID);
            var model = new EventModel(events.FirstOrDefault());

            RaisePropertyChanged("DisableParentWindow");

            var view = new BookingView(BookingViews.Event, model);
            view.ShowDialog();

            RaisePropertyChanged("EnableParentWindow");

            if (view.DialogResult != null && view.DialogResult.Value)
            {
                _contactsDataUnit.EventsRepository.Refresh();

                events = await _contactsDataUnit.EventsRepository.GetLightEventsAsync(x => x.ID == model.Event.ID);
                Event = new EventModel(events.FirstOrDefault());
                await LoadLightEventDetails();
                model.RefreshItems();
            }
        }
Example #6
0
        private async void BookCommandExecute()
        {
            bool? dialogResult = null;
            string confirmText = Properties.Resources.MESSAGE_ASK_BEFORE_BOOKING_ENQUIRY;

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

            if (dialogResult != true) return;

            Enquiry.EnquiryStatus = EnquiryStatuses.FirstOrDefault(x => x.Status == "Booked");
            EnquiryStatus = Enquiry.EnquiryStatus;

            var newEvent = new Event()
            {
                ID = Guid.NewGuid(),
                Name = Enquiry.Name,
                Date = (DateTime)Enquiry.Date,
                Places = (int)Enquiry.Places,
                CreationDate = DateTime.Now,
                ShowOnCalendar = true,
                IsDeleted = false,
                LastEditDate = DateTime.Now,
                EventTypeID = Enquiry.EventType.ID,
                EnquiryID = Enquiry.Enquiry.ID,
                EventStatusID = _eventStatuses.FirstOrDefault(x => x.Name == "Provisional").ID
            };

            if (_enquiry.PrimaryContact != null)
                newEvent.ContactID = _enquiry.PrimaryContact.Contact.ID;

            _crmDataUnit.EventsRepository.Add(newEvent);

            var update = new EventUpdate()
            {
                ID = Guid.NewGuid(),
                EventID = newEvent.ID,
                Date = DateTime.Now,
                UserID = AccessService.Current.User.ID,
                Message = string.Format("Event {0} was created", newEvent.Name),
                OldValue = null,
                NewValue = newEvent.Name,
                ItemId = newEvent.ID,
                ItemType = "Event",
                Field = "Event",
                Action = UpdateAction.Added
            };

            _crmDataUnit.EventUpdatesRepository.Add(update);
            _crmDataUnit.SaveChanges();

            // Warning: Here we use EventDataUnit!

            var events = await _eventDataUnit.EventsRepository.GetLightEventsAsync(x => x.ID == newEvent.ID);
            var @event = events.FirstOrDefault();

            var item = new EventModel(@event);

            // Open Add Event window in UI thread
            Application.Current.Dispatcher.BeginInvoke(new Action(() =>
            {
                var bookingView = new BookingView(BookingViews.Event, item);
                bookingView.ShowDialog();

                if (bookingView.DialogResult != null && bookingView.DialogResult == true)
                {
                    string campaingText = Enquiry.Campaign == null ? "" : ", via Campaign " + Enquiry.Campaign.Name;

                    var note = new EventNoteModel(new EventNote()
                    {
                        ID = Guid.NewGuid(),
                        EventID = newEvent.ID,
                        Date = DateTime.Now,
                        EventNoteType = _eventNoteTypes.FirstOrDefault(x => x.Type == "Internal"),
                        UserID = AccessService.Current.User.ID,
                        Note = String.Format("From Enquiry, made on {0}, Taken by {1} Assigned to {2} enquiry via {3} {4}. {5} Notes, {6} Updates, {7} Activities & {8} Follow-Ups.",
                        DateTime.Now,
                        Enquiry.LoggedUser.FirstName,
                        Enquiry.AssignedToUser.FirstName,
                        Enquiry.ReceivedMethod.ReceiveMethod,
                        campaingText,
                        Enquiry.EnquiryNotes.Count,
                        Enquiry.EnquiryUpdates.Count,
                        Enquiry.Activities.Count,
                        Enquiry.FollowUps.Count)
                    });

                    _crmDataUnit.EventNotesRepository.Add(note.EventNote);
                    _crmDataUnit.SaveChanges();
                }
            }));

            BookCommand.RaiseCanExecuteChanged();
        }
Example #7
0
        private void OpenEventCommandExecuted()
        {
            RaisePropertyChanged("DisableParentWindow");

            var window = new BookingView(BookingViews.Event, new EventModel(EventReminder.EventReminder.Event));
            window.ShowDialog();

            if (window.DialogResult != null && window.DialogResult.Value)
            {
                var IsCurrentEventReminderDeleted = true;
                var eventBookingView = window.ViewModel.Content as EventBookingView;
                var eventBookingViewModel = eventBookingView.ViewModel as EventBookingViewModel;
                if (eventBookingViewModel.Event.EventReminders.Where(eventReminder => eventReminder.EventReminder.ID == _eventReminder.EventReminder.ID).Count() > 0)
                    IsCurrentEventReminderDeleted = false;

                if (IsCurrentEventReminderDeleted)
                {
                    Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                    {
                        //var currentPopUp = Application.Current.MainWindow;
                        //var viewModel = currentPopUp.DataContext as MainWindowModel;
                        //var workspaceView = viewModel.WindowContent as WorkspaceView;
                        //var tile = workspaceView.RootTileView.MaximizedItem as Tile;
                        //if (tile.Name == "CRM")
                        //{
                        //    var crmview = tile.Content as CRMView;
                        //    var crmvm = crmview.DataContext as CRMViewModel;

                        //    if (isToDo)
                        //        crmvm.ReloadFollowUps();
                        //    else
                        //    {
                        //        crmvm.ReloadFollowUpsAndEnquiries();
                        //    }
                        //}
                    }));
                    RaisePropertyChanged("CloseParentWindow");
                }
                else
                {
                    RaisePropertyChanged("EnableParentWindow");
                }
            }
            else
            {
                RaisePropertyChanged("EnableParentWindow");
            }
        }