private static EventEditViewModel BuildNewEventDetailsModel(EventEditViewModel existingEvent, DuplicateEventViewModel newEventDetails)
{
existingEvent.Id = 0;
existingEvent.Name = newEventDetails.Name;
existingEvent.Description = newEventDetails.Description;
existingEvent.StartDateTime = newEventDetails.StartDateTime;
existingEvent.EndDateTime = newEventDetails.EndDateTime;
return(existingEvent);
}
public async Task <IActionResult> Edit(EventEditViewModel eventEditViewModel, IFormFile fileUpload)
{
if (eventEditViewModel == null)
{
return(BadRequest());
}
var authorizableEvent = await _mediator.SendAsync(new AuthorizableEventQuery(eventEditViewModel.Id));
if (!await authorizableEvent.UserCanEdit())
{
return(new ForbidResult());
}
var campaign = await _mediator.SendAsync(new CampaignSummaryQuery { CampaignId = eventEditViewModel.CampaignId });
var errors = _eventEditViewModelValidator.Validate(eventEditViewModel, campaign);
errors.ForEach(e => ModelState.AddModelError(e.Key, e.Value));
if (ModelState.IsValid)
{
if (fileUpload != null)
{
if (!fileUpload.IsAcceptableImageContentType())
{
ModelState.AddModelError(nameof(eventEditViewModel.ImageUrl), "You must upload a valid image file for the logo (.jpg, .png, .gif)");
return(View(eventEditViewModel));
}
if (_imageSizeValidator != null && fileUpload.Length > _imageSizeValidator.FileSizeInBytes)
{
ModelState.AddModelError(nameof(eventEditViewModel.ImageUrl), $"File size must be less than {_imageSizeValidator.BytesToMb():#,##0.00}MB!");
return(View("Edit", eventEditViewModel));
}
var existingImageUrl = eventEditViewModel.ImageUrl;
var newImageUrl = await _imageService.UploadEventImageAsync(campaign.OrganizationId, eventEditViewModel.Id, fileUpload);
if (!string.IsNullOrEmpty(newImageUrl))
{
eventEditViewModel.ImageUrl = newImageUrl;
if (existingImageUrl != null && existingImageUrl != newImageUrl)
{
await _imageService.DeleteImageAsync(existingImageUrl);
}
}
}
var id = await _mediator.SendAsync(new EditEventCommand { Event = eventEditViewModel });
return(RedirectToAction(nameof(Details), new { area = AreaNames.Admin, id = id }));
}
return(View(eventEditViewModel));
}
public IActionResult Create()
{
var viewModel = new EventEditViewModel()
{
Title = "Add New Event",
SelectVenues = _venueRepository.GetSelectListItems(),
SelectedVenue = 1
};
return(View(viewModel));
}
public async Task <IActionResult> Edit(EventEditViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
await _EventsService.UpdateEventAsync(model);
return(RedirectToAction("List"));
}
public async Task <IActionResult> Create(int campaignId, EventEditViewModel eventEditViewModel, IFormFile fileUpload)
{
var campaign = await _mediator.SendAsync(new CampaignSummaryQuery { CampaignId = campaignId });
var authorizableCampaign = await _mediator.SendAsync(new AuthorizableCampaignQuery(campaign.Id, campaign.OrganizationId));
if (!await authorizableCampaign.UserCanManageChildObjects())
{
return(new ForbidResult());
}
var errors = _eventEditViewModelValidator.Validate(eventEditViewModel, 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(eventEditViewModel))
{
if (fileUpload != null)
{
if (!fileUpload.IsAcceptableImageContentType())
{
ModelState.AddModelError(nameof(eventEditViewModel.ImageUrl), "You must upload a valid image file for the logo (.jpg, .png, .gif)");
return(View("Edit", eventEditViewModel));
}
if (_imageSizeValidator != null && fileUpload.Length > _imageSizeValidator.FileSizeInBytes)
{
ModelState.AddModelError(nameof(eventEditViewModel.ImageUrl), $"File size must be less than {_imageSizeValidator.BytesToMb():#,##0.00}MB!");
return(View("Edit", eventEditViewModel));
}
}
eventEditViewModel.OrganizationId = campaign.OrganizationId;
var id = await _mediator.SendAsync(new EditEventCommand { Event = eventEditViewModel });
if (fileUpload != null)
{
// resave now that event has the ImageUrl
eventEditViewModel.Id = id;
eventEditViewModel.ImageUrl = await _imageService.UploadEventImageAsync(campaign.OrganizationId, id, fileUpload);
await _mediator.SendAsync(new EditEventCommand { Event = eventEditViewModel });
}
return(RedirectToAction(nameof(Details), new { area = AreaNames.Admin, id = id }));
}
return(View("Edit", eventEditViewModel));
}
public async Task <IActionResult> Edit(EventEditViewModel eventEditViewModel, IFormFile fileUpload)
{
if (eventEditViewModel == null)
{
return(BadRequest());
}
var organizationId = await _mediator.SendAsync(new ManagingOrganizationIdByEventIdQuery { EventId = eventEditViewModel.Id });
if (!User.IsOrganizationAdmin(organizationId))
{
return(Unauthorized());
}
var campaign = await _mediator.SendAsync(new CampaignSummaryQuery { CampaignId = eventEditViewModel.CampaignId });
var errors = _eventEditViewModelValidator.Validate(eventEditViewModel, campaign);
errors.ForEach(e => ModelState.AddModelError(e.Key, e.Value));
if (ModelState.IsValid)
{
if (fileUpload != null)
{
if (fileUpload.IsAcceptableImageContentType())
{
var existingImageUrl = eventEditViewModel.ImageUrl;
var newImageUrl = await _imageService.UploadEventImageAsync(campaign.OrganizationId, campaign.Id, fileUpload);
if (!string.IsNullOrEmpty(newImageUrl))
{
eventEditViewModel.ImageUrl = newImageUrl;
if (existingImageUrl != null)
{
await _imageService.DeleteImageAsync(existingImageUrl);
}
}
}
else
{
ModelState.AddModelError("ImageUrl", "You must upload a valid image file for the logo (.jpg, .png, .gif)");
return(View(eventEditViewModel));
}
}
var id = await _mediator.SendAsync(new EditEventCommand { Event = eventEditViewModel });
return(RedirectToAction(nameof(Details), new { area = "Admin", id = id }));
}
return(View(eventEditViewModel));
}
public async Task <IActionResult> Edit(EventEditViewModel model)
{
if (!this.ModelState.IsValid)
{
return(this.RedirectToAction(nameof(Edit)));
}
var parsedEvent = this.mapper.Map <Event>(model);
await this.eventService.EditEvent(parsedEvent);
return(RedirectToAction(nameof(EventList)));
}
public IActionResult SaveEvent(EventEditViewModel model, string returnUrl = null)
{
ViewBag.ReturnUrl = returnUrl;
if (model.Date.Date < DateTime.Now.Date)
{
ModelState.AddModelError("Date", "Please provide an actual date");
}
if (string.IsNullOrWhiteSpace(model.Name))
{
ModelState.AddModelError("Name", "Name is required");
}
if (!ModelState.IsValid)
{
model = _eventService.ActualizeModel(model);
return(View(model.Id.HasValue ? "EditEvent" : "AddEvent", model));
}
model.OrganizerId = Guid.Parse(User.FindFirst("userId").Value);
var ok = true;
if (model.Id.HasValue)
{
ok = _eventService.UpdateEvent(model);
if (ok)
{
_logger.Here().Information("Event updated: {@Event}", model);
}
}
else
{
_eventService.AddEvent(model);
_logger.Here().Information("New event created: {@Event}", model);
}
if (!ok)
{
return(NotFound());
}
if (string.IsNullOrEmpty(returnUrl))
{
return(RedirectToAction("Events"));
}
return(Redirect(returnUrl));
}
public bool UpdateEvent(EventEditViewModel model)
{
var entity = _unitOfWork.EventRepository.Get(model.Id.Value);
if (entity == null)
{
return(false);
}
entity = BuildEntityFromModel(model, entity);
_unitOfWork.Commit();
return(true);
}
public ActionResult Edit(int id)
{
var eventEditModel = _context.Events.FirstOrDefault(x => x.Id == id);
EventEditViewModel model = new EventEditViewModel
{
Id = eventEditModel.Id,
Date = eventEditModel.Date,
Description = eventEditModel.Description,
Image = eventEditModel.Image,
Title = eventEditModel.Title
};
return(View(model));
}
public async Task <IActionResult> Edit(EventEditViewModel model)
{
EventDTO eventDTO = _mapper.Map <EventEditViewModel, EventDTO>(model);
var result = model.Id == 0 ?
await _eventService.CreateEventAsync(eventDTO) :
await _eventService.EditEventAsync(eventDTO);
if (result.Succedeed)
{
return(Ok());
}
return(BadRequest());
}
public IActionResult Edit(long id, [Bind("Title,Description,Date,RecordId,ImagePath,File")] EventEditViewModel vm)
{
if (id != vm.RecordId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
var evt = this._context.Events.FirstOrDefault(e => e.RecordId == vm.RecordId);
evt.Date = vm.Date;
evt.Description = vm.Description;
evt.Title = vm.Title;
if (vm.File != null)
{
var file = vm.File;
var parsedContentDisposition =
ContentDispositionHeaderValue.Parse(file.ContentDisposition);
var filename = Path.Combine(_hostingEnvironment.WebRootPath, "images", "events",
parsedContentDisposition.FileName.Trim('"'));
using (var stream = System.IO.File.OpenWrite(filename))
{
file.CopyTo(stream);
}
evt.ImagePath = parsedContentDisposition.FileName.Trim('"');
}
_context.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!EventExists(vm.RecordId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(vm));
}
public static EventEditDto ToDto(this EventEditViewModel source, string fileName)
{
return(new EventEditDto
{
Title = source.Title,
Date = source.Date.ToDateTime(),
Description = source.Description,
EndDate = source.EndDate.ToDateTime(),
Id = source.Id,
MultiDay = source.MultiDay,
PrimaryPicture = fileName,
StartDate = source.StartDate.ToDateTime(),
Time = source.Time
});
}
public ActionResult Edit(EventEditViewModel model)
{
if (ModelState.IsValid)
{
var input = MapperManager.Map <EventInputDto>(model);
var result = _eventManageService.EditEvent(input);
if (result.Id > 0)
{
return(RedirectToAction("Index", "Event"));
}
}
return(View(model));
}
private Event BuildEntityFromModel(EventEditViewModel model, Event entity = null)
{
entity ??= new Event();
entity.Name = model.Name;
entity.Description = !string.IsNullOrWhiteSpace(model.Description) ? model.Description : null;
entity.DateTime = model.Date + model.Time;
entity.CreateTime = DateTime.Now;
entity.EventCategoryId = model.CategoryId;
entity.LocationId = model.LocationId;
entity.Photo = !string.IsNullOrWhiteSpace(model.Photo) ? model.Photo : null;
entity.OrganizerId = model.OrganizerId;
return(entity);
}
public ActionResult Edit(int?Id)
{
EventEditViewModel viewModel = new EventEditViewModel();
using (SussexDBEntities db = new SussexDBEntities())
{
viewModel.EventCategories = db.Categories.ToList();
if (Id != null)
{
viewModel.Event = db.Events.Where(w => w.EventId == Id).FirstOrDefault();
viewModel.MeetingSchedules = db.MeetingSchedules.Where(w => w.EventId == Id).ToList();
viewModel.SelectedEventCategories = db.EventCategories.Where(w => w.EventId == Id).Select(s => s.Category).ToList();
}
}
return(View(viewModel));
}
public IActionResult Edit(int id)
{
EventEditViewModel evm = new EventEditViewModel();
var evt = DB.Events.Where(ev => ev.EventId == id)
.Include(x => x.Players).ThenInclude(c => c.User).ThenInclude(y => y.Gender)
.Include(x => x.Sport)
.Include(x => x.Gender)
.Include(x => x.SkillLevel)
.Include(x => x.Creator);
evm.Sports = DB.Sports.ToList();
evm.SkillLevels = DB.SkillLevels.ToList();
evm.PreferredGenders = DB.PreferredGenders.ToList();
evm.Event = evt.FirstOrDefault();
return(View(evm));
}
public ActionResult Edit(EventEditViewModel model)
{
if (!this.ModelState.IsValid)
{
return this.Edit(model.Id);
}
var eventToEdit = this.eventsServices.GetById(model.Id);
eventToEdit.Name = model.Name;
eventToEdit.Description = model.Description;
eventToEdit.StartDate = model.StartDate;
this.eventsServices.Update(eventToEdit);
return this.Redirect("/Events/" + this.provider.EncodeId(model.Id));
}
public ActionResult Edit(EventEditViewModel model)
{
if (ModelState.IsValid)
{
var edit = _context.Events.FirstOrDefault(x => x.Id == model.Id);
edit.Image = model.Image;
edit.Title = model.Title;
edit.Date = model.Date;
edit.Description = edit.Description;
_context.SaveChanges();
return(RedirectToAction("ListEvents", "Planner"));
}
else
{
return(View());
}
}
public void ReturnCorrectErrorWhenEndDateTimeIsLessThanStartDateTime()
{
var validator = new EventEditViewModelValidator();
var parentCampaign = new CampaignSummaryViewModel {
EndDate = new DateTimeOffset(new DateTime(1999, 2, 1))
};
var model = new EventEditViewModel
{
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 async Task <IActionResult> Create(int campaignId, EventEditViewModel eventEditViewModel, IFormFile fileUpload)
{
var campaign = await _mediator.SendAsync(new CampaignSummaryQuery { CampaignId = campaignId });
if (campaign == null || !User.IsOrganizationAdmin(campaign.OrganizationId))
{
return(Unauthorized());
}
var errors = _eventEditViewModelValidator.Validate(eventEditViewModel, 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(eventEditViewModel))
{
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", eventEditViewModel));
}
}
eventEditViewModel.OrganizationId = campaign.OrganizationId;
var id = await _mediator.SendAsync(new EditEventCommand { Event = eventEditViewModel });
if (fileUpload != null)
{
// resave now that event has the ImageUrl
eventEditViewModel.Id = id;
eventEditViewModel.ImageUrl = await _imageService.UploadEventImageAsync(campaign.OrganizationId, id, fileUpload);
await _mediator.SendAsync(new EditEventCommand { Event = eventEditViewModel });
}
return(RedirectToAction(nameof(Details), new { area = "Admin", id = id }));
}
return(View("Edit", eventEditViewModel));
}
public IActionResult Edit(EventEditViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
string uniqueFileName = null;
if (viewModel.Photos != null && viewModel.Photos.Count > 0)
{
foreach (IFormFile photo in viewModel.Photos)
{
var extension = Path.GetExtension(photo.FileName).ToLower();
if (extension == ".jpg" || extension == ".jpeg" || extension == ".png")
{
string uploadsFolder = Path.Combine(_hostingEnvironment.WebRootPath, "images");
uniqueFileName = Guid.NewGuid().ToString() + "_" + photo.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
photo.CopyTo(new FileStream(filePath, FileMode.Create));
}
else
{
throw new Exception("Dosya türü .JPG , .JPEG veya .PNG olmalıdır..");
}
}
}
Event editedEvent = new Event()
{
Id = viewModel.Id,
Name = viewModel.Name,
Description = viewModel.Description,
EditorContent = viewModel.EditorContent,
Slug = viewModel.Slug,
ImageUrl = uniqueFileName,
StatusId = viewModel.StatusId,
Location = viewModel.Location,
StartDate = viewModel.StartDate,
EndDate = viewModel.EndDate,
CampusId = viewModel.CampusId
};
_eventService.Edit(editedEvent);
return(RedirectToAction("Index"));
}
public ActionResult Edit(int Page_ID, int Event_ID, bool?Return_Home)
{
if (Return_Home != null)
{
ViewBag.Return_Home = true;
Page page = db.Pages.Find(Page_ID);
ViewBag.Page_Url = page.URL;
}
Event ev = db.Events.Find(Event_ID);
if (ev == null)
{
return(HttpNotFound());
}
EventEditViewModel viewMod = new EventEditViewModel(Page_ID, ev);
return(View(viewMod));
}
public ActionResult Edit(long id)
{
var theEvent = _eventService.FindById(id);
if (theEvent == null || !theEvent.Creator.Id.Equals(User.Identity.GetUserId()))
{
return(RedirectToAction("Index", "EventFeed"));
}
var model = new EventEditViewModel
{
Event = theEvent,
DurationHours = theEvent.EventTime == null ? 0 : theEvent.EventTime.DurationInMinutes / 60,
DurationMinutes = theEvent.EventTime == null ? 0 : theEvent.EventTime.DurationInMinutes % 60
};
return(View(model));
}
public async Task UpdateEventAsync(EventEditViewModel model)
{
var _event = await GetEventByIdAsync(model.Id);
_event.Address1 = model.Address1;
_event.Address2 = model.Address2;
_event.City = model.City;
_event.State = model.State;
_event.Location = model.Location;
_event.Zip = model.Zip;
_event.Title = model.EventTitle;
_event.Contactid = model.ContactId;
_event.Description = model.Description;
_event.EventEnd = model.EventEnd;
_event.EventStart = model.EventStart;
await _EventsRepository.SaveChangesAsync();
}
public async Task <IActionResult> Edit(int id, string returnUrl)
{
var result = await _mediator.Send(new GetEventEditQuery { Id = id });
if (result == null)
{
return(NotFound());
}
var eventTypeResult = await _mediator.Send(new GetEventTypeListQuery());
var eventSeriesResult = await _mediator.Send(new GetEventSeriesesListQuery());
EventEditViewModel vm = new EventEditViewModel(result, eventTypeResult.EventTypes.ToList(), eventSeriesResult.EventSerieses.ToList());
ViewData["Title"] = "Edit Event";
ViewBag.ReturnUrl = returnUrl;
return(View(vm));
}
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 EventEditViewModel
{
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 void Create_ReturnsEventEditViewModel_WhenModelIsInvalid()
{
//Arrange
var mockEventEditViewModel = new EventEditViewModel {
Id = 20, EventName = "Test Event"
};
_homeController.ModelState.AddModelError("EventDate", "Required");
var mockEvent = Mock.Of <Event>();
//Act
var result = _homeController.Create(mockEventEditViewModel);
//Assert
Assert.NotNull(result);
var viewResult = Assert.IsType <ViewResult>(result);
Assert.Equal(mockEventEditViewModel, viewResult.ViewData.Model);
_mockEventRepository.Verify(evnt => evnt.Add(mockEvent), Times.Never);
}
public void RetrunCorrectErrorWhenModelsEndDateTimeIsGreaterThanParentCampaignsEndDate()
{
var validator = new EventEditViewModelValidator();
var parentCampaign = new CampaignSummaryViewModel
{
StartDate = new DateTimeOffset(new DateTime(2000, 1, 1)),
EndDate = new DateTimeOffset(new DateTime(2001, 1, 1))
};
var model = new EventEditViewModel
{
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 ActionResult Edit(int id)
{
try
{
if (User.IsInRole(AppEnum.RoleEnum.User.ToString()))
{
return(new HttpNotFoundResult());
}
var eventEditData = db.EventDetails.FirstOrDefault(x => x.EventId == id);
var eventEditViewModels = new EventEditViewModel();
var eventType = db.EventTypes.ToList();
eventEditViewModels.EventTypeDropDownVm = new EventTypeDropDownViewModel()
{
EventTypes = eventType
};
var eventVenue = db.EventVenues.ToList();
eventEditViewModels.EventVenueDropDownVm = new EventVenueDropDownViewModel()
{
EventVenues = eventVenue
};
if (eventEditData != null)
{
eventEditViewModels.EventId = eventEditData.EventId;
eventEditViewModels.EventTitle = eventEditData.EventTitle;
eventEditViewModels.EventStarTime = eventEditData.EventStarTime;
eventEditViewModels.EventEndTime = eventEditData.EventEndTime;
eventEditViewModels.EventMaxBookingTime = eventEditData.EventMaxBookingTime;
eventEditViewModels.EventTypeId = eventEditData.EventTypeId;
eventEditViewModels.EventVenueId = eventEditData.EventVenueId;
eventEditViewModels.IsDeleted = eventEditData.IsDeleted;
}
return(View(eventEditViewModels));
}
catch (Exception)
{
return(View("Error"));
}
}
public ActionResult Edit(EventEditViewModel eventEditViewModel)
{
DoEditEventValidation(eventEditViewModel.Event);
if (ModelState.IsValid)
{
unitOfWork.context.Events.Attach(eventEditViewModel.Event);
unitOfWork.context.Entry(eventEditViewModel.Event).Collection(m => m.EventCategories).Load();
int[] selectedCategories = eventEditViewModel.Categories.Where(x => x.Selected).Select<SelectListItem, int>(x => Convert.ToInt32(x.Value.ToString())).ToArray<int>();
eventEditViewModel.Event.EventCategories.Clear();
eventEditViewModel.Event.EventCategories = unitOfWork.EventCategoryRepository.Get(x => selectedCategories.Contains(x.CategoryID)).ToList();
unitOfWork.EventRepository.Update(eventEditViewModel.Event);
unitOfWork.Save();
return RedirectToAction("Index");
}
return View(EventEditorSetupEdit(eventEditViewModel));
}
public void Create_RedirectsToActionIndex_WhenModelIsValid()
{
//Arrange
var mockEventEditViewModel = new EventEditViewModel()
{
Id = 20,
EventName = "Test Event Name",
EventDate = DateTime.Parse("2018-08-14"),
SelectedVenue = 1
};
//Act
var result = _homeController.Create(mockEventEditViewModel);
//Assert
Assert.NotNull(result);
var redirectResult = Assert.IsType <RedirectToActionResult>(result);
Assert.Null(redirectResult.ControllerName);
Assert.Equal("Index", redirectResult.ActionName);
}
public ActionResult Edit(int eventID)
{
EventEditViewModel eventEditViewModel = new EventEditViewModel();
eventEditViewModel.Event = unitOfWork.EventRepository.GetByID(eventID);
return View(EventEditorSetupEdit(eventEditViewModel));
}
private EventEditViewModel EventEditorSetupEdit(EventEditViewModel eventEditViewModel)
{
eventEditViewModel.ReoccurrenceFrames = unitOfWork.EventReoccurrenceFrameRepository.ReoccurrenceFrameKeyValueList();
eventEditViewModel.Categories = unitOfWork.EventCategoryRepository.CategoriesSelectList(eventEditViewModel.Event.EventCategories);
return eventEditViewModel;
}
