예제 #1
0
        public async Task <IActionResult> ExternalCalendarProviders()
        {
            var user = await _userManager.GetCurrentUserAsync();

            if (!user.IsSuccess)
            {
                return(NotFound());
            }
            var userId      = user.Result.Id;
            var factory     = new ExternalCalendarProviderFactory();
            var providers   = factory.GetProvidersInfo();
            var exportModel = new List <ExternalCalendarProviderSettingsViewModel>();

            foreach (var provider in providers)
            {
                var providerConf = new ExternalCalendarProviderSettingsViewModel
                {
                    ProviderName    = provider.ProviderName,
                    FontAwesomeIcon = provider.FontAwesomeIcon,
                    DisplayName     = provider.DisplayName
                };

                var isEnabledRequest = await _userSettingsService.IsProviderEnabledAsync(userId, provider.ProviderName);

                providerConf.IsEnabled = isEnabledRequest.IsSuccess;

                if (!isEnabledRequest.IsSuccess)
                {
                    exportModel.Add(providerConf); continue;
                }

                var providerService = factory.CreateService(provider.ProviderName);
                var authResult      = await providerService.AuthorizeAsync(userId);

                if (authResult.IsSuccess)
                {
                    var provideruserRequest = await providerService.GetUserAsync();

                    if (provideruserRequest.IsSuccess)
                    {
                        var providerUser = provideruserRequest.Result;
                        providerConf.User = new ExternalCalendarUser
                        {
                            IsAuthorized = true,
                            UserName     = providerUser.DisplayName,
                            EmailAdress  = providerUser.EmailAddress,
                            ImageUrl     = providerUser.ImageUrl
                        };
                    }
                }
                exportModel.Add(providerConf);
            }

            return(View(exportModel));
        }
예제 #2
0
        public async Task <IActionResult> CalendarExternalLogin(string provider, string returnUrl = null)
        {
            var user = await _userManager.GetCurrentUserAsync();

            if (!user.IsSuccess)
            {
                return(NotFound());
            }
            var           factory = new ExternalCalendarProviderFactory();
            IActionResult result;

            switch (provider)
            {
            case "GoogleCalendarProvider":
            {
                if (factory.GetProviders().Contains(provider))
                {
                    var serviceProvider = factory.CreateService(provider);
                    await serviceProvider.AuthorizeAsync(user.Result.Id, true);

                    result = RedirectToAction("ExternalCalendarProviders");
                }
                else
                {
                    result = RedirectToAction(nameof(ExternalCalendarProviders));
                }
            }
            break;

            case "OutlookCalendarProvider":
            {
                var redirectUrl = Url.Action(nameof(OutlookCalendarExternalLoginCallback), "Calendar", new
                    {
                        returnUrl,
                        gearUserId = user.Result.Id,
                        provider
                    });

                const string instanceProvider = "Microsoft";

                var properties = _signInManager.ConfigureExternalAuthenticationProperties(instanceProvider, redirectUrl);

                result = Challenge(properties, instanceProvider);
            }
            break;

            default:
            {
                result = RedirectToAction(nameof(ExternalCalendarProviders));
            }
            break;
            }

            return(result);
        }
        /// <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);
        }