public async Task <bool> IsAuthenticatedAndValid()
        {
            var authUserInfo = LocalStorage.Storage.GetValueOrDefault <ExternAuthUser>(StorageKey.ExternAuthUserInfo);

            if (authUserInfo == null)
            {
                _isAuthenticated = false;
                return(false);
            }

            // 기간 만료
            if (authUserInfo.ExpiresIn < DateTime.UtcNow)
            {
                _isAuthenticated = false;
                return(false);
            }

            var oAuth = OAuthProviderFactory.CreateProvider(authUserInfo.Provider);

            _authenticatedUser = await oAuth.GetUserInfoAsync(authUserInfo.Token);

            // 유효하지 않은 토큰
            if (_authenticatedUser == null)
            {
                _isAuthenticated = false;
                return(false);
            }

            _isAuthenticated = true;
            return(true);
        }
        public async Task OAuthLoginAsync(SNSProviderType provider)
        {
            if (!await WebApiService.CheckInternetConnection())
            {
                _isAuthenticated = false;
                return;
            }

            var oAuth = OAuthProviderFactory.CreateProvider(provider);

            Cur_Provider = oAuth.Provider;

            if (oAuth.Provider == SNSProviderType.Google)
            {
                var googleOAuthService = DependencyService.Resolve <IGoogleOAuth>();
                googleOAuthService.Login(oAuth.ClientId);
            }
            else if (oAuth.Provider == SNSProviderType.Facebook)
            {
                Cur_Authenticator = new OAuth2Authenticator(
                    oAuth.ClientId,
                    oAuth.Scope,
                    new Uri(oAuth.AuthorizationUrl),
                    new Uri(oAuth.RedirectUrl));

                Cur_Authenticator.Completed += OnOAuthComplete;
                Cur_Authenticator.Error     += OnOAuthError;

                var presenter = new Xamarin.Auth.Presenters.OAuthLoginPresenter();
                presenter.Login(Cur_Authenticator);
            }
        }
        public async void OAuthLoginAsync(SNSProvider provider)
        {
            try
            {
                if (!ApiService.CheckInternetConnected())
                {
                    await UserDialogs.Instance.AlertAsync("Please check internet connection");
                }

                var oAuth         = OAuthProviderFactory.CreateProvider(provider);
                var authenticator = new OAuth2Authenticator(
                    oAuth.ClientId,
                    oAuth.Scope,
                    new Uri(oAuth.AuthorizationUrl),
                    new Uri(oAuth.RedirectUrl));

                // Completed
                authenticator.Completed += async(sender, eventArgs) =>
                {
                    _isAuthenticated = eventArgs.IsAuthenticated;

                    if (IsAuthenticated)
                    {
                        string token = eventArgs.Account.Properties["access_token"];
                        _authenticatedUser = await oAuth.GetUserInfoAsync(token);

                        LocalStorage.Storage.AddOrUpdateValue(StorageKey.ExternAuthUserInfo, _authenticatedUser);

                        Singleton.Get <ViewLocator>().Login.PoseLoginAsync();
                    }
                };

                // Error
                authenticator.Error += async(sender, eventArgs) =>
                {
                    _isAuthenticated = false;
                    await UserDialogs.Instance.AlertAsync($"Authentication error: {eventArgs.Message}");
                };

                var presenter = new Xamarin.Auth.Presenters.OAuthLoginPresenter();
                presenter.Login(authenticator);

                // 로그인 폼 닫힘
                presenter.Completed += (sender, eventArgs) =>
                {
                    UserDialogs.Instance.HideLoading();
                };
            }
            catch (Exception ex)
            {
                Debug.WriteLine("Login Error : " + ex.Message);
            }
        }
示例#4
0
        public static async Task <ExternAuthUser> Execute(I_CheckVaildOAuthUser input)
        {
            if (input == null)
            {
                ErrorHandler.OccurException(RowCode.Invalid_InputValue);
            }

            if (string.IsNullOrEmpty(input.AccessToken))
            {
                ErrorHandler.OccurException(RowCode.Invalid_AccessToken);
            }

            var oAuth          = OAuthProviderFactory.CreateProvider(input.SNSProvider);
            var externAuthUser = await oAuth.GetUserInfoAsync(input.AccessToken);

            if (externAuthUser == null)
            {
                ErrorHandler.OccurException(RowCode.Failed_OAuth);
            }

            // Check DB
            using (var P_INSERT_USER_BASE = new PoseGlobalDB.Procedures.P_INSERT_USER_BASE())
            {
                P_INSERT_USER_BASE.SetInput(new PoseGlobalDB.Procedures.P_INSERT_USER_BASE.Input
                {
                    PlatformId     = externAuthUser.Id,
                    PlatformType   = externAuthUser.SNSProvider.ToString(),
                    PlatformEmail  = externAuthUser.Email,
                    RoleType       = ServiceRoleType.Promotion.ToString(),//ServiceRoleType.Regular.ToString(), // default 회원등급
                    RoleExpireTime = DateTime.UtcNow.AddDays(7),
                    CurrentTime    = DateTime.UtcNow,
                });

                int queryResult = P_INSERT_USER_BASE.OnQuery();

                if (P_INSERT_USER_BASE.EntityStatus != null || queryResult != 0)
                {
                    ErrorHandler.OccurException(RowCode.DB_Failed_Save);
                }
            }

            return(externAuthUser);
        }