private void EditReminderCommandExecuted(EventReminderModel eventReminderModel)
{
RaisePropertyChanged("DisableParentWindow");
var eventReminderView = new AddEventReminderView(eventReminderModel);
eventReminderView.ShowDialog();
if (eventReminderView.DialogResult != null && eventReminderView.DialogResult == true)
{
_eventDataUnit.SaveChanges();
}
RaisePropertyChanged("EnableParentWindow");
}
private async void SaveCommandExecuted()
{
if (!_isEdit)
{
_eventsDataUnit.CalendarNotesRepository.Add(CalendarNote.CalendarNote);
}
await _eventsDataUnit.SaveChanges();
}
private void SnoozeCommandExecute()
{
RaisePropertyChanged("DisableParentWindow");
var eventID = EventReminder.EventReminder.EventID;
var snoozeWindow = new SnoozeView(EventReminder);
snoozeWindow.WindowStartupLocation = WindowStartupLocation.CenterOwner;
snoozeWindow.ShowDialog();
RaisePropertyChanged("EnableParentWindow");
if (snoozeWindow.DialogResult == null || snoozeWindow.DialogResult != true)
{
return;
}
var viewModel = snoozeWindow.DataContext as SnoozeViewModel;
switch (viewModel.SnoozeTime)
{
case "5 mins":
EventReminder.DateDue = DateTime.Now + TimeSpan.FromMinutes(5);
break;
case "10 mins":
EventReminder.DateDue = DateTime.Now + TimeSpan.FromMinutes(10);
break;
case "30 mins":
EventReminder.DateDue = DateTime.Now + TimeSpan.FromMinutes(30);
break;
case "1 Hour":
EventReminder.DateDue = DateTime.Now + TimeSpan.FromHours(1);
break;
case "2 Hours":
EventReminder.DateDue = DateTime.Now + TimeSpan.FromHours(2);
break;
case "1 Day":
EventReminder.DateDue = DateTime.Now + TimeSpan.FromDays(1);
break;
case "7 Days":
EventReminder.DateDue = DateTime.Now + TimeSpan.FromDays(7);
break;
}
_eventDataUnit.SaveChanges();
var window = Application.Current.MainWindow;
var mainViewModel = window.DataContext as MainWindowModel;
var workspaceView = mainViewModel.WindowContent as WorkspaceView;
var tile = workspaceView.RootTileView.MaximizedItem as Tile;
if (tile.Name == "Events")
{
var eventsView = tile.Content as EventsView;
if (eventsView != null)
{
var eventsViewModel = eventsView.DataContext as EventsViewModel;
eventsViewModel.RefreshReminders(EventReminder, eventID);
eventsView.RefreshReminder(EventReminder);
}
}
}
public async void LoadData()
{
IsBusy = true;
if (_isEditMode)
{
var desiredEvent = await _eventsDataUnit.EventsRepository.GetUpdatedEvent(_event.Event.ID);
// Check locking
if (desiredEvent.LockedUserID != null && desiredEvent.LockedUserID != AccessService.Current.User.ID)
{
// Okey, someone is editing event right now.
var user = (await _eventsDataUnit.UsersRepository.GetUsersAsync(x => x.ID == desiredEvent.LockedUserID)).FirstOrDefault();
IsLocked = true;
LockedText = string.Format("{0} is locked by {1} {2}. Please wait till user makes changes", _event.Name, user.FirstName, user.LastName);
return;
}
// Lock event
_event.Event.LockedUserID = AccessService.Current.User.ID;
await _eventsDataUnit.SaveChanges();
if (desiredEvent.LastEditDate != null && _event.LoadedTime < desiredEvent.LastEditDate)
{
Event.RefreshEventProp();
if (desiredEvent.Contact != null)
{
Event.PrimaryContact = new ContactModel(desiredEvent.Contact);
}
if (desiredEvent.EventType != null)
{
Event.EventType = desiredEvent.EventType;
}
if (desiredEvent.EventStatus != null)
{
Event.EventStatus = desiredEvent.EventStatus;
}
Event.PropertyChanged += OnEventPropertyChanged;
_forceRefreshData = true;
}
if (_forceRefreshData)
{
_eventsDataUnit.EventBookedProductsRepository.Refresh();
}
var products = await _eventsDataUnit.EventBookedProductsRepository.GetAllAsync(x => x.EventID == Event.Event.ID);
Event.EventBookedProducts = new List <EventBookedProductModel>(products.Select(x => new EventBookedProductModel(x)));
if (_forceRefreshData)
{
_eventsDataUnit.EventChargesRepository.Refresh();
}
var charges = await _eventsDataUnit.EventChargesRepository.GetAllAsync(x => x.EventID == Event.Event.ID);
Event.EventCharges = new ObservableCollection <EventChargeModel>(charges.Select(x => new EventChargeModel(x)));
if (_forceRefreshData)
{
_eventsDataUnit.EventCateringsRepository.Refresh();
}
var caterings = await _eventsDataUnit.EventCateringsRepository.GetAllAsync(x => x.EventID == Event.Event.ID);
Event.EventCaterings = new List <EventCateringModel>(caterings.Select(x => new EventCateringModel(x)));
if (_forceRefreshData)
{
_eventsDataUnit.EventRoomsRepository.Refresh();
}
var rooms = await _eventsDataUnit.EventRoomsRepository.GetAllAsync(x => x.EventID == Event.Event.ID);
Event.EventRooms = new List <EventRoomModel>(rooms.Select(x => new EventRoomModel(x)));
if (_forceRefreshData)
{
_eventsDataUnit.EventGolfsRepository.Refresh();
}
var golfs = await _eventsDataUnit.EventGolfsRepository.GetAllAsync(x => x.EventID == Event.Event.ID && x.IsLinked == false);
Event.EventGolfs = new List <EventGolfModel>(golfs.Select(x => new EventGolfModel(x)));
if (_forceRefreshData)
{
_eventsDataUnit.EventInvoicesRepository.Refresh();
}
var invoices = await _eventsDataUnit.EventInvoicesRepository.GetAllAsync(x => x.EventID == Event.Event.ID);
Event.EventInvoices = new List <EventInvoiceModel>(invoices.Select(x => new EventInvoiceModel(x)));
if (_forceRefreshData)
{
_eventsDataUnit.EventPaymentsRepository.Refresh();
}
var payments = await _eventsDataUnit.EventPaymentsRepository.GetAllAsync(x => x.EventID == Event.Event.ID);
Event.EventPayments = new ObservableCollection <EventPaymentModel>(payments.Select(x => new EventPaymentModel(x)));
Event.RefreshItems();
if (_forceRefreshData)
{
_eventsDataUnit.EventNotesRepository.Refresh();
}
var notes = await _eventsDataUnit.EventNotesRepository.GetAllAsync(x => x.EventID == Event.Event.ID);
Event.EventNotes = new ObservableCollection <EventNoteModel>(notes.Select(x => new EventNoteModel(x)));
if (_forceRefreshData)
{
_eventsDataUnit.EventRemindersRepository.Refresh();
}
var reminders = await _eventsDataUnit.EventRemindersRepository.GetAllAsync(x => x.EventID == Event.Event.ID);
Event.EventReminders = new ObservableCollection <EventReminderModel>(reminders.Select(x => new EventReminderModel(x)));
_event.LoadedTime = DateTime.Now;
_forceRefreshData = false;
}
_eventsDataUnit.EventStatusesRepository.Refresh();
var statuses = await _eventsDataUnit.EventStatusesRepository.GetAllAsync();
if (Event.EventStatus != null)
{
EventStatuses = new ObservableCollection <EventStatus>(statuses.Where(x => x.IsEnabled || x.ID == Event.EventStatus.ID).OrderBy(x => x.Name));
}
else
{
EventStatuses = new ObservableCollection <EventStatus>(statuses.Where(x => x.IsEnabled).OrderBy(x => x.Name));
}
_eventsDataUnit.EventTypesRepository.Refresh();
var types = await _eventsDataUnit.EventTypesRepository.GetAllAsync();
if (Event.EventType != null)
{
EventTypes = new ObservableCollection <EventType>(types.Where(x => x.IsEnabled && x.AllowToBeBooked || x.ID == Event.EventType.ID).OrderBy(x => x.Name));
}
else
{
EventTypes = new ObservableCollection <EventType>(types.Where(x => x.IsEnabled && x.AllowToBeBooked).OrderBy(x => x.Name));
}
var events = await _eventsDataUnit.EventsRepository.GetLightEventsAsync();
_allEvents = new List <Event>(events);
AlreadyCreatedEvents = new ObservableCollection <Event>(_allEvents.DistinctBy(x => x.Name));
_originalEvent = Event.Clone();
IsBusy = false;
}
private async void SubmitCommandExecuted()
{
if (!IsEditMode)
{
if (AreEventsVisible)
{
EventReminder.EventReminder.EventID = SelectedEvent.Event.ID;
EventReminder.EventReminder.Event = SelectedEvent.Event;
}
else
{
_event.EventReminders.Add(EventReminder);
}
_eventDataUnit.EventRemindersRepository.Add(EventReminder.EventReminder);
var primaryContact = EventReminder.EventReminder.Event != null ? EventReminder.EventReminder.Event.Contact == null ? String.Empty : "Primary Contact: " + EventReminder.EventReminder.Event.Contact.FirstName + " "
+ EventReminder.EventReminder.Event.Contact.LastName : String.Empty;
var msg = "Event-Reminder" + "\n" + "Created by " + EventReminder.CreatedByUser.FirstName + " " +
EventReminder.CreatedByUser.LastName + " at " + DateTime.Now + "\n" +
"Event Name: " + EventReminder.EventName + "\n" + primaryContact + "\n" + EventReminder.WhatToDo;
var email = new CorrespondenceModel(new Corresponcence()
{
ID = Guid.NewGuid(),
Date = DateTime.Now,
FromAddress = EventReminder.CreatedByUser.EmailAddress,
ToAddress = EventReminder.AssignedToUser.EmailAddress,
Subject = "Event-Reminder",
Message = msg,
});
await EmailService.SendEmail(email, null, null);
if (AreEventsVisible)
{
_originalEvent = SelectedEvent.Clone();
SelectedEvent.EventReminders.Add(EventReminder);
var eventUpdates = LoggingService.FindDifference(_originalEvent, SelectedEvent);
if (!SelectedEvent.EventUpdates.Any())
{
var updates = await _eventDataUnit.EventUpdatesRepository.GetAllAsync(x => x.EventID == SelectedEvent.Event.ID);
SelectedEvent.EventUpdates = new ObservableCollection <EventUpdate>(updates.OrderByDescending(x => x.Date));
}
ProcessUpdates(SelectedEvent, eventUpdates);
await _eventDataUnit.SaveChanges();
}
}
else
{
_eventReminder.AssignedToUser = AssignedToUser;
_eventReminder.EventReminder.AssignedToUserID = AssignedToUser.ID;
EventReminder.EventReminder.LastEditDate = DateTime.Now;
if (AreEventsVisible)
{
if (_originalEvent.Event.ID != _selectedEvent.Event.ID)
{
_originalEvent = _selectedEvent.Clone();
}
EventReminder.EventReminder.Event = SelectedEvent.Event;
SelectedEvent.EventReminders.Where(x => x.EventReminder == _eventReminder.EventReminder).FirstOrDefault().AssignedToUser = AssignedToUser;
var eventUpdates = LoggingService.FindDifference(_originalEvent, SelectedEvent);
if (!SelectedEvent.EventUpdates.Any())
{
var updates = await _eventDataUnit.EventUpdatesRepository.GetAllAsync(x => x.EventID == SelectedEvent.Event.ID);
SelectedEvent.EventUpdates = new ObservableCollection <EventUpdate>(updates.OrderByDescending(x => x.Date));
}
ProcessUpdates(_selectedEvent, eventUpdates);
await _eventDataUnit.SaveChanges();
}
else
{
_eventDataUnit.EventRemindersRepository.SetEntityModified(_eventReminder.EventReminder);
}
EventReminder.Refresh();
}
}