public void CheckIfAttendOptionsAllowedToUpdate(EditEventDto eventDto, Event eventToUpdate)
{
if ((eventDto.AllowMaybeGoing != eventToUpdate.AllowMaybeGoing || eventDto.AllowNotGoing != eventToUpdate.AllowNotGoing) && eventToUpdate.EventParticipants.Count > 0)
{
throw new EventException(PremiumErrorCodes.EventAttendTypeCannotBeChangedIfParticipantsJoined);
}
}
private void UpdateEventOptions(EditEventDto editedEvent, Event @event)
{
foreach (var editedOption in editedEvent.EditedOptions)
{
var option = @event.EventOptions.Single(o => o.Id == editedOption.Id);
option.Option = editedOption.Option;
}
var removedOptions = @event.EventOptions.Where(o => !editedEvent.EditedOptions.Select(x => x.Id).Contains(o.Id)).ToList();
foreach (var option in removedOptions)
{
_eventOptionsDbSet.Remove(option);
}
foreach (var newOption in editedEvent.NewOptions)
{
var option = new EventOption
{
Option = newOption.Option,
Rule = newOption.Rule,
EventId = editedEvent.Id,
Created = DateTime.UtcNow,
CreatedBy = editedEvent.UserId,
Modified = DateTime.UtcNow,
ModifiedBy = editedEvent.UserId
};
_eventOptionsDbSet.Add(option);
}
}
public IHttpActionResult EditEvent(EditEventDto dto)
{
if (dto == null)
{
return(BadRequest());
}
var e = db.Events.Find(dto.Id);
if (e == null)
{
return(NotFound());
}
dto.Edit(ref e);
db.SaveChanges();
return(Ok());
}
public async Task UpdateEventAsync(EditEventDto eventDto)
{
var eventToUpdate = await _eventsDbSet
.Include(e => e.EventOptions)
.Include(e => e.EventParticipants)
.FirstOrDefaultAsync(e => e.Id == eventDto.Id && e.OrganizationId == eventDto.OrganizationId);
var totalOptionsProvided = eventDto.NewOptions.Count() + eventDto.EditedOptions.Count();
eventDto.MaxOptions = FindOutMaxChoices(totalOptionsProvided, eventDto.MaxOptions);
eventDto.RegistrationDeadlineDate = SetRegistrationDeadline(eventDto);
var hasPermission = await _permissionService.UserHasPermissionAsync(eventDto, AdministrationPermissions.Event);
_eventValidationService.CheckIfEventExists(eventToUpdate);
if (eventToUpdate == null)
{
return;
}
_eventValidationService.CheckIfUserHasPermission(eventDto.UserId, eventToUpdate.ResponsibleUserId, hasPermission);
_eventValidationService.CheckIfUserHasPermissionToPin(eventDto.IsPinned, eventToUpdate.IsPinned, hasPermission);
_eventValidationService.CheckIfCreatingEventHasInsufficientOptions(eventDto.MaxOptions, totalOptionsProvided);
_eventValidationService.CheckIfCreatingEventHasNoChoices(eventDto.MaxOptions, totalOptionsProvided);
_eventValidationService.CheckIfAttendOptionsAllowedToUpdate(eventDto, eventToUpdate);
await ValidateEvent(eventDto);
if (eventDto.ResetParticipantList)
{
await _eventParticipationService.ResetAttendeesAsync(eventDto.Id, eventDto);
}
await UpdateWallAsync(eventToUpdate, eventDto);
UpdateEventInfo(eventDto, eventToUpdate);
UpdateEventOptions(eventDto, eventToUpdate);
await _uow.SaveChangesAsync(false);
eventToUpdate.Description = _markdownConverter.ConvertToHtml(eventToUpdate.Description);
}
public void Should_Return_No_Permission_Exception_While_Updating_Event()
{
MockPermissionService(_permissionService);
MockUsers();
MockEventTypes();
var eventsGuids = MockEventsListTest();
var newEvent = new EditEventDto
{
Id = eventsGuids[0],
UserId = "2",
ResetParticipantList = false,
EndDate = DateTime.UtcNow.AddHours(3),
StartDate = DateTime.UtcNow.AddHours(2),
Name = "Name",
TypeId = 1,
ImageName = "qwer",
Recurrence = EventRecurrenceOptions.EveryDay,
MaxOptions = 0,
MaxParticipants = 1,
OrganizationId = 2,
ResponsibleUserId = "1",
Location = "place",
NewOptions = new List <NewEventOptionDto>(),
EditedOptions = new List <EventOptionDto>
{
new EventOptionDto
{
Id = 1,
Option = "edited1"
},
new EventOptionDto
{
Id = 2,
Option = "edited2"
}
}
};
var ex = Assert.ThrowsAsync <EventException>(async() => await _eventService.UpdateEventAsync(newEvent));
Assert.That(PremiumErrorCodes.EventDontHavePermissionCode, Is.EqualTo(ex.Message));
}
public EditEventDto EditEvent(EditEventDto dto)
{
var eventToEdit = _context.Events.SingleOrDefault(e => e.EventId == dto.EventId);
eventToEdit.Name = dto.Name;
eventToEdit.Street = dto.Description;
eventToEdit.Date = dto.Date;
eventToEdit.Description = dto.Description;
eventToEdit.AudienceKey = dto.AudienceKey;
eventToEdit.City = dto.City;
if (dto.Image != null)
{
ImageFileHelper.SaveFile(dto.Image, out var imageFileName);
eventToEdit.ImageFilename = imageFileName;
}
_context.SaveChanges();
return(_mapper.Map <Domain.Entity.Event, EditEventDto>(eventToEdit));
}
private async Task UpdateWallAsync(Event currentEvent, EditEventDto updatedEvent)
{
var updateWallDto = new UpdateWallDto
{
Id = currentEvent.WallId,
Description = updatedEvent.Description,
Logo = updatedEvent.ImageName,
Name = updatedEvent.Name,
OrganizationId = updatedEvent.OrganizationId,
UserId = updatedEvent.UserId
};
await _wallService.UpdateWallAsync(updateWallDto);
var responsibleUserChanged = currentEvent.ResponsibleUserId != updatedEvent.ResponsibleUserId;
var currentHostIsParticipating = currentEvent.EventParticipants.Any(x => x.ApplicationUserId == currentEvent.ResponsibleUserId);
var newHostIsParticipating = currentEvent.EventParticipants.Any(p => p.ApplicationUserId == updatedEvent.ResponsibleUserId);
if (!responsibleUserChanged)
{
return;
}
await _wallService.RemoveModeratorAsync(currentEvent.WallId, currentEvent.ResponsibleUserId, updatedEvent);
await _wallService.AddModeratorAsync(currentEvent.WallId, updatedEvent.ResponsibleUserId, updatedEvent);
if (!newHostIsParticipating)
{
await _wallService.JoinOrLeaveWallAsync(currentEvent.WallId, updatedEvent.ResponsibleUserId, updatedEvent.ResponsibleUserId, updatedEvent.OrganizationId, true);
}
if (!currentHostIsParticipating)
{
await _wallService.JoinOrLeaveWallAsync(currentEvent.WallId, currentEvent.ResponsibleUserId, currentEvent.ResponsibleUserId, updatedEvent.OrganizationId, true);
}
}
public EditEventDto EditEvent(EditEventDto dto)
{
return(_eventRepo.EditEvent(dto));
}
public async Task Should_Return_Updated_Event()
{
MockPermissionService(_permissionService);
MockUsers();
MockEventTypes();
var eventsGuids = MockEventsListTest();
MockEventOptions();
var newEvent = new EditEventDto
{
Id = eventsGuids[0],
UserId = "1",
ResetParticipantList = false,
EndDate = DateTime.UtcNow.AddHours(3),
StartDate = DateTime.UtcNow.AddHours(2),
Name = "Name",
TypeId = 1,
ImageName = "qwer",
Offices = new EventOfficesDto {
OfficeNames = new List <string> {
"office"
}
},
Recurrence = EventRecurrenceOptions.EveryDay,
MaxOptions = 1,
MaxParticipants = 1,
OrganizationId = 2,
ResponsibleUserId = "1",
Location = "place",
NewOptions = new List <NewEventOptionDto>
{
new NewEventOptionDto
{
Option = "Type1"
},
new NewEventOptionDto
{
Option = "Type2"
}
},
EditedOptions = new List <EventOptionDto>
{
new EventOptionDto
{
Id = 1,
Option = "Edited1"
},
new EventOptionDto
{
Id = 2,
Option = "Edited2"
}
}
};
await _eventService.UpdateEventAsync(newEvent);
_eventOptionsDbSet.Received(0).Remove(Arg.Any <EventOption>());
_eventOptionsDbSet.Received(2).Add(Arg.Any <EventOption>());
await _uow.Received(1).SaveChangesAsync(false);
}
public IActionResult EditEvent([FromForm] EditEventDto dto)
{
_eventService.EditEvent(dto);
return(Ok(dto));
}
