public async Task <ActionResult> UpdateEventAsync( Guid eventId, [FromBody] UpdateEventViewModel entity) { var validator = new UpdateEventViewModelValidator(_utilityService, _mapper); ValidationResult result = validator.Validate(entity); if (!result.IsValid) { return(BadRequest(new ErrorResponseFormat(result.Errors.First().ErrorMessage))); } var targetEvent = await _service.GetEventAsync(eventId); if (targetEvent == null) { return(BadRequest(new ErrorResponseFormat(Constants.Errors.EVENT_NOT_FOUND))); } if (targetEvent.Creator.Id != new Guid( User.FindFirst(JwtRegisteredClaimNames.Jti).Value)) { return(BadRequest(new ErrorResponseFormat(Constants.Errors.NO_UPDATE_RIGHTS))); } var updateResult = await _service.UpdateEventAsync(eventId, _mapper.Map <UpdateEventModel>(entity)); return(Ok()); }
public async Task <IActionResult> Put([FromBody] UpdateEventViewModel updateModel) { var result = await this.Mediator.Send( updateModel.ProjectedAs <PresenterUpdateEventCommand>()); return(this.GetResult(result)); }
public ActionResult Update(UpdateEventViewModel model) { if (ModelState.IsValid) { var newEvent = new Event { Id = model.Id, Name = model.Name, BeginDate = model.BeginTime, EndDate = model.EndTime }; if (IsIntersected(newEvent)) { return(RedirectToAction("Intersection")); } try { _db.Update(newEvent); return(RedirectToAction("GetAll")); } catch (Exception) { ModelState.AddModelError("", "Oops something went wrong"); } } return(Json(new { status = "error", errors = GetErrors(ModelState) }, JsonRequestBehavior.DenyGet)); }
public async Task <IHttpActionResult> UpdateEvent(UpdateEventViewModel eventViewModel) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var eventDto = _mapper.Map <UpdateEventViewModel, EditEventDto>(eventViewModel); eventDto.Offices = new EventOfficesDto { Value = JsonConvert.SerializeObject(eventViewModel.Offices.Select(p => p.ToString()).ToList()) }; SetOrganizationAndUser(eventDto); try { await _eventService.UpdateEventAsync(eventDto); } catch (EventException e) { return(BadRequest(e.Message)); } return(Ok()); }
public UpdateEventPage(Events events) { InitializeComponent(); var ViewModel = new UpdateEventViewModel(); ViewModel.Events = events; BindingContext = ViewModel; }
public async Task <IActionResult> UpdateEvent(Guid eventId, [FromBody] UpdateEventViewModel eventViewModel) { if (!ModelState.IsValid) { return(StatusCode(422, eventViewModel)); } await _eventApplicationService.UpdateEvent(eventId, eventViewModel); return(NoContent()); }
public async Task UpdateEvent(Guid eventId, UpdateEventViewModel eventViewModel) { var _event = _mapper.Map<Event>(eventViewModel); await _mediator.Send(new UpdateEventCommand(eventViewModel.Id) { Name = _event.Name, Description = _event.Description, EventDate = _event.EventDate, Image = _event.Image, Address = _event.Address, Price = _event.Price }); }
public void SetUpConverterUpdateCommandShould() { this.UpdateAreaViewModel = new UpdateAreaViewModel { Id = 1, LayoutId = 1, Description = "UpdateAreaViewModelDescription", CoordX = 2, CoordY = 3 }; this.UpdateEventAreaViewModel = new UpdateEventAreaViewModel { Id = 2, CoordX = 1, CoordY = 2, Description = "UpdateEventAreaViewModelDescription", EventId = 11, Price = 123142M }; this.UpdateEventViewModel = new UpdateEventViewModel { Id = 3, Name = "EventName1", Banner = "EventBanner1", Description = "EventDescription1", RunTime = TimeSpan.FromHours(1), StartAt = new DateTime(2019, 1, 17, 18, 30, 0), LayoutId = 1 }; this.UpdateEventSeatViewModel = new UpdateEventSeatViewModel { Id = 4, EventAreaId = 1, Row = 2, Number = 3, State = 4 }; this.UpdateLayoutViewModel = new UpdateLayoutViewModel { Id = 5, VenueId = 1, Description = "LayoutDescription1" }; this.UpdateSeatViewModel = new UpdateSeatViewModel { Id = 6, AreaId = 1, Row = 1, Number = 1 }; this.UpdateVenueViewModel = new UpdateVenueViewModel { Id = 7, Description = "VenueDescription1", Address = "VenueAddress1", Phone = "VenuePhone1" }; }
/// <summary> /// Map /// </summary> /// <param name="initialSource"></param> /// <param name="targetSource"></param> /// <returns></returns> public static CalendarEvent Map(CalendarEvent initialSource, UpdateEventViewModel targetSource) { if (targetSource == null) { return(initialSource); } initialSource.Title = targetSource.Title; initialSource.Details = targetSource.Details; initialSource.StartDate = targetSource.StartDate; initialSource.EndDate = targetSource.EndDate; initialSource.Location = targetSource.Location; initialSource.Priority = targetSource.Priority; initialSource.MinutesToRemind = targetSource.MinutesToRemind; return(initialSource); }
public async Task <CommandResult <bool> > UpdateEvent([FromBody] UpdateEventViewModel viewModel) { var updateEventModel = _mapper.Map <WebSiteEventModel>(viewModel); var result = await _EventManager.UpdateEvent(updateEventModel); if (result.IsSucceeded) { foreach (var image in viewModel.Images) { this.ConfirmFileAdded(image); this.ConfirmImageAdded(image); } this.ConfirmFileAdded(viewModel.CoverImage); this.ConfirmImageAdded(viewModel.CoverImage); } return(result); }
public async Task <JsonResult> UpdateEvent([Required] UpdateEventViewModel model) { var response = new ResultModel(); if (ModelState.IsValid) { var userRequest = await _userManager.GetCurrentUserAsync(); if (!userRequest.IsSuccess) { return(Json(response)); } var user = userRequest.Result; return(Json(await _calendarManager.UpdateEventAsync(model, user.Id))); } response.Errors = ModelState.ToResultModelErrors().ToList(); return(Json(response, _serializeSettings)); }
/// <inheritdoc /> /// <summary> /// Update event /// </summary> /// <param name="model"></param> /// <param name="organizerId"></param> /// <returns></returns> public async Task <ResultModel> UpdateEventAsync(UpdateEventViewModel model, Guid?organizerId) { var response = new ResultModel(); if (!organizerId.HasValue) { response.Errors.Add(new ErrorModel(string.Empty, "Organizer not identified")); return(response); } var evt = await _context.CalendarEvents.FirstOrDefaultAsync(x => x.Organizer.Equals(organizerId) && x.Id.Equals(model.Id)); if (evt == null) { response.Errors.Add(new ErrorModel(string.Empty, "The event was not found or the organizer does not have access to this event")); return(response); } var updateModel = EventMapper.Map(evt, model); _context.CalendarEvents.Update(updateModel); var dbResult = await _context.PushAsync(); CalendarEvents.SystemCalendarEvents.EventUpdated(new EventUpdatedEventArgs { EventId = evt.Id, StartDate = evt.StartDate, EndDate = evt.EndDate, Title = evt.Title, Details = evt.Details, Organizer = evt.Author, Invited = model.Members?.Select(x => x.ToString()), BaseAppUrl = _contextAccessor?.GetAppBaseUrl() }); if (dbResult.IsSuccess) { return(await AddOrUpdateMembersToEventAsync(model.Id, model.Members)); } response.Errors = dbResult.Errors; return(response); }
public IActionResult Put([FromBody] UpdateEventViewModel updateEventViewModel) { var eventDto = Mapper.Map <EventDto>(updateEventViewModel); var updatedEvent = _eventService.UpdateEvent(eventDto); updateEventViewModel = Mapper.Map <UpdateEventViewModel>(updatedEvent); if (updateEventViewModel == null) { return(BadRequest()); } if ((updateEventViewModel.StartDate < DateTime.Now) || (updateEventViewModel.StartDate > updateEventViewModel.EndDate)) { return(BadRequest()); } return(Ok(updateEventViewModel)); }
public async Task <ActionResult> CreateEventAsync( [FromBody] UpdateEventViewModel entity) { var validator = new UpdateEventViewModelValidator(_utilityService, _mapper); ValidationResult result = validator.Validate(entity); if (!result.IsValid) { return(BadRequest(new ErrorResponseFormat(result.Errors.First().ErrorMessage))); } CreateEventModel createEventModel = new CreateEventModel(); _mapper.Map(entity, createEventModel); createEventModel.CreatorId = new Guid( User.FindFirst(JwtRegisteredClaimNames.Jti).Value); var createdEvent = await _service.CreateEventAsync(createEventModel); return(Ok(_mapper.Map <EventViewModel>(createdEvent))); }
public async Task <IActionResult> Update(UpdateEventViewModel model) { if (!ModelState.IsValid) { return(View(model)); } if (!(await _eventsService.IsOwner(model.Id, User.GetNameIdentifier()))) { return(RedirectToAction(nameof(Browse))); } var @event = _mapper.Map <UpdateEventViewModel, Event>(model); var result = await _eventsService.UpdateEventAsync(@event); if (result.Type != ResultStatusType.Ok) { AddModelErrors(result); return(View(model)); } return(RedirectToAction(nameof(Browse))); }