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