private IEnumerable<Event> GetEvents(string sql, params object[] parameters)
{
using (var db = new Database(_settings))
{
var mapper = new EventMapper();
return db.Query<Event>(mapper.Types, mapper.Map, sql, parameters);
}
}
public async Task <JsonResult> GetEventById([Required] Guid?eventId)
{
var eventRequest = await _calendarManager.GetEventByIdAsync(eventId);
return(Json(EventMapper.Map(eventRequest), _serializeSettings));
}
/**
* @param applianceEventMapper
*/
public void addToChain(EventMapper applianceEventMapper)
{
//Add this to a queue
mappers.offer(applianceEventMapper);
}
public async Task <JsonResult> GetAllEventsOrganizedByMe()
{
var eventRequest = await _calendarManager.GetAllEventsOrganizedByMeAsync();
return(Json(EventMapper.MapWithHelpers(eventRequest), _serializeSettings));
}
public async Task <JsonResult> GetMyEvents([Required] DateTime startDate, [Required] DateTime endDate)
{
var eventRequest = await _calendarManager.GetMyEventsAsync(startDate, endDate);
return(Json(EventMapper.MapWithHelpers(eventRequest), _serializeSettings));
}
public async Task <List <Event> > SearchByCategory(string search, int type)
{
var list = new List <IEnumerable <DAL.App.DTO.Event> >();
switch (type)
{
case 1:
return((await Uow.Event.FindByEventNameSearch(search)).Select(item => EventMapper.MapFromDAL(item)).ToList());
break;
case 2:
list = await Uow.Event.FindByAdministrativeUnitSearch(search);
break;
case 3:
list = await Uow.Event.FindByEventTypeSearch(search);
break;
case 4:
list = await Uow.Event.FindByLocationSearch(search);
break;
case 5:
list = await Uow.Event.FindByTargetAudienceSearch(search);
break;
case 6:
list = await Uow.Event.FindByLocationSearch(search);
break;
case 7:
list = await Uow.Event.FindByOrganizationSearch(search);
break;
case 8:
list = await Uow.Event.FindBySponsorSearch(search);
break;
case 9:
list = await Uow.Event.FindByPerformerSearch(search);
break;
}
var union = new List <DAL.App.DTO.Event>();
foreach (var t in list)
{
union = new List <DAL.App.DTO.Event>(union.Union(t, new EventComparer()));
}
return(union.Select(item => EventMapper.MapFromDAL(item)).ToList());
}
public override Event Update(Event entity)
{
return(EventMapper.MapFromDAL(ServiceRepository.Update(EventMapper.MapFromBLL(entity))));
}
public async Task <BLL.App.DTO.Event> FindForUserAsync(int id, int userId)
{
return(EventMapper.MapFromDAL(await Uow.Event.FindForUserAsync(id, userId)));
}
public async Task <List <BLL.App.DTO.Event> > AllForUserAsync(int userId)
{
return((await Uow.Event.AllForUserAsync(userId)).Select(e => EventMapper.MapFromDAL(e)).ToList());
}
public async Task <List <Event> > AllPastAsync()
{
return((await Uow.Event.AllPastAsync()).Select(e => EventMapper.MapFromDAL(e)).ToList());
}
public EventController(EventRepository eventRepository, EventMapper eventMapper)
{
_eventRepository = eventRepository;
_eventMapper = eventMapper;
}
/// <summary>
/// Register events
/// </summary>
/// <param name="serviceCollection"></param>
/// <returns></returns>
public static CalendarServiceCollection RegisterSyncOnExternalCalendars(this CalendarServiceCollection serviceCollection)
{
//On event created
CalendarEvents.SystemCalendarEvents.OnEventCreated += async(sender, args) =>
{
var calendarManager = IoC.Resolve <ICalendarManager>();
var userSettingsService = IoC.Resolve <ICalendarUserSettingsService>();
var evtRequest = await calendarManager.GetEventByIdAsync(args.EventId);
if (!evtRequest.IsSuccess)
{
return;
}
var evt = evtRequest.Result;
var factory = new ExternalCalendarProviderFactory();
var providers = factory.GetProviders();
foreach (var provider in providers)
{
var isProviderEnabledForUser = await userSettingsService.IsProviderEnabledAsync(evt.Organizer, provider);
if (!isProviderEnabledForUser.IsSuccess)
{
continue;
}
var providerService = factory.CreateService(provider);
var authRequest = await providerService.AuthorizeAsync(evt.Organizer);
if (!authRequest.IsSuccess)
{
continue;
}
var syncResult = await providerService.PushEventAsync(EventMapper.Map(evt));
if (!syncResult.IsSuccess)
{
Debug.WriteLine(syncResult.Errors);
}
}
await calendarManager.SetEventSyncState(evt.Id, true);
};
//On event update
CalendarEvents.SystemCalendarEvents.OnEventUpdated += async(sender, args) =>
{
var calendarManager = IoC.Resolve <ICalendarManager>();
var userSettingsService = IoC.Resolve <ICalendarUserSettingsService>();
var evtRequest = await calendarManager.GetEventByIdAsync(args.EventId);
if (!evtRequest.IsSuccess)
{
return;
}
var evt = evtRequest.Result;
var factory = new ExternalCalendarProviderFactory();
var providers = factory.GetProviders();
foreach (var provider in providers)
{
var isProviderEnabledForUser = await userSettingsService.IsProviderEnabledAsync(evt.Organizer, provider);
if (!isProviderEnabledForUser.IsSuccess)
{
continue;
}
var providerService = factory.CreateService(provider);
var authRequest = await providerService.AuthorizeAsync(evt.Organizer);
if (!authRequest.IsSuccess)
{
continue;
}
if (!evt.Synced)
{
await providerService.PushEventAsync(EventMapper.Map(evt));
}
else
{
var attrRequest = await userSettingsService.GetEventAttributeAsync(evt.Id, $"{provider}_evtId");
if (attrRequest.IsSuccess)
{
var providerEventId = attrRequest.Result;
var syncResult = await providerService.UpdateEventAsync(EventMapper.Map(evt), providerEventId);
if (!syncResult.IsSuccess)
{
Debug.WriteLine(syncResult.Errors);
}
}
else
{
await providerService.PushEventAsync(EventMapper.Map(evt));
}
}
}
if (!evt.Synced)
{
await calendarManager.SetEventSyncState(evt.Id, true);
}
};
//On delete Event
CalendarEvents.SystemCalendarEvents.OnEventDeleted += async(sender, args) =>
{
var calendarManager = IoC.Resolve <ICalendarManager>();
var userSettingsService = IoC.Resolve <ICalendarUserSettingsService>();
var evtRequest = await calendarManager.GetEventByIdAsync(args.EventId);
if (!evtRequest.IsSuccess)
{
return;
}
var evt = evtRequest.Result;
if (!evt.Synced)
{
return;
}
var factory = new ExternalCalendarProviderFactory();
var providers = factory.GetProviders();
foreach (var provider in providers)
{
var isProviderEnabledForUser = await userSettingsService.IsProviderEnabledAsync(evt.Organizer, provider);
if (!isProviderEnabledForUser.IsSuccess)
{
continue;
}
var providerService = factory.CreateService(provider);
var authRequest = await providerService.AuthorizeAsync(evt.Organizer);
if (!authRequest.IsSuccess)
{
continue;
}
var attrRequest = await userSettingsService.GetEventAttributeAsync(evt.Id, $"{provider}_evtId");
if (!attrRequest.IsSuccess)
{
continue;
}
var providerEventId = attrRequest.Result;
await providerService.DeleteEventAsync(providerEventId);
}
};
return(serviceCollection);
}
