public async Task <EventForDetailedDto> GetEvent(int id)
{
var dbEvent = await _context.Events.Include(e => e.EventParticipants.Select(u => u.User))
.Include(e => e.Posts.Select(p => p.Creator)).Include(e => e.Creator).FirstOrDefaultAsync(e => e.Id == id);
return(EventTranslator.ToEventForDetailedDto(dbEvent));
}
public void ShouldBatch(ProducerType producerType)
{
var d = new Disruptor <LongEvent>(() => new LongEvent(), 2048, TaskScheduler.Current, producerType, new SleepingWaitStrategy());
var handler1 = new ParallelEventHandler(1, 0);
var handler2 = new ParallelEventHandler(1, 1);
d.HandleEventsWith(handler1, handler2);
var buffer = d.Start();
IEventTranslator <LongEvent> translator = new EventTranslator <LongEvent>();
const int eventCount = 10000;
for (var i = 0; i < eventCount; i++)
{
buffer.PublishEvent(translator);
}
while (Volatile.Read(ref handler1.Processed) != eventCount - 1 ||
Volatile.Read(ref handler2.Processed) != eventCount - 1)
{
Thread.Sleep(1);
}
Assert.That(handler1.PublishedValue, Is.EqualTo((long)eventCount - 2));
Assert.That(handler1.EventCount, Is.EqualTo((long)eventCount / 2));
Assert.That(handler2.PublishedValue, Is.EqualTo((long)eventCount - 1));
Assert.That(handler2.EventCount, Is.EqualTo((long)eventCount / 2));
}
public async Task <EventForCreateDto> UploadImage(int id, IFormFile image)
{
var dbEvent = await _context.Events.FindAsync(id);
var uploadResult = await _cloudinaryService.UploadImage(image, "event-images", dbEvent.ImageId);
dbEvent.ImageId = uploadResult.PublicId;
dbEvent.ImageUrl = uploadResult.Uri.ToString();
await _context.SaveChangesAsync();
return(EventTranslator.ToEventForCreateDto(dbEvent));
}
public async Task <EventForDetailedDto> DeletePost(int id, int eventId)
{
var dbPost = await _context.Posts.FirstOrDefaultAsync(p => p.Id == id);
_context.Posts.Remove(dbPost);
await _context.SaveChangesAsync();
//return id;
var dbEvent = await _context.Events.Include(e => e.EventParticipants.Select(u => u.User))
.Include(p => p.Posts.Select(po => po.Creator)).Include(e => e.Creator).FirstOrDefaultAsync(e => e.Id == eventId);
return(EventTranslator.ToEventForDetailedDto(dbEvent));
}
public async Task <EventForUpdateDto> UpdateEvent(int id, EventForUpdateDto ev)
{
var dbEvent = await _context.Events.FindAsync(id);
dbEvent.Title = ev.Title;
dbEvent.Location = ev.Location;
dbEvent.Description = ev.Description;
dbEvent.StartDate = new DateTime(ev.StartDate.Year, ev.StartDate.Month,
ev.StartDate.Day, ev.StartTime.Hour, ev.StartTime.Minute, 0);
dbEvent.EndDate = new DateTime(ev.EndDate.Year, ev.EndDate.Month,
ev.EndDate.Day, ev.EndTime.Hour, ev.EndTime.Minute, 0);
var dbEventParticipants = await _context.EventParticipants.Where(e => e.EventId == id).ToListAsync();
var newEventParticipants = new List <EventParticipant>();
if (ev.Users != null)
{
foreach (var user in ev.Users)
{
if (!dbEventParticipants.Exists(ep => ep.EventId == id && ep.UserId == user.Id))
{
newEventParticipants.Add(new EventParticipant {
EventId = id, UserId = user.Id
});
}
}
}
_context.EventParticipants.AddRange(newEventParticipants);
await _context.SaveChangesAsync();
var attendees = new List <User>();
foreach (var newEp in newEventParticipants)
{
attendees.Add(_context.EventParticipants.Include(ep => ep.User).FirstOrDefault(ep =>
ep.UserId == newEp.UserId && ep.EventId == newEp.EventId).User);
}
_googleCalendarService.UpdateGoogleEvent(dbEvent, attendees);
return(EventTranslator.ToEventForUpdateDto(dbEvent));
}
public async Task <EventForDetailedDto> AddEventParticipantStatus(int eventId, int userId, string answer)
{
//Check if participant already exist and has answered to the event
var eventParticipant = await _context.EventParticipants
.FirstOrDefaultAsync(ep => ep.EventId == eventId && ep.UserId == userId);
if (eventParticipant == null)
{
//Add participants answer to db if not answered earlier
var newEp = new EventParticipant
{
EventId = eventId,
UserId = userId,
Status = answer
};
_context.EventParticipants.Add(newEp);
}
else
{
//Update participants answer if already answered
eventParticipant.Status = answer;
}
await _context.SaveChangesAsync();
//Update the participants status for the google calendar event
var updatedEp = await _context.EventParticipants.Include(ep => ep.User).Include(ep => ep.Event)
.FirstOrDefaultAsync(ep => ep.EventId == eventId && ep.UserId == userId);
_googleCalendarService.UpdateGoogleEventParticipantStatus(updatedEp);
var dbEvent = await _context.Events.Include(e => e.EventParticipants.Select(u => u.User))
.Include(e => e.Posts.Select(p => p.Creator)).Include(e => e.Creator).FirstOrDefaultAsync(e => e.Id == eventId);
return(EventTranslator.ToEventForDetailedDto(dbEvent));
}
public async Task <EventForCreateDto> CreateEvent(EventForCreateDto ev)
{
var newEvent = new Event()
{
Title = ev.Title,
Description = ev.Description,
Location = ev.Location,
StartDate = new DateTime(ev.StartDate.Year, ev.StartDate.Month,
ev.StartDate.Day, ev.StartTime.Hour, ev.StartTime.Minute, 0),
EndDate = new DateTime(ev.EndDate.Year, ev.EndDate.Month,
ev.EndDate.Day, ev.EndTime.Hour, ev.EndTime.Minute, 0),
CreateDate = ev.CreateDate,
CreatorId = ev.CreatorId
};
_context.Events.Add(newEvent);
var eventParticipants = new List <EventParticipant>()
{
new EventParticipant {
EventId = ev.Id, UserId = ev.CreatorId, Status = "accepted"
}
};
if (ev.Offices != null)
{
foreach (var office in ev.Offices)
{
var usersInOffice = await _context.Users.Include(u => u.Office)
.Where(u => u.OfficeId == office.Id && u.Id != ev.CreatorId && u.Name != "admin").ToListAsync();
eventParticipants.AddRange(usersInOffice.Select(u =>
new EventParticipant {
EventId = ev.Id, UserId = u.Id
}).ToList());
}
}
if (ev.Users != null)
{
foreach (var user in ev.Users)
{
//Add user to the eventParticipants list if it does not already exist
if (!eventParticipants.Exists(ep => ep.EventId == ev.Id && ep.UserId == user.Id))
{
eventParticipants.Add(new EventParticipant {
EventId = ev.Id, UserId = user.Id
});
}
}
}
_context.EventParticipants.AddRange(eventParticipants);
await _context.SaveChangesAsync();
var attendees = await _context.EventParticipants.Include(ep => ep.User)
.Where(ep => ep.EventId == newEvent.Id).Select(u => u.User).ToListAsync();
//Create a google calendar event and returns Google Event Id
var googleEventId = await _googleCalendarService.CreateGoogleEvent(newEvent, attendees);
newEvent.GoogleEventId = googleEventId;
await _context.SaveChangesAsync();
return(EventTranslator.ToEventForCreateDto(newEvent));
}
