public AddEventGolfItemView(EventModel eventModel, EventGolfModel golfModel = null, System.Collections.Generic.List<EventGolfModel> alreadyBookedGolfs = null)
{
InitializeComponent();
DataContext = _viewModel = new AddEventGolfItemViewModel(eventModel, golfModel, alreadyBookedGolfs);
_viewModel.PropertyChanged += ViewModelOnPropertyChanged;
Owner = Application.Current.MainWindow;
Loaded += OnAddEventGolfItemViewLoaded;
}
/// <summary>
/// Double Check whether the resources booked in the event are not booked by someone else meanwhile.
/// </summary>
/// <returns></returns>
private async System.Threading.Tasks.Task ValidateResourcesAvailability()
{
AlreadyBookedCaterings = new List<EventCateringModel>();
AlreadyBookedRooms = new List<EventRoomModel>();
AlreadyBookedGolfs = new List<EventGolfModel>();
AlreadyBookedEventItems = new ObservableCollection<EventItemModel>();
_eventsDataUnit.EventRoomsRepository.Refresh(RefreshMode.ClientWins);
var rooms = await _eventsDataUnit.EventRoomsRepository.GetAllAsync(p => p.Event.ID != Event.Event.ID);
var eventRooms = rooms.Select(x => new EventRoomModel(x)).ToList();
_eventsDataUnit.EventCateringsRepository.Refresh(RefreshMode.ClientWins);
var caterings = await _eventsDataUnit.EventCateringsRepository.GetAllAsync(p => p.Event.ID != Event.Event.ID);
var eventCaterings = caterings.Select(x => new EventCateringModel(x)).ToList();
_eventsDataUnit.EventGolfsRepository.Refresh(RefreshMode.ClientWins);
var golfs = await _eventsDataUnit.EventGolfsRepository.GetAllAsync(p => p.Event.ID != Event.Event.ID);
var eventGolfs = golfs.Select(x => new EventGolfModel(x)).ToList();
var golfBookingService = new BookingsService() { BookedGolfs = eventGolfs };
var roomBookingService = new BookingsService() { BookedRooms = eventRooms, BookedCaterings = eventCaterings };
foreach (var eventItem in _event.EventItems)
{
if (eventItem.Instance.GetType() == typeof(EventCateringModel))
{
var model = (EventCateringModel)eventItem.Instance;
if (!model.EventCatering.Room.MultipleBooking)
{
var startTime = new DateTime(_event.Date.Year, _event.Date.Month, _event.Date.Day, model.StartTime.Hour, model.StartTime.Minute, 0);
var endTime = new DateTime(_event.Date.Year, _event.Date.Month, _event.Date.Day, model.EndTime.Hour, model.EndTime.Minute, 0);
if (roomBookingService.IsRoomAvailable(_event.Event.ID, model.Room, startTime, endTime))
roomBookingService.BookedCaterings.Add(model);
else
{
AlreadyBookedCaterings.Add(model);
AlreadyBookedEventItems.Add(eventItem);
}
}
}
else if (eventItem.Instance.GetType() == typeof(EventRoomModel))
{
var model = (EventRoomModel)eventItem.Instance;
if (!model.EventRoom.Room.MultipleBooking)
{
var startTime = new DateTime(_event.Date.Year, _event.Date.Month, _event.Date.Day, model.StartTime.Hour, model.StartTime.Minute, 0);
var endTime = new DateTime(_event.Date.Year, _event.Date.Month, _event.Date.Day, model.EndTime.Hour, model.EndTime.Minute, 0);
if (roomBookingService.IsRoomAvailable(_event.Event.ID, model.Room, startTime, endTime))
roomBookingService.BookedRooms.Add(model);
else
{
AlreadyBookedRooms.Add(model);
AlreadyBookedEventItems.Add(eventItem);
}
}
}
else if (eventItem.Instance.GetType() == typeof(EventGolfModel))
{
var model = (EventGolfModel)eventItem.Instance;
var startTime = new DateTime(_event.Date.Year, _event.Date.Month, _event.Date.Day, model.Time.Hour, model.Time.Minute, 0);
var endTime = startTime.AddMinutes(model.Golf.TimeInterval.TotalMinutes * model.EventGolf.Slots);
if (golfBookingService.IsGolfAvailable(model.Golf, startTime, endTime))
{
golfBookingService.BookedGolfs.Add(model);
if (model.EventGolf.EventGolf1 != null)
{
var linkedGolf = new EventGolfModel(model.EventGolf.EventGolf1);
startTime = new DateTime(_event.Date.Year, _event.Date.Month, _event.Date.Day, linkedGolf.Time.Hour, linkedGolf.Time.Minute, 0);
endTime = startTime.AddMinutes(linkedGolf.Golf.TimeInterval.TotalMinutes * linkedGolf.EventGolf.Slots);
if (golfBookingService.IsGolfAvailable(linkedGolf.Golf, startTime, endTime))
golfBookingService.BookedGolfs.Add(linkedGolf);
else
{
AlreadyBookedGolfs.Add(model);
AlreadyBookedEventItems.Add(eventItem);
}
}
}
else
{
AlreadyBookedGolfs.Add(model);
AlreadyBookedEventItems.Add(eventItem);
}
}
}
}
private void AddGolfProduct(EventGolfModel model)
{
var charge = new EventCharge
{
ID = Guid.NewGuid(),
EventID = _event.Event.ID,
ShowInInvoice = model.EventGolf.ShowInInvoice
};
var item = new EventBookedProductModel(new EventBookedProduct
{
ID = Guid.NewGuid(),
EventBookingItemID = model.EventGolf.ID,
EventID = _event.Event.ID,
EventCharge = charge
});
item.Quantity = _event.Event.Places;
item.PropertyChanged += OnEventBookedProductModelPropertyChanged;
model.EventBookedProducts.Add(item);
}
private EventGolfModel GetEventGolf()
{
var eventGolf = new EventGolfModel(new EventGolf
{
ID = Guid.NewGuid(),
EventID = _event.Event.ID,
Slots = (int)Math.Round((double)(_event.Places / 4), 0),
ShowInInvoice = true,
IncludeInCorrespondence = true,
IncludeInForwardBook = true
});
return eventGolf;
}
private void ProcessEventGolf(EventGolfModel golfModel)
{
_isEditMode = (golfModel != null);
EventGolf = (_isEditMode) ? golfModel : GetEventGolf();
if (_isEditMode)
EventGolfOriginal = EventGolf.Clone();
EventGolf.PropertyChanged += OnEventBookedProductModelPropertyChanged;
}
public AddEventGolfItemViewModel(EventModel eventModel, EventGolfModel golfModel, List<EventGolfModel> alreadyBookedGolfs)
{
_event = eventModel;
var dataUnitLocator = ContainerAccessor.Instance.GetContainer().Resolve<IDataUnitLocator>();
_eventDataUnit = dataUnitLocator.ResolveDataUnit<IEventDataUnit>();
SubmitCommand = new RelayCommand(SubmitCommandExecuted, SubmitCommandCanExecute);
AddItemCommand = new RelayCommand(AddItemCommandExecuted);
CancelCommand = new RelayCommand(CancelCommandExecuted);
ShowResourcesCommand = new RelayCommand(ShowResourcesCommandExecuted);
AddProductCommand = new RelayCommand(AddProductCommandExecuted);
DeleteBookedProductCommand = new RelayCommand<EventBookedProductModel>(DeleteBookedProductCommandExecuted);
AlreadyBookedGolfs = alreadyBookedGolfs;
ProcessEventGolf(golfModel);
}
