private Event MapToEvent(EventEditModel editModel)
{
var @event = _eventsService.Get(editModel.Id);
@event = Mapper.Map(editModel, @event);
@event.MediaIds = @event.MediaIds.Concat(_mediaHelper.CreateMedia(editModel, MediaFolderTypeEnum.EventsContent));
@event.StartDate = editModel.StartDate.ToUniversalTime().WithCorrectedDaylightSavingTime(editModel.StartDate);
@event.PublishDate = editModel.PublishDate.ToUniversalTime().WithCorrectedDaylightSavingTime(editModel.PublishDate);
@event.EndDate = editModel.EndDate.ToUniversalTime().WithCorrectedDaylightSavingTime(editModel.EndDate);
@event.EndPinDate = editModel.EndPinDate?.ToUniversalTime().WithCorrectedDaylightSavingTime(editModel.EndPinDate.Value);
if (!_permissionsService.Check(ActivityType, PermissionActionEnum.CanPin))
{
@event.EndPinDate = null;
@event.IsPinned = false;
}
@event.SubscribeNotes = editModel.SubscribeNotes;
// not allow change CanSubscribe, if someone subscribes while event was editing
if (_eventsService.CanEditSubscribe(@event.Id))
{
@event.CanSubscribe = editModel.CanSubscribe;
}
return(@event);
}
protected virtual EventBase MapEditModel(EventEditModel saveModel)
{
var @event = _eventsService.Get(saveModel.Id);
@event = Mapper.Map(saveModel, @event);
return(@event);
}
public ActionResult Edit(int id, EventEditModel model)
{
//Defensive coding
if (model.EventID != id)
{
ModelState.AddModelError("", "Nice try!");
model.EventID = id;
return(View(model));
}
if (!ModelState.IsValid)
{
return(View(model));
}
if (!CreateEventService().UpdateEvent(model))
{
ModelState.AddModelError("", "Unable to update event");
return(View(model));
}
TempData["SaveResult"] = "Your event was saved";
return(RedirectToAction("Index"));
}
public async Task UpdateProperties(Event @event, EventEditModel editModel)
{
if (editModel.Title != null)
{
@event.Title = editModel.Title;
}
if (editModel.ShortTitle != null)
{
@event.ShortTitle = editModel.ShortTitle;
}
if (editModel.Description != null)
{
@event.Description = editModel.Description;
}
if (editModel.Dates != null)
{
@event.Dates = new List <EventDate>(editModel.Dates);
}
if (editModel.Images != null)
{
@event.Images = new List <ImageModel>(editModel.Images);
}
if (editModel.Place != null)
{
@event.Place = await context.Places
.FirstAsync(existingPlace => existingPlace.Id == editModel.Place.Id);
}
if (editModel.Categories != null)
{
@event.EventCategories = editModel.Categories.Select(categoryName => new EventCategory
{
//если такой категории ещё не было, она будет добавлена при сохранении; аналогично с тегом
Category = FindCategoryByName(categoryName) ?? new Category {
Name = categoryName
},
Event = @event
}).ToHashSet();
}
if (editModel.Tags != null)
{
@event.EventTags = editModel.Tags.Select(tagName => new EventTag
{
Tag = FindTagByName(tagName) ?? new Tag {
Name = tagName
},
Event = @event
}).ToHashSet();
}
}
private void RaiseEventEditedEvent(EventEditModel eventEditModel)
{
var handler = EventEdited;
if (handler != null)
{
EventEditEventArgs e = new EventEditEventArgs(eventEditModel);
handler(this, e);
}
}
private EventEditModel buildNewEventDetailsModel(EventEditModel existingEvent, DuplicateEventModel newEventDetails)
{
existingEvent.Id = 0;
existingEvent.Name = newEventDetails.Name;
existingEvent.Description = newEventDetails.Description;
existingEvent.StartDateTime = newEventDetails.StartDateTime;
existingEvent.EndDateTime = newEventDetails.EndDateTime;
return(existingEvent);
}
protected virtual EventBase MapToEvent(EventEditModel editModel)
{
var @event = MapEditModel(editModel);
@event.MediaIds = @event.MediaIds.Concat(_mediaHelper.CreateMedia(editModel));
@event.StartDate = editModel.StartDate.ToUniversalTime().WithCorrectedDaylightSavingTime(editModel.StartDate);
@event.PublishDate = editModel.PublishDate.ToUniversalTime().WithCorrectedDaylightSavingTime(editModel.PublishDate);
@event.EndDate = editModel.EndDate.ToUniversalTime().WithCorrectedDaylightSavingTime(editModel.EndDate);
@event.EndPinDate = editModel.EndPinDate?.ToUniversalTime().WithCorrectedDaylightSavingTime(editModel.EndPinDate.Value);
return(@event);
}
// GET: Event/Edit/5
public ActionResult Edit(int id)
{
var detail = _eventService.Value.GetEventById(id);
var model =
new EventEditModel
{
EventID = detail.EventID,
EventName = detail.EventName,
EventDate = detail.EventDate,
EventLocation = detail.EventLocation
};
return(View(model));
}
public ActionResult Edit(int id)
{
var detailModel = CreateEventService().GetEventById(id);
var editModel =
new EventEditModel
{
EventID = detailModel.EventID,
EventName = detailModel.EventName,
Date = detailModel.Date,
Location = detailModel.Location
};
return(View(editModel));
}
protected override EventBase MapToEvent(EventEditModel editModel)
{
var @event = (Event)base.MapToEvent(editModel);
var extendedEditModel = (EventExtendedEditModel)editModel;
@event.SubscribeNotes = extendedEditModel.SubscribeNotes;
// not allow change CanSubscribe, if someone subscribes while event was editing
if (_eventsService.CanEditSubscribe(@event.Id))
{
@event.CanSubscribe = extendedEditModel.CanSubscribe;
}
return(@event);
}
public async Task <Event> UpdateAsync(int id, EventEditModel editModel)
{
var eventToUpdate = context.Events.Find(id);
if (eventToUpdate == null)
{
return(null);
}
await UpdateProperties(eventToUpdate, editModel);
await context.SaveChangesAsync();
return(eventToUpdate);
}
public IActionResult Create(EventEditModel model)
{
if (ModelState.IsValid)
{
var newEvent = new Event();
newEvent.EventName = model.EventName;
newEvent.EventType = model.EventType;
newEvent = _eventData.Add(newEvent);
return(RedirectToAction(nameof(Details), new { id = newEvent.EventId }));
}
else
{
return(View());
}
}
public IHttpActionResult Put(EventEditModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var service = CreateEventService();
if (!service.UpdateEvent(model))
{
return(InternalServerError());
}
return(Ok());
}
public async Task <ActionResult <EventViewModel> > UpdateEventAsync([FromRoute] int id,
[FromBody] EventEditModel editViewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!EventExists(id))
{
return(NotFound());
}
var @event = await eventsRepository.UpdateAsync(id, editViewModel);
return(@event.ToViewModel());
}
public ActionResult Edit(EventEditModel model)
{
if (!ModelState.IsValid)
{
return(Json(new { success = false, message = ModelState.GetErrors() }));
}
var eventEntity = Mapper.Map <EventEditModel, EventEntity>(model);
var success = EventServices.UpdateEvent(model.EventId, eventEntity, CurrentCedUser.CurrentUser.UserId);
if (!success)
{
return(Json(new { success = false, message = "Update failed!" }));
}
return(Json(new { success = true, message = "You updated the event!" }));
}
public void ReturnsCorrectErrorWhenEndDateTimeIsLessThanStartDateTime()
{
var validator = new EventEditModelValidator();
var parentCampaign = new CampaignSummaryModel {
EndDate = new DateTimeOffset(new DateTime(1999, 2, 1))
};
var model = new EventEditModel
{
StartDateTime = new DateTimeOffset(new DateTime(2000, 1, 1)),
EndDateTime = new DateTimeOffset(new DateTime(1999, 1, 1))
};
var errors = validator.Validate(model, parentCampaign);
Assert.True(errors.Exists(x => x.Key.Equals("EndDateTime")));
Assert.Equal(errors.Find(x => x.Key == "EndDateTime").Value, "End date cannot be earlier than the start date");
}
public bool UpdateEvent(EventEditModel model)
{
using (var ctx = new ApplicationDbContext())
{
var entity =
ctx
.Events
.Single(e => e.EventID == model.EventID && e.UserID == _userId);
entity.EventName = model.EventName;
entity.EventDate = model.EventDate;
entity.EventTime = model.EventTime;
entity.EventLocation = model.EventLocation;
return(ctx.SaveChanges() == 1);
}
}
public async Task <IActionResult> Edit(int id, EventEditModel model)
{
var user = await this.userManager.GetUserAsync(this.User);
var isEdited = await this.events.EditAsync(
id, user.Id, model.Title, model.Description, model.StartDate, model.EndDate,
model.Address, model.Latitude, model.Longitude);
if (!isEdited)
{
return(this.RedirectToAction("Details", "Events", new { Area = "Events", id })
.WithDanger(string.Empty, CantEditEvent));
}
return(this.RedirectToAction("Details", "Events", new { Area = "Events", id })
.WithSuccess(string.Empty, EditEventSuccess));
}
public async Task <IActionResult> Create(int campaignId, EventEditModel campaignEvent, IFormFile fileUpload)
{
var campaign = await _mediator.SendAsync(new CampaignSummaryQuery { CampaignId = campaignId });
if (campaign == null || !User.IsOrganizationAdmin(campaign.OrganizationId))
{
return(Unauthorized());
}
var errors = _eventDetailModelValidator.Validate(campaignEvent, campaign);
errors.ToList().ForEach(e => ModelState.AddModelError(e.Key, e.Value));
ModelState.Remove("NewItinerary");
//TryValidateModel is called explictly because of MVC 6 behavior that supresses model state validation during model binding when binding to an IFormFile.
//See #619.
if (ModelState.IsValid && TryValidateModel(campaignEvent))
{
if (fileUpload != null)
{
if (!fileUpload.IsAcceptableImageContentType())
{
ModelState.AddModelError("ImageUrl", "You must upload a valid image file for the logo (.jpg, .png, .gif)");
return(View("Edit", campaignEvent));
}
}
campaignEvent.OrganizationId = campaign.OrganizationId;
var id = await _mediator.SendAsync(new EditEventCommand { Event = campaignEvent });
if (fileUpload != null)
{
// resave now that event has the ImageUrl
campaignEvent.Id = id;
campaignEvent.ImageUrl = await _imageService.UploadEventImageAsync(campaign.OrganizationId, id, fileUpload);
await _mediator.SendAsync(new EditEventCommand { Event = campaignEvent });
}
return(RedirectToAction(nameof(Details), new { area = "Admin", id = id }));
}
return(View("Edit", campaignEvent));
}
public async Task EventDoesNotExist()
{
var context = ServiceProvider.GetService <AllReadyContext>();
var htb = new Organization
{
Id = 123,
Name = "Humanitarian Toolbox",
LogoUrl = "http://www.htbox.org/upload/home/ht-hero.png",
WebUrl = "http://www.htbox.org",
Campaigns = new List <Campaign>()
};
var firePrev = new Campaign
{
Id = 1,
Name = "Neighborhood Fire Prevention Days",
ManagingOrganization = htb,
TimeZoneId = "Central Standard Time"
};
htb.Campaigns.Add(firePrev);
context.Organizations.Add(htb);
context.SaveChanges();
var vm = new EventEditModel
{
CampaignId = 1,
TimeZoneId = "Central Standard Time"
};
var query = new EditEventCommand {
Event = vm
};
var handler = new EditEventCommandHandler(context);
var result = await handler.Handle(query);
Assert.True(result > 0);
var data = context.Events.Count(_ => _.Id == result);
Assert.True(data == 1);
}
public async Task <IActionResult> Edit(EventEditModel campaignEvent, IFormFile fileUpload)
{
if (campaignEvent == null)
{
return(BadRequest());
}
var organizationId = _mediator.Send(new ManagingOrganizationIdByEventIdQuery {
EventId = campaignEvent.Id
});
if (!User.IsOrganizationAdmin(organizationId))
{
return(Unauthorized());
}
var campaign = await _mediator.SendAsync(new CampaignSummaryQuery { CampaignId = campaignEvent.CampaignId });
var errors = _eventDetailModelValidator.Validate(campaignEvent, campaign);
errors.ForEach(e => ModelState.AddModelError(e.Key, e.Value));
if (ModelState.IsValid)
{
if (fileUpload != null)
{
if (fileUpload.IsAcceptableImageContentType())
{
campaignEvent.ImageUrl = await _imageService.UploadEventImageAsync(campaign.OrganizationId, campaignEvent.Id, fileUpload);
}
else
{
ModelState.AddModelError("ImageUrl", "You must upload a valid image file for the logo (.jpg, .png, .gif)");
return(View(campaignEvent));
}
}
var id = await _mediator.SendAsync(new EditEventCommand { Event = campaignEvent });
return(RedirectToAction(nameof(Details), new { area = "Admin", id = id }));
}
return(View(campaignEvent));
}
public EventInfoViewModel(EventDisplayModel eventDisplayModel)
{
this.eventEditModel = new EventEditModel
{
DateOfTournamentStart = eventDisplayModel.DateOfTournamentStart,
SportName = eventDisplayModel.SportName,
TournamentName = eventDisplayModel.TournamentName,
DateOfEvent = eventDisplayModel.DateOfEvent,
NewDateOfEvent = eventDisplayModel.DateOfEvent,
OldNotes = eventDisplayModel.Notes,
NewNotes = eventDisplayModel.Notes,
Participants = eventDisplayModel.Participants
};
this.SaveChangesCommand = new DelegateCommand(() => RaiseEventEditedEvent(eventEditModel), CanSave);
}
public void RetrunsCorrectErrorWhenModelsEndDateTimeIsGreaterThanParentCampaignsEndDate()
{
var validator = new EventEditModelValidator();
var parentCampaign = new CampaignSummaryModel
{
StartDate = new DateTimeOffset(new DateTime(2000, 1, 1)),
EndDate = new DateTimeOffset(new DateTime(2001, 1, 1))
};
var model = new EventEditModel
{
StartDateTime = new DateTimeOffset(new DateTime(2001, 1, 1)),
EndDateTime = new DateTimeOffset(new DateTime(2001, 2, 1)),
};
var errors = validator.Validate(model, parentCampaign);
Assert.True(errors.Exists(x => x.Key.Equals("EndDateTime")));
Assert.Equal(errors.Find(x => x.Key == "EndDateTime").Value, "End date cannot be later than the campaign end date " + parentCampaign.EndDate.ToString("d"));
}
public virtual ActionResult Edit(EventEditModel editModel)
{
if (!ModelState.IsValid)
{
return(RedirectToCurrentUmbracoPage(Request.QueryString));
}
var cachedActivityMedias = _eventsService.Get(editModel.Id).MediaIds;
var activity = MapToEvent(editModel);
_eventsService.Save(activity);
DeleteMedia(cachedActivityMedias.Except(activity.MediaIds));
OnEventEdited(activity, editModel);
return(Redirect(editModel.Links.Details));
}
protected override void OnEventEdited(EventBase @event, EventEditModel model)
{
if (!_eventsService.IsActual(@event))
{
return;
}
if (model.NotifyAllSubscribers)
{
var notificationType = NotificationTypeEnum.EventUpdated;
((INotifyableService)_eventsService).Notify(@event.Id, notificationType);
}
if (model is EventExtendedEditModel extendedModel)
{
_activityTagsHelper.ReplaceTags(@event.Id, extendedModel.TagIdsData);
}
_reminderService.CreateIfNotExists(@event.Id, ReminderTypeEnum.OneDayBefore);
}
private void Edit(EventDisplayModel eventDisplayModel, IEnumerable <ParticipantBaseModel> allParticipants)
{
EventManageViewModel viewModel = new EventManageViewModel(eventDisplayModel, allParticipants);
EventManageControl control = new EventManageControl(viewModel);
Window window = WindowFactory.CreateByContentsSize(control);
viewModel.InfoViewModel.EventEdited += (s, e) =>
{
EventEditModel eventEditModel = e.Event;
EventEditDTO eventEditDTO = Mapper.Map <EventEditModel, EventEditDTO>(eventEditModel);
using (IEventService service = factory.CreateEventService())
{
ServiceMessage serviceMessage = service.Update(eventEditDTO);
RaiseReceivedMessageEvent(serviceMessage);
if (serviceMessage.IsSuccessful)
{
Notify();
}
}
};
viewModel.EventParticipantViewModel.EventEdited += (s, e) =>
{
EventEditModel eventEditModel = e.Event;
EventEditDTO eventEditDTO = Mapper.Map <EventEditModel, EventEditDTO>(eventEditModel);
using (IEventService service = factory.CreateEventService())
{
ServiceMessage serviceMessage = service.UpdateParticipants(eventEditDTO);
RaiseReceivedMessageEvent(serviceMessage);
if (serviceMessage.IsSuccessful)
{
Notify();
}
}
};
window.Show();
}
public ActionResult Edit(int id, EventEditModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
if (model.EventID != id)
{
ModelState.AddModelError("", "ID Mismatch");
return(View(model));
}
if (_eventService.Value.UpdateEvent(model))
{
TempData["SaveResult"] = "Your event was updated";
return(RedirectToAction("Index"));
}
ModelState.AddModelError("", "Your event could not be updated.");
return(View(model));
}
public List <KeyValuePair <string, string> > Validate(EventEditModel model, CampaignSummaryModel parentCampaign)
{
var result = new List <KeyValuePair <string, string> >();
if (model.EndDateTime < model.StartDateTime)
{
result.Add(new KeyValuePair <string, string>(nameof(model.EndDateTime), "End date cannot be earlier than the start date"));
}
if (model.StartDateTime < parentCampaign.StartDate)
{
result.Add(new KeyValuePair <string, string>(nameof(model.StartDateTime), "Start date cannot be earlier than the campaign start date " + parentCampaign.StartDate.ToString("d")));
}
if (model.EndDateTime > parentCampaign.EndDate)
{
result.Add(new KeyValuePair <string, string>(nameof(model.EndDateTime), "End date cannot be later than the campaign end date " + parentCampaign.EndDate.ToString("d")));
}
return(result);
}
public List<KeyValuePair<string, string>> Validate(EventEditModel model, CampaignSummaryModel parentCampaign)
{
var result = new List<KeyValuePair<string, string>>();
if (model.EndDateTime < model.StartDateTime)
{
result.Add(new KeyValuePair<string, string>(nameof(model.EndDateTime), "End date cannot be earlier than the start date"));
}
if (model.StartDateTime < parentCampaign.StartDate)
{
result.Add(new KeyValuePair<string, string>(nameof(model.StartDateTime), "Start date cannot be earlier than the campaign start date " + parentCampaign.StartDate.ToString("d")));
}
if (model.EndDateTime > parentCampaign.EndDate)
{
result.Add(new KeyValuePair<string, string>(nameof(model.EndDateTime), "End date cannot be later than the campaign end date " + parentCampaign.EndDate.ToString("d")));
}
return result;
}
public async Task <IActionResult> Create(int campaignId)
{
var campaign = await _mediator.SendAsync(new CampaignSummaryQuery { CampaignId = campaignId });
if (campaign == null || !User.IsOrganizationAdmin(campaign.OrganizationId))
{
return(Unauthorized());
}
var campaignEvent = new EventEditModel
{
CampaignId = campaign.Id,
CampaignName = campaign.Name,
TimeZoneId = campaign.TimeZoneId,
OrganizationId = campaign.OrganizationId,
OrganizationName = campaign.OrganizationName,
StartDateTime = DateTime.Today.Date,
EndDateTime = DateTime.Today.Date
};
return(View("Edit", campaignEvent));
}
public async Task <IHttpActionResult> Edit(EventEditModel editModel)
{
if (!await _eventsService.CanEditAsync(editModel.Id))
{
return(StatusCode(System.Net.HttpStatusCode.Forbidden));
}
var cachedActivityMedias = _eventsService.Get(editModel.Id).MediaIds;
var activity = MapToEvent(editModel);
_eventsService.Save(activity);
_mediaHelper.DeleteMedia(cachedActivityMedias.Except(activity.MediaIds));
if (!_eventsService.IsActual(activity))
{
return(BadRequest("Event is not actual'"));
}
if (editModel.NotifyAllSubscribers)
{
var notificationType = NotificationTypeEnum.EventUpdated;
((INotifyableService)_eventsService).Notify(activity.Id, notificationType);
}
_activityTagsHelper.ReplaceTags(activity.Id, editModel.TagIdsData);
_reminderService.CreateIfNotExists(activity.Id, ReminderTypeEnum.OneDayBefore);
ResolveMentions(editModel.Description, activity);
var redirectUrl = _activityLinkService.GetLinks(activity.Id).Details;
ReloadFeed();
return(Ok(redirectUrl));
}
