/// <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))); }