/// <summary>
/// Create a venue. A venue can not be created without layouts
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public async Task Create(VenueDto entity)
{
if (entity == null)
{
throw new ArgumentNullException();
}
if (!IsNameUnique(entity, true))
{
throw new VenueException("Such venue already exists");
}
if (entity.LayoutList == null || !entity.LayoutList.Any())
{
throw new VenueException("Incorrect state of the venue. The venue must have at least one layout");
}
var venueAdd = VenueParser.MapToVenue(entity);
using (var transaction = CustomTransactionScope.GetTransactionScope())
{
_context.VenueRepository.Create(venueAdd);
await _context.SaveAsync();
entity.Id = venueAdd.Id;
foreach (var layout in entity.LayoutList)
{
layout.VenueId = venueAdd.Id;
await _layoutService.Create(layout);
}
transaction.Complete();
}
}
private EventBusinessModel EventModelBllToEventModelContract(BusinessLogic.BusinessModels.EventModel from)
{
return(new EventBusinessModel
{
Areas = from.Areas?.Select(x => EventAreaParser.ToEventAreaContract(x)).ToList(),
Event = from.Event is null ? null : EventParser.ToEventContract(from.Event),
IsPublished = from.IsPublished,
LayoutName = from.LayoutName ?? null,
Venue = from.Venue is null ? null : VenueParser.ToVenueContract(from.Venue)
});
public override async Task Initialize()
{
AddVenueCommand = new RelayCommandAsync(OnAddVenue);
EditVenueCommand = new RelayCommandAsync(OnEditVenue);
DeleteVenueCommand = new RelayCommandAsync(OnDeleteVenue);
_mediator.Subscribe(VenueSavedOperationKey, VenueSaved);
var venues = await _venueService.ToListAsync();
VenueList = new ObservableCollection <Models.Venue>(venues.Select(x => VenueParser.ToVenue(x)).ToList());
}
private SeatBusinessModel SeatModelBllToSeatModelContract(BusinessLogic.BusinessModels.SeatModel from)
{
return(new SeatBusinessModel
{
Seat = EventSeatParser.ToEventSeatContract(from.Seat),
Area = EventAreaParser.ToEventAreaContract(from.Area),
Event = EventParser.ToEventContract(from.Event),
Layout = LayoutParser.ToLayoutContract(from.Layout),
Venue = VenueParser.ToVenueContract(from.Venue)
});
}
public async Task <IEnumerable <Venue> > ToList()
{
try
{
var result = await _venueService.GetList();
return(result.Select(x => VenueParser.ToVenueContract(x)));
}
catch (VenueException exception)
{
var fault = new ServiceValidationFaultDetails {
Message = "Getting of list of venue error"
};
throw new FaultException <ServiceValidationFaultDetails>(fault, exception.Message);
}
}
public async Task <Venue> GetFullModel(int id)
{
try
{
var result = await _venueService.GetFullModel(id);
return(VenueParser.ToVenueContract(result));
}
catch (VenueException exception)
{
var fault = new ServiceValidationFaultDetails {
Message = "Get venue error"
};
throw new FaultException <ServiceValidationFaultDetails>(fault, exception.Message);
}
}
public async Task Update(Venue entity)
{
try
{
var update = VenueParser.ToVenueDto(entity);
await _venueService.Update(update);
}
catch (VenueException exception)
{
var fault = new ServiceValidationFaultDetails {
Message = "Update venue error"
};
throw new FaultException <ServiceValidationFaultDetails>(fault, exception.Message);
}
}
private async Task OnEditVenue(object obj)
{
if (!(obj is Models.Venue venue))
{
return;
}
var edit = await _venueService.GetFullModelAsync(venue.Id);
venue.LayoutList = VenueParser.ToVenue(edit).LayoutList;
_markedVenue = venue;
await OpenVenueWindow(venue, string.Format(l10n.VenueView.View.EditTitle, edit.Name));
_markedVenue = null;
}
public async Task <int> Create(Venue entity)
{
try
{
var add = VenueParser.ToVenueDto(entity);
await _venueService.Create(add);
return(add.Id);
}
catch (VenueException exception)
{
var fault = new ServiceValidationFaultDetails {
Message = "Create venue error"
};
throw new FaultException <ServiceValidationFaultDetails>(fault, exception.Message);
}
}
public Task <VenueDto> GetFullModel(int id)
{
var data = (from venues in _context.VenueRepository.GetList()
join layotus in _context.LayoutRepository.GetList() on venues.Id equals layotus.VenueId
join areas in _context.AreaRepository.GetList() on layotus.Id equals areas.LayoutId
join seats in _context.SeatRepository.GetList() on areas.Id equals seats.AreaId
where venues.Id == id
select new { Venue = venues, Layout = layotus, Area = areas, Seat = seats }).ToList();
if (!data.Any())
{
return(null);
}
var venue = data.FirstOrDefault().Venue;
var result = VenueParser.MapToVenueDto(venue);
foreach (var row in data)
{
var layout = result.LayoutList.SingleOrDefault(x => x.Id == row.Layout.Id);
//add layout if it isn't exist in a result
if (layout is null)
{
layout = LayoutParser.MapToLayoutDto(row.Layout);
result.LayoutList.Add(layout);
}
var area = layout.AreaList.SingleOrDefault(x => x.Id == row.Area.Id);
//add area if it isn't exist in a result
if (area is null)
{
area = AreaParser.MapToAreaDto(row.Area);
layout.AreaList.Add(area);
}
area.SeatList.Add(SeatParser.MapToSeatDto(row.Seat));
}
return(Task.FromResult(result));
}
private async Task OnSave(object obj)
{
if (Venue is null)
{
return;
}
Errors = Venue.Validate().ToList();
if (Errors.Any())
{
return;
}
var addOrUpdate = VenueParser.ToVenueContract(Venue);
try
{
if (addOrUpdate.Id <= 0)
{
Venue.Id = await _venueService.CreateAsync(addOrUpdate);
}
else
{
await _venueService.UpdateAsync(addOrUpdate);
Venue.Id = addOrUpdate.Id;
}
//update ids of areas, which were update (for large count of seats, venue service deletes areas and inserts it in order to increase performance)
var venue = _venueService.GetFullModel(Venue.Id);
Venue = VenueParser.ToVenue(venue);
_mediator.Raise(VenueManagementViewModel.VenueSavedOperationKey, Venue);
}
catch (FaultException <ServiceValidationFaultDetails> exception)
{
switch (exception.Message)
{
case "Such venue already exists":
DisplayError(l10n.VenueView.Errors.VenueNameIsExists);
break;
case "Incorrect state of the venue. The venue must have at least one layout":
DisplayError(l10n.VenueView.Errors.VenueHasNoLayouts);
break;
case "Area description isn't unique":
DisplayError(l10n.VenueView.Errors.AreaDescriptionUnique);
break;
case "Incorrect state of area. An area must have atleast one seat":
DisplayError(l10n.VenueView.Errors.AreaHasNoSeats);
break;
case "Layout description isn't unique":
DisplayError(l10n.VenueView.Errors.LayoutDescriptionUnique);
break;
case "Incorrect state of the layout. The layout must have at least one area":
DisplayError(l10n.VenueView.Errors.LayoutDescriptionUnique);
break;
}
}
catch (FaultException)
{
DisplayError(l10n.Shared.Errors.InternalAppError);
}
}
public async Task <VenueDto> Get(int id)
{
var venue = await _context.VenueRepository.GetAsync(id);
return(venue == null ? null : VenueParser.MapToVenueDto(venue));
}
public async Task <IEnumerable <VenueDto> > GetList()
{
var list = await _context.VenueRepository.GetListAsync();
return(list.Select(x => VenueParser.MapToVenueDto(x)));
}
