public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context) { try { //context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" }); using (AuthService _repo = new AuthService()) { var user = await _repo.FindUser(context.UserName, context.Password); if (user == null) { context.SetError("invalid_grant", "The user name or password is incorrect."); return; } } var identity = new ClaimsIdentity(context.Options.AuthenticationType); identity.AddClaim(new Claim("sub", context.UserName)); identity.AddClaim(new Claim("role", "user")); context.Validated(identity); } catch (Exception exp) {} }
static IAppHost GetAppHost() { if (_appHost == null) { _appHost = new BasicAppHost(); var authService = new AuthService(); authService.SetResolver(_appHost); _appHost.Container.Register(authService); _appHost.Container.Register<IAuthSession>(authUserSession); } return _appHost; }
public static void CopyAuthorization( ISecured sourceEntity, ISecured targetEntity, int? personId ) { using ( new Rock.Helpers.UnitOfWorkScope() ) { // If there's no Authorizations object, create it if ( Authorizations == null ) Load(); AuthService authService = new AuthService(); // Delete the current authorizations for the target entity foreach(Auth auth in authService.GetAuthsByEntityTypeAndEntityId(targetEntity.AuthEntity, targetEntity.Id)) authService.DeleteAuth(auth); Dictionary<string, List<AuthRule>> newActions = new Dictionary<string, List<AuthRule>>(); int order = 0; foreach ( KeyValuePair<string, List<AuthRule>> action in Authorizations[sourceEntity.AuthEntity][sourceEntity.Id] ) if (targetEntity.SupportedActions.Contains(action.Key)) { newActions.Add( action.Key, new List<AuthRule>() ); foreach ( AuthRule rule in action.Value ) { Auth auth = new Auth(); auth.EntityType = targetEntity.AuthEntity; auth.EntityId = targetEntity.Id; auth.Order = order; auth.Action = action.Key; auth.AllowOrDeny = rule.AllowOrDeny; auth.UserOrRole = rule.UserOrRole; auth.UserOrRoleName = rule.UserOrRoleName; authService.AddAuth(auth); authService.Save(auth, personId); newActions[action.Key].Add( new AuthRule( rule.AllowOrDeny, rule.UserOrRole, rule.UserOrRoleName ) ); order++; } } if ( !Authorizations.ContainsKey( targetEntity.AuthEntity ) ) Authorizations.Add( targetEntity.AuthEntity, new Dictionary<int, Dictionary<string, List<AuthRule>>>() ); Dictionary<int, Dictionary<string, List<AuthRule>>> entityType = Authorizations[targetEntity.AuthEntity]; if ( !entityType.ContainsKey( targetEntity.Id ) ) entityType.Add( targetEntity.Id, new Dictionary<string, List<AuthRule>>() ); entityType[targetEntity.Id] = newActions; } }
protected void Page_Load(object sender, EventArgs e) { IApplicationContext ctx = ContextRegistry.GetContext(); authService = (AuthService)ctx.GetObject("AuthService"); if (!Page.IsPostBack) { setPrgName(); initMenu(); initInfo(); } }
/// <summary> /// Create an APM token /// </summary> internal static string CreateAPMToken(AuthService authService) { var tokenRequest = new TokenRequest(); tokenRequest.clientKey = Configuration.ClientKey; var cardRequest = new APMRequest(); cardRequest.type = "APM"; cardRequest.apmName = "PAYPAL"; cardRequest.shopperCountryCode = "GB"; cardRequest.apmFields = new Dictionary<string, string>(); tokenRequest.paymentMethod = cardRequest; TokenResponse response = authService.GetToken(tokenRequest); return response.token; }
public async Task ReceiveAsync(AuthenticationTokenReceiveContext context) { var allowedOrigin = context.OwinContext.Get<string>("as:clientAllowedOrigin"); context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { allowedOrigin }); var hashedTokenId = Helper.GetHash( context.Token) ; authRepository = new AuthService(); var refreshToken = await authRepository.FindRefreshToken(hashedTokenId); if (refreshToken != null) { //Get protectedTicket from refreshToken class context.DeserializeTicket(refreshToken.ProtectedTicket); var result = await authRepository.RemoveRefreshToken( hashedTokenId ); } }
/// <summary> /// Create an access token /// </summary> internal static string CreateToken(AuthService authService) { var tokenRequest = new TokenRequest(); tokenRequest.clientKey = Configuration.ClientKey; var cardRequest = new CardRequest(); cardRequest.cardNumber = TestMastercardNumber; cardRequest.cvc = TestCvv; cardRequest.name = "csharplib client"; cardRequest.expiryMonth = 2; cardRequest.expiryYear = 2018; cardRequest.type = "Card"; tokenRequest.paymentMethod = cardRequest; TokenResponse response = authService.GetToken(tokenRequest); return response.token; }
public async Task CreateAsync(AuthenticationTokenCreateContext context) { try { if (!context.Response.Headers.ContainsKey("Access-Control-Allow-Origin")) context.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" }); var clientid = context.Ticket.Properties.Dictionary["as:client_id"]; if (string.IsNullOrEmpty(clientid)) { return; } var refreshTokenId = Helper.GetHash(ObjectId.GenerateNewId().ToString ()); var refreshTokenLifeTime = context.OwinContext.Get<string>("as:clientRefreshTokenLifeTime"); var token = new RefreshToken() { Token = refreshTokenId , ClientId = clientid, Subject = context.Ticket.Identity.Name, IssuedUtc = DateTime.UtcNow, ExpiresUtc = DateTime.UtcNow.AddMinutes(Convert.ToDouble(refreshTokenLifeTime)) }; context.Ticket.Properties.IssuedUtc = token.IssuedUtc; context.Ticket.Properties.ExpiresUtc = token.ExpiresUtc; token.ProtectedTicket = context.SerializeTicket(); authRepository = new AuthService(); var result = await authRepository.AddRefreshToken(token); if (result) { context.SetToken(refreshTokenId); } } catch (Exception exp) { } }
public void should_succeed_if_registered() { AuthService auth = new AuthService(); var acontroller = new AccountController(auth); acontroller.Request = new HttpRequestMessage(); acontroller.Configuration = new HttpConfiguration(); var p = new UserModel { Name = "*****@*****.**", Password = "******", ConfirmPassword = "******" }; var res = acontroller.Register(p); }
protected void Page_Load(object sender, EventArgs e) { IApplicationContext ctx = ContextRegistry.GetContext(); authService = (AuthService)ctx.GetObject("AuthService"); if (!Page.IsPostBack) { SetConcrol(); if (Request.QueryString["id"] != null) { UseUpdateMode(); hdnId.Value = Request.QueryString["id"].ToString(); LoadDataToUI(hdnId.Value); } else { UseAddMode(); } } }
protected override void OnCreate(Bundle savedInstanceState) { base.OnCreate(savedInstanceState); Xamarin.Essentials.Platform.Init(this, savedInstanceState); SetContentView(Resource.Layout.activity_auth); loginText = FindViewById <EditText>(Resource.Id.vklogin); passwordText = FindViewById <EditText>(Resource.Id.vkpassword); Button btn = FindViewById <Button>(Resource.Id.log_in_btn); btn.Click += async(sender, e) => { if (loginText.Text == "" || passwordText.Text == "") { Toast.MakeText(this, "Вы не указали логин и пароль", ToastLength.Long).Show(); return; } var progressBarLoading = FindViewById <ProgressBar>(Resource.Id.progressBarLogin); progressBarLoading.Visibility = ViewStates.Visible; btn.Visibility = ViewStates.Invisible; Toast.MakeText(this, "Пытаюсь связаться с ВКонтакте...", ToastLength.Long).Show(); string token = null; try { token = await Auth.User(loginText.Text, passwordText.Text, TwoFactorAuth, null); }catch (VkNet.Exception.UserAuthorizationFailException) { AuthService.ShowIncorrectLoginDialog(this.FragmentManager); }catch (VkNet.Exception.VkAuthorizationException) { AuthService.ShowIncorrectLoginDialog(this.FragmentManager); } catch (VkNet.Exception.VkApiAuthorizationException) { AuthService.ShowIncorrectLoginDialog(this.FragmentManager); } catch (VkNet.Exception.UserDeletedOrBannedException) { AuthService.ShowIncorrectLoginDialog(this.FragmentManager); } catch (Flurl.Http.FlurlHttpException) { Toast.MakeText(this, "Нет доступа к интернету", ToastLength.Long).Show(); } catch (System.Exception ex) { Toast.MakeText(this, "Неизвестная ошибка авторизации: " + ex, ToastLength.Long).Show(); } if (token != null) { //Toast.MakeText(this, "Ваш токен " + token, ToastLength.Long).Show(); var prefs = Application.Context.GetSharedPreferences("MusicX", FileCreationMode.Private); var editor = prefs.Edit(); editor.PutString("VKToken", token); editor.Commit(); Intent intent = new Intent(this.ApplicationContext, typeof(MainActivity)); intent.SetFlags(ActivityFlags.NewTask); StartActivity(intent); Finish(); } else { progressBarLoading.Visibility = ViewStates.Invisible; btn.Visibility = ViewStates.Visible; } }; }
public Edit(AuthService authService) { _httpService = new HttpService(authService.GetHttpClient(), authService.ApiUrl); }
public UnAuthorizeCommand(AppConfig appConfig, LiteDatabaseAsync liteDb, IEasyCachingProvider easyCachingProvider, AuthService authService) { _appConfig = appConfig; _easyCachingProvider = easyCachingProvider; _authService = authService; _liteDb = liteDb; }
public AuthController(AuthService authService) { AuthService = authService; }
public async Task ActivateAsync() { Identity = await AuthService.GetIdentityAsync().ConfigureAwait(true); }
public static void Init(string customUserAgent = null, string clearCipherCacheKey = null, string[] allClearCipherCacheKeys = null) { if (Inited) { return; } Inited = true; var platformUtilsService = Resolve <IPlatformUtilsService>("platformUtilsService"); var storageService = Resolve <IStorageService>("storageService"); var stateService = Resolve <IStateService>("stateService"); var i18nService = Resolve <II18nService>("i18nService"); var messagingService = Resolve <IMessagingService>("messagingService"); var cryptoFunctionService = Resolve <ICryptoFunctionService>("cryptoFunctionService"); var cryptoService = Resolve <ICryptoService>("cryptoService"); SearchService searchService = null; var tokenService = new TokenService(stateService); var apiService = new ApiService(tokenService, platformUtilsService, (extras) => { messagingService.Send("logout", extras); return(Task.CompletedTask); }, customUserAgent); var appIdService = new AppIdService(storageService); var organizationService = new OrganizationService(stateService); var settingsService = new SettingsService(stateService); var fileUploadService = new FileUploadService(apiService); var cipherService = new CipherService(cryptoService, stateService, settingsService, apiService, fileUploadService, storageService, i18nService, () => searchService, clearCipherCacheKey, allClearCipherCacheKeys); var folderService = new FolderService(cryptoService, stateService, apiService, i18nService, cipherService); var collectionService = new CollectionService(cryptoService, stateService, i18nService); var sendService = new SendService(cryptoService, stateService, apiService, fileUploadService, i18nService, cryptoFunctionService); searchService = new SearchService(cipherService, sendService); var policyService = new PolicyService(stateService, organizationService); var keyConnectorService = new KeyConnectorService(stateService, cryptoService, tokenService, apiService, organizationService); var vaultTimeoutService = new VaultTimeoutService(cryptoService, stateService, platformUtilsService, folderService, cipherService, collectionService, searchService, messagingService, tokenService, policyService, keyConnectorService, (extras) => { messagingService.Send("locked", extras); return(Task.CompletedTask); }, (extras) => { messagingService.Send("logout", extras); return(Task.CompletedTask); }); var syncService = new SyncService(stateService, apiService, settingsService, folderService, cipherService, cryptoService, collectionService, organizationService, messagingService, policyService, sendService, keyConnectorService, (extras) => { messagingService.Send("logout", extras); return(Task.CompletedTask); }); var passwordGenerationService = new PasswordGenerationService(cryptoService, stateService, cryptoFunctionService, policyService); var totpService = new TotpService(stateService, cryptoFunctionService); var authService = new AuthService(cryptoService, cryptoFunctionService, apiService, stateService, tokenService, appIdService, i18nService, platformUtilsService, messagingService, vaultTimeoutService, keyConnectorService); var exportService = new ExportService(folderService, cipherService, cryptoService); var auditService = new AuditService(cryptoFunctionService, apiService); var environmentService = new EnvironmentService(apiService, stateService); var eventService = new EventService(apiService, stateService, organizationService, cipherService); var userVerificationService = new UserVerificationService(apiService, platformUtilsService, i18nService, cryptoService); Register <ITokenService>("tokenService", tokenService); Register <IApiService>("apiService", apiService); Register <IAppIdService>("appIdService", appIdService); Register <IOrganizationService>("organizationService", organizationService); Register <ISettingsService>("settingsService", settingsService); Register <ICipherService>("cipherService", cipherService); Register <IFolderService>("folderService", folderService); Register <ICollectionService>("collectionService", collectionService); Register <ISendService>("sendService", sendService); Register <ISearchService>("searchService", searchService); Register <IPolicyService>("policyService", policyService); Register <ISyncService>("syncService", syncService); Register <IVaultTimeoutService>("vaultTimeoutService", vaultTimeoutService); Register <IPasswordGenerationService>("passwordGenerationService", passwordGenerationService); Register <ITotpService>("totpService", totpService); Register <IAuthService>("authService", authService); Register <IExportService>("exportService", exportService); Register <IAuditService>("auditService", auditService); Register <IEnvironmentService>("environmentService", environmentService); Register <IEventService>("eventService", eventService); Register <IKeyConnectorService>("keyConnectorService", keyConnectorService); Register <IUserVerificationService>("userVerificationService", userVerificationService); }
public MediaController(MediaPresenterService media, CacheService cache, AuthService auth) { _media = media; _cache = cache; _auth = auth; }
public PosLoginPageViewModel(ICustomerNavService navService, AuthService authService) : base(navService) { AuthService = authService; }
public AuthController( AuthService <AccountUser> authService) { _authService = authService; }
/// <inheritdoc/> protected override async Task <TaskModel> ProtectedHandleAsync(UpdateTaskStatusCommand request, CancellationToken cancellationToken) { var entity = await Context.TaskRepository .GetFirstOrDefaultAsync(e => e.Id == Guid.Parse(request.Id)); if (entity == null) { throw new NotFoundException(nameof(TaskEntity), request.Id); } if (!AuthService.IsAuthorized(entity.UserId)) { throw new ForbiddenException("Not authorized"); } entity.ModifiedDate = DateTime.UtcNow; entity.Status = (int)request.Status; entity.Message = request.Message; switch (request.Status) { case Domain.Enums.TaskStatus.Created: entity.QueuedDate = null; entity.StartedDate = null; entity.EndedDate = null; break; case Domain.Enums.TaskStatus.Queued: entity.QueuedDate = DateTime.UtcNow; entity.StartedDate = null; entity.EndedDate = null; break; case Domain.Enums.TaskStatus.Processing: entity.StartedDate = DateTime.UtcNow; entity.EndedDate = null; break; case Domain.Enums.TaskStatus.Canceled: case Domain.Enums.TaskStatus.Failed: case Domain.Enums.TaskStatus.Finished: entity.EndedDate = DateTime.UtcNow; break; default: break; } if (request.Status != Domain.Enums.TaskStatus.Queued) { entity.Position = 0; } if (!string.IsNullOrWhiteSpace(request.ResultId)) { entity.ResultId = Guid.Parse(request.ResultId); } Context.TaskRepository.Update(entity); await Context.SaveChangesAsync(cancellationToken); var result = await mediator.Send(new GetByIdQuery() { Id = entity.Id.ToString() }); if (result == null) { throw new UnexpectedNullException($"The task '{entity.Id.ToString()}' could not be retrieved after updating it."); } if (entity.Object != null) { await Events.CreateAsync(entity.Object.UserId, EventType.TaskUpdated, result, cancellationToken); await Gateway.NotifyGroupsAsync(entity.Object.UserId, EventType.TaskUpdated, result, cancellationToken); } return(result); }
public async Task <ActionResult> Validate(String token) { await AuthService.ValidateRegistration(token); return(Ok()); }
public async Task <ActionResult> Register([FromBody] API.Request.NewUser newUser) { await AuthService.Register(newUser); return(StatusCode(StatusCodes.Status201Created)); }
public AuthController( AuthService <ColossusUser> authService) { _authService = authService; }
public AccountController(UserService userService, AuthService authService) { _userService = userService; _authService = authService; }
private async Task Login() { ClearErrorMessage(); if (!EmailHelper.IsValidEmail(email)) { ErrorMessageEmail = "Invalid Email."; IsErrorEmail = true; return; } IsBusy = true; await Task.Delay(1000); try { //LoadingLottie = true; if (NullValidate(Email) == false) { ErrorMessageEmail = "Please enter E-mail"; IsErrorEmail = true; } else if (!EmailHelper.IsValidEmail(email)) { ErrorMessageEmail = "E-mail is invalid"; IsErrorEmail = true; } else if (NullValidate(Password) == false) { ErrorMessagePassword = "******"; IsErrorPassword = true; } else { var checkNet = true; int workingStep = 1; retry = 1; int loopcheck = 0; bool internetCheck = true; do { switch (workingStep) { case 1: //check internet checkNet = CheckingInternet(); if (checkNet == true) { workingStep = 10; } else { workingStep = 2; } break; case 2: //delay await Task.Delay(300); workingStep = 3; break; case 3: //action result bool istryAgain = await Application.Current.MainPage.DisplayAlert("", "No Internet", "Try Again", "Cancel"); if (istryAgain) { workingStep = 1; } else { internetCheck = false; } break; case 10: //call api loopcheck++; LoginCommandModel command = new LoginCommandModel() { Email = Email, Password = Password }; result = await AuthService.Login(command); if (result.StatusCode == Enums.StatusCode.Ok) { // await App.Current.MainPage.Navigation.PushAsync(new LoginPage()); App.Email = result.Success.Email; App.FullName = result.Success.FullName; App.UserId = result.Success.Id; App.AccessToken = result.Success.AccessToken; App.About = result.Success.About; App.ImagePath = result.Success.ImageProfilePath; App.Current.MainPage = new AppShell(); workingStep = 100; } else { if (loopcheck <= maxRetry) { if (result.StatusCode == Enums.StatusCode.Unauthorized) { // await GetToken(); } else { workingStep++; } } else { internetCheck = false; } } break; case 11: // await Task.Delay(300); workingStep++; break; case 12: // if (result.StatusCode == Enums.StatusCode.BadRequest) { //await PopupNavigation.Instance.PushAsync(new ErrorPopup(resultHistory.Error.ErrorMessage)); //await Application.Current.MainPage.DisplayAlert("", resultHistory.Error.ErrorMessage.ToString(), "OK"); } else if (result.StatusCode == Enums.StatusCode.NotFound) { //await PopupNavigation.Instance.PushAsync(new ErrorPopup(resultHistory.Error.ErrorMessage)); //await Application.Current.MainPage.DisplayAlert("", resultHistory.Error.ErrorMessage.ToString(), "OK"); } else if (result.StatusCode == Enums.StatusCode.InternalServerError) { //await PopupNavigation.Instance.PushAsync(new ErrorPopup(resultHistory.Error.ErrorMessage)); //await Application.Current.MainPage.DisplayAlert("", resultHistory.Error.ErrorMessage.ToString(), "OK"); } else { //await PopupNavigation.Instance.PushAsync(new ErrorPopup(resultHistory.Error.ErrorMessage)); //await Application.Current.MainPage.DisplayAlert("", resultHistory.Error.ErrorMessage.ToString(), "OK"); } workingStep++; break; case 13: // internetCheck = false; break; case 100: // internetCheck = false; break; default: internetCheck = false; break; } } while (internetCheck); } } catch (OperationCanceledException ex) { //await PopupNavigation.Instance.PushAsync(new ErrorPopup("ปิดปรับปรุงServer")); await Application.Current.MainPage.DisplayAlert("", "ปิดปรับปรุงServer", "OK"); //Application.Current.MainPage = new NavigationPage(new LoginPage()); } catch (TimeoutException ex) { //await PopupNavigation.Instance.PushAsync(new ErrorPopup("กรุณาลองใหม่อีกครั้ง")); await Application.Current.MainPage.DisplayAlert("", "กรุณาลองใหม่อีกครั้ง", "OK"); //Application.Current.MainPage = new NavigationPage(new LoginPage()); } catch (Exception ex) { //await PopupNavigation.Instance.PushAsync(new ErrorPopup("กรุณาลองใหม่อีกครั้ง")); await Application.Current.MainPage.DisplayAlert("", "กรุณาลองใหม่อีกครั้ง", "OK"); } //Call Api //Home IsBusy = false; }
public SignInController(UserRepository userRepository, AuthService authService) { _userRepository = userRepository; _authService = authService; }
public void TestFixtureSetUp() { AuthService.Init(new TestAppHost(), () => new AuthUserSession(), new CredentialsAuthProvider()); }
public AuthController(UserManager <Person> userManager, SignInManager <Person> signInManager, PersonService personService, AuthService authService) { _userManager = userManager; _signInManager = signInManager; PersonService = personService; AuthService = authService; }
public ReservationDetailsViewModel() { _proxy = AutofacHelper.Container.Resolve <ApiClientProxy>(); _mapper = AutofacHelper.Container.Resolve <Mapper>(); _authService = AutofacHelper.Container.Resolve <AuthService>(); }
private AuthViewModel() { IsActiveProgressRing = false; VisibilityButton = Visibility.Visible; LoginCommand = new RelayCommand(async() => { IsActiveProgressRing = true; VisibilityButton = Visibility.Collapsed; Changed("IsActiveProgressRing"); Changed("VisibilityButton"); if (Login == null || Password == null) { await new MessageDialog("Вы не указали логин или пароль").ShowAsync(); IsActiveProgressRing = false; VisibilityButton = Visibility.Visible; Changed("IsActiveProgressRing"); Changed("VisibilityButton"); return; } string token = null; try { token = await AuthService.FirstAuth(Login, Password); } catch (VkNet.Exception.UserAuthorizationFailException) { await ContentDialogService.Show(new IncorrectLoginOrPasswordContentDialog()); } catch (VkNet.Exception.VkAuthorizationException) { await ContentDialogService.Show(new IncorrectLoginOrPasswordContentDialog()); } catch (VkNet.Exception.VkApiAuthorizationException) { await ContentDialogService.Show(new IncorrectLoginOrPasswordContentDialog()); } catch (VkNet.Exception.UserDeletedOrBannedException) { await ContentDialogService.Show(new IncorrectLoginOrPasswordContentDialog()); } catch (Flurl.Http.FlurlHttpException) { await ContentDialogService.Show(new ErrorConnectContentDialog()); }catch (Exception e) { await ContentDialogService.Show(new ExceptionDialog("Неизвестная ошибка авторизации", "", e)); } if (token != null) { try { PlayerMenuViewModel.Instanse.VkontaktePages = Visibility.Visible; await TokenService.Save(token); StaticContent.IsAuth = true; StaticContent.CurrentSessionIsAuth = true; StaticContent.NavigationContentService.Go(typeof(HomeView)); }catch (Exception e) { await ContentDialogService.Show(new ExceptionDialog("Неизвестная ошибка после авторизации", "Возможно, ошибка навигации или сохранения", e)); PlayerMenuViewModel.Instanse.VkontaktePages = Visibility.Collapsed; StaticContent.IsAuth = false; StaticContent.CurrentSessionIsAuth = false; } } else { IsActiveProgressRing = false; VisibilityButton = Visibility.Visible; Changed("IsActiveProgressRing"); Changed("VisibilityButton"); } }); }
public AudioController() { _vkAuthService = new AuthService(); _vkMusicService = new AudioService(); }
public SimpleRefreshTokenProvider(AuthService authRepository) { this.authRepository = authRepository; }
public async Task <IViewComponentResult> InvokeAsync(PageComponentContext context) { ErpPage currentPage = null; try { #region << Init >> if (context.Node == null) { return(await Task.FromResult <IViewComponentResult>(Content("Error: The node Id is required to be set as query param 'nid', when requesting this component"))); } var pageFromModel = context.DataModel.GetProperty("Page"); if (pageFromModel is ErpPage) { currentPage = (ErpPage)pageFromModel; } else { return(await Task.FromResult <IViewComponentResult>(Content("Error: PageModel does not have Page property or it is not from ErpPage Type"))); } if (currentPage == null) { return(await Task.FromResult <IViewComponentResult>(Content("Error: The page Id is required to be set as query param 'pid', when requesting this component"))); } var options = new PcSectionOptions(); if (context.Options != null) { options = JsonConvert.DeserializeObject <PcSectionOptions>(context.Options.ToString()); } //Check if it is defined in form group if (options.LabelMode == LabelRenderMode.Undefined) { if (context.Items.ContainsKey(typeof(LabelRenderMode))) { options.LabelMode = (LabelRenderMode)context.Items[typeof(LabelRenderMode)]; } else { options.LabelMode = LabelRenderMode.Stacked; } } //Check if it is defined in form group if (options.FieldMode == FieldRenderMode.Undefined) { if (context.Items.ContainsKey(typeof(FieldRenderMode))) { options.FieldMode = (FieldRenderMode)context.Items[typeof(FieldRenderMode)]; } else { options.FieldMode = FieldRenderMode.Form; } } var componentMeta = new PageComponentLibraryService().GetComponentMeta(context.Node.ComponentName); //Init IsCollapsed from userPreferences if (HttpContext.User != null) { var currentUser = AuthService.GetUser(HttpContext.User); if (currentUser != null) { var componentData = new UserPreferencies().GetComponentData(currentUser.Id, "WebVella.Erp.Web.Components.PcSection"); if (componentData != null) { var collapsedNodeIds = new List <Guid>(); var uncollapsedNodeIds = new List <Guid>(); if (componentData.Properties.ContainsKey("collapsed_node_ids") && componentData["collapsed_node_ids"] != null) { if (componentData["collapsed_node_ids"] is string) { try { collapsedNodeIds = JsonConvert.DeserializeObject <List <Guid> >((string)componentData["collapsed_node_ids"]); } catch (Exception ex) { throw new Exception("WebVella.Erp.Web.Components.PcSection component data object in user preferences not in the correct format. collapsed_node_ids should be List<Guid>"); } } else if (componentData["collapsed_node_ids"] is List <Guid> ) { collapsedNodeIds = (List <Guid>)componentData["collapsed_node_ids"]; } else if (componentData["collapsed_node_ids"] is JArray) { collapsedNodeIds = ((JArray)componentData["collapsed_node_ids"]).ToObject <List <Guid> >(); } else { throw new Exception("Unknown format of collapsed_node_ids"); } } if (componentData.Properties.ContainsKey("uncollapsed_node_ids") && componentData["uncollapsed_node_ids"] != null) { if (componentData["uncollapsed_node_ids"] is string) { try { uncollapsedNodeIds = JsonConvert.DeserializeObject <List <Guid> >((string)componentData["uncollapsed_node_ids"]); } catch (Exception ex) { throw new Exception("WebVella.Erp.Web.Components.PcSection component data object in user preferences not in the correct format. uncollapsed_node_ids should be List<Guid>"); } } else if (componentData["uncollapsed_node_ids"] is List <Guid> ) { uncollapsedNodeIds = (List <Guid>)componentData["uncollapsed_node_ids"]; } else if (componentData["uncollapsed_node_ids"] is JArray) { uncollapsedNodeIds = ((JArray)componentData["uncollapsed_node_ids"]).ToObject <List <Guid> >(); } else { throw new Exception("Unknown format of uncollapsed_node_ids"); } } if (collapsedNodeIds.Contains(context.Node.Id)) { options.IsCollapsed = true; } else if (uncollapsedNodeIds.Contains(context.Node.Id)) { options.IsCollapsed = false; } } } } #endregion ViewBag.Options = options; ViewBag.Node = context.Node; ViewBag.ComponentMeta = componentMeta; ViewBag.RequestContext = ErpRequestContext; ViewBag.AppContext = ErpAppContext.Current; ViewBag.ComponentContext = context; ViewBag.GeneralHelpSection = HelpJsApiGeneralSection; if (context.Mode == ComponentMode.Display || context.Mode == ComponentMode.Design) { var isVisible = true; var isVisibleDS = context.DataModel.GetPropertyValueByDataSource(options.IsVisible); if (isVisibleDS is string && !String.IsNullOrWhiteSpace(isVisibleDS.ToString())) { if (Boolean.TryParse(isVisibleDS.ToString(), out bool outBool)) { isVisible = outBool; } } else if (isVisibleDS is Boolean) { isVisible = (bool)isVisibleDS; } ViewBag.IsVisible = isVisible; ViewBag.ProcessedTitle = context.DataModel.GetPropertyValueByDataSource(options.Title); } context.Items[typeof(LabelRenderMode)] = options.LabelMode; context.Items[typeof(FieldRenderMode)] = options.FieldMode; switch (context.Mode) { case ComponentMode.Display: return(await Task.FromResult <IViewComponentResult>(View("Display"))); case ComponentMode.Design: return(await Task.FromResult <IViewComponentResult>(View("Design"))); case ComponentMode.Options: ViewBag.LabelRenderModeOptions = ModelExtensions.GetEnumAsSelectOptions <LabelRenderMode>(); ViewBag.FieldRenderModeOptions = ModelExtensions.GetEnumAsSelectOptions <FieldRenderMode>(); return(await Task.FromResult <IViewComponentResult>(View("Options"))); case ComponentMode.Help: return(await Task.FromResult <IViewComponentResult>(View("Help"))); default: ViewBag.Error = new ValidationException() { Message = "Unknown component mode" }; return(await Task.FromResult <IViewComponentResult>(View("Error"))); } } catch (ValidationException ex) { ViewBag.Error = ex; return(await Task.FromResult <IViewComponentResult>(View("Error"))); } catch (Exception ex) { ViewBag.Error = new ValidationException() { Message = ex.Message }; return(await Task.FromResult <IViewComponentResult>(View("Error"))); } }
public AuthController(IMediator mediator, AuthService authService) { _mediator = mediator; _authService = authService; }
public OnboardingRestService(AuthService authService, ILogger logger, string baseUrl) : base(authService, logger, baseUrl) { client.Authenticator = new HttpBasicAuthenticator("Administrator", "Edison1234"); }
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context) { if (!context.Response.Headers.ContainsKey("Access-Control-Allow-Origin")) context.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" }); var allowedOrigin = context.OwinContext.Get<string>("as:clientAllowedOrigin"); ApplicationUser user = new ApplicationUser(); if (allowedOrigin == null) allowedOrigin = "*"; using (AuthService _repo = new AuthService()) { user = await _repo.FindUser(context.UserName, context.Password); } if (user == null) { context.SetError("invalid_grant", "The user name or password is incorrect."); return; } var identity = new ClaimsIdentity(context.Options.AuthenticationType); identity.AddClaim(new Claim(ClaimTypes.Name, context.UserName)); identity.AddClaim(new Claim("sub", context.UserName)); identity.AddClaim(new Claim("role", "user")); //using (AuthService _repo = new AuthService()) //{ // var identity = await _repo.CreateIdentity(user, context.Options.AuthenticationType); var props = new AuthenticationProperties(new Dictionary<string, string> { { "as:client_id", (context.ClientId == null) ? string.Empty : context.ClientId }, { "userName", context.UserName } }); var ticket = new AuthenticationTicket(identity, props); try { var accessToken = Startup.OAuthServerOptions.AccessTokenFormat.Protect(ticket); } catch { } context.Validated(ticket); //} }
/// <summary>Gets registration service.</summary> /// /// <param name="userAuthRepository">The user authentication repository.</param> /// <param name="oAuthUserSession"> The authentication user session.</param> /// <param name="requestContext"> Context for the request.</param> /// /// <returns>The registration service.</returns> public static RegistrationService GetRegistrationService( IUserAuthRepository userAuthRepository, AuthUserSession oAuthUserSession = null, MockRequestContext requestContext = null) { if (requestContext == null) requestContext = new MockRequestContext(); if (oAuthUserSession == null) oAuthUserSession = requestContext.ReloadSession(); var httpReq = requestContext.Get<IHttpRequest>(); var httpRes = requestContext.Get<IHttpResponse>(); oAuthUserSession.Id = httpRes.CreateSessionId(httpReq); httpReq.Items[ServiceExtensions.RequestItemsSessionKey] = oAuthUserSession; var mockAppHost = new BasicAppHost { Container = requestContext.Container }; requestContext.Container.Register(userAuthRepository); var authService = new AuthService { RequestContext = requestContext, }; authService.SetResolver(mockAppHost); mockAppHost.Register(authService); var registrationService = new RegistrationService { UserAuthRepo = userAuthRepository, RequestContext = requestContext, RegistrationValidator = new RegistrationValidator { UserAuthRepo = RegistrationServiceTests.GetStubRepo() }, }; registrationService.SetResolver(mockAppHost); return registrationService; }
public async void LogoutUser(object sender, EventArgs e) { await AuthService.Logout(); NavigateToDashboard?.Invoke(); }
public CreditCardController(AuthService authService) { this.authService = authService; }
public AuthController(AuthService authService, UserService userService = null) { this.authService = authService; this.userService = userService; }
/// <summary> /// Load the static Authorizations object /// </summary> public static void Load() { Authorizations = new Dictionary<string, Dictionary<int, Dictionary<string, List<AuthRule>>>>(); AuthService authService = new AuthService(); foreach ( Auth auth in authService.Queryable(). OrderBy( A => A.EntityType ).ThenBy( A => A.EntityId ).ThenBy( A => A.Action ).ThenBy( A => A.Order ) ) { if ( !Authorizations.ContainsKey( auth.EntityType ) ) Authorizations.Add( auth.EntityType, new Dictionary<int, Dictionary<string, List<AuthRule>>>() ); Dictionary<int, Dictionary<string, List<AuthRule>>> entityAuths = Authorizations[auth.EntityType]; if ( !entityAuths.ContainsKey( auth.EntityId ?? 0 ) ) entityAuths.Add( auth.EntityId ?? 0, new Dictionary<string, List<AuthRule>>() ); Dictionary<string, List<AuthRule>> instanceAuths = entityAuths[auth.EntityId ?? 0]; if ( !instanceAuths.ContainsKey( auth.Action ) ) instanceAuths.Add( auth.Action, new List<AuthRule>() ); List<AuthRule> actionPermissions = instanceAuths[auth.Action]; actionPermissions.Add( new AuthRule( auth.AllowOrDeny, auth.UserOrRole, auth.UserOrRoleName ) ); } }
private async Task <Response> LoginUser() { var userId = string.Empty; var dateTimeOffset = Request.Form.DateTimeOffset; var username = Request.Form.username.Value; Log.Debug("Username \"{0}\" attempting to login", username); if (string.IsNullOrWhiteSpace(username)) { Session["TempMessage"] = Resources.UI.UserLogin_IncorrectUserPass; var uri = Linker.BuildRelativeUri(Context, "UserLoginIndex"); return(Response.AsRedirect(uri.ToString())); // TODO Check this } var authenticated = false; var settings = await AuthService.GetSettingsAsync(); var plexSettings = await PlexSettings.GetSettingsAsync(); if (IsUserInDeniedList(username, settings)) { Log.Debug("User is in denied list, not allowing them to authenticate"); Session["TempMessage"] = Resources.UI.UserLogin_IncorrectUserPass; var uri = Linker.BuildRelativeUri(Context, "UserLoginIndex"); return(Response.AsRedirect(uri.ToString())); // TODO Check this } var password = string.Empty; if (settings.UsePassword) { Log.Debug("Using password"); password = Request.Form.password.Value; } if (settings.UserAuthentication && settings.UsePassword) // Authenticate with Plex { Log.Debug("Need to auth and also provide pass"); var signedIn = (PlexAuthentication)Api.SignIn(username, password); if (signedIn.user?.authentication_token != null) { Log.Debug("Correct credentials, checking if the user is account owner or in the friends list"); if (CheckIfUserIsOwner(plexSettings.PlexAuthToken, signedIn.user?.username)) { Log.Debug("User is the account owner"); authenticated = true; } else { authenticated = CheckIfUserIsInPlexFriends(username, plexSettings.PlexAuthToken); Log.Debug("Friends list result = {0}", authenticated); } userId = signedIn.user.uuid; } } else if (settings.UserAuthentication) // Check against the users in Plex { Log.Debug("Need to auth"); authenticated = CheckIfUserIsInPlexFriends(username, plexSettings.PlexAuthToken); if (authenticated) { userId = GetUserIdIsInPlexFriends(username, plexSettings.PlexAuthToken); } if (CheckIfUserIsOwner(plexSettings.PlexAuthToken, username)) { Log.Debug("User is the account owner"); authenticated = true; userId = GetOwnerId(plexSettings.PlexAuthToken, username); } Log.Debug("Friends list result = {0}", authenticated); } else if (!settings.UserAuthentication) // No auth, let them pass! { Log.Debug("No need to auth"); authenticated = true; } if (authenticated) { UserLogins.Insert(new UserLogins { UserId = userId, Type = UserType.PlexUser, LastLoggedIn = DateTime.UtcNow }); Log.Debug("We are authenticated! Setting session."); // Add to the session (Used in the BaseModules) Session[SessionKeys.UsernameKey] = (string)username; Session[SessionKeys.ClientDateTimeOffsetKey] = (int)dateTimeOffset; } if (!authenticated) { var uri = Linker.BuildRelativeUri(Context, "UserLoginIndex"); Session["TempMessage"] = Resources.UI.UserLogin_IncorrectUserPass; return(Response.AsRedirect(uri.ToString())); // TODO Check this } var landingSettings = await LandingPageSettings.GetSettingsAsync(); if (landingSettings.Enabled) { if (!landingSettings.BeforeLogin) { var uri = Linker.BuildRelativeUri(Context, "LandingPageIndex"); return(Response.AsRedirect(uri.ToString())); } } var retVal = Linker.BuildRelativeUri(Context, "SearchIndex"); return(Response.AsRedirect(retVal.ToString())); // TODO Check this }
public void Setup() { var restClient = new WorldpayRestClient(Configuration.ServiceKey); _authService = restClient.GetAuthService(); _orderService = restClient.GetOrderService(); }
public async Task <ActionResult <User> > Authenticated([FromServices] AuthService authService) { User user = await authService.getAuthUser(User.Identity.Name); return(user); }
/// <summary> /// This method gets called by the runtime. Use this method to add services to the container. /// </summary> /// <param name="services">The injected services provider.</param> public void ConfigureServices(IServiceCollection services) { this.logger.LogDebug("Starting Service Configuration..."); services.AddHttpClient(); services.AddResponseCompression(options => { options.Providers.Add <GzipCompressionProvider>(); options.EnableForHttps = true; }); services.AddAuthentication(options => { options.DefaultAuthenticateScheme = CookieAuthenticationDefaults.AuthenticationScheme; options.DefaultSignInScheme = CookieAuthenticationDefaults.AuthenticationScheme; options.DefaultChallengeScheme = OpenIdConnectDefaults.AuthenticationScheme; }) .AddCookie() .AddOpenIdConnect(o => { this.configuration.GetSection("OpenIdConnect").Bind(o); if (string.IsNullOrEmpty(o.Authority)) { this.logger.LogCritical("OpenIdConnect Authority is missing, bad things are going to occur"); } o.Events = new OpenIdConnectEvents() { OnTokenValidated = ctx => { JwtSecurityToken accessToken = ctx.SecurityToken; if (accessToken != null) { ClaimsIdentity identity = ctx.Principal.Identity as ClaimsIdentity; if (identity != null) { identity.AddClaim(new Claim("access_token", accessToken.RawData)); } } return(Task.CompletedTask); }, OnRedirectToIdentityProvider = ctx => { if (ctx.Properties.Items.ContainsKey(this.configuration["KeyCloak:IDPHintKey"])) { this.logger.LogDebug("Adding IDP Hint passed in from client to provider"); ctx.ProtocolMessage.SetParameter( this.configuration["KeyCloak:IDPHintKey"], ctx.Properties.Items[this.configuration["KeyCloak:IDPHintKey"]]); } else { if (!string.IsNullOrEmpty(this.configuration["KeyCloak:IDPHint"])) { this.logger.LogDebug("Adding IDP Hint on Redirect to provider"); ctx.ProtocolMessage.SetParameter(this.configuration["KeyCloak:IDPHintKey"], this.configuration["KeyCloak:IDPHint"]); } } return(Task.FromResult(0)); }, OnAuthenticationFailed = c => { c.HandleResponse(); c.Response.StatusCode = 500; c.Response.ContentType = "text/plain"; this.logger.LogError(c.Exception.ToString()); return(c.Response.WriteAsync(c.Exception.ToString())); }, }; }); // Auth Service services.AddTransient <IAuthService>(serviceProvider => { this.logger.LogDebug("Configuring Transient Service IAuthService"); IAuthService service = new AuthService( serviceProvider.GetService <ILogger <AuthService> >(), serviceProvider.GetService <IHttpContextAccessor>(), serviceProvider.GetService <IConfiguration>()); return(service); }); // Inject HttpContextAccessor services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>(); services .AddMvc() .SetCompatibilityVersion(CompatibilityVersion.Version_2_2); services.Configure <SwaggerSettings>(this.configuration.GetSection(nameof(SwaggerSettings))); services .AddApiVersionWithExplorer() .AddSwaggerOptions() .AddSwaggerGen(); }
public override Task ValidateClientAuthentication(OAuthValidateClientAuthenticationContext context) { try { if (!context.Response.Headers.ContainsKey("Access-Control-Allow-Origin")) context.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" }); var clientId = default(string); var clientSecret = default(string); var client = default(Client); if (!context.TryGetBasicCredentials(out clientId, out clientSecret)) { context.TryGetFormCredentials(out clientId, out clientSecret); } if (context.ClientId == null) { // Remove the comments from the below line context.SetError, and invalidate context // if you want to force sending clientId/secrects once obtain access tokens. context.Validated(); // context.SetError("invalid_clientId", "ClientId should be sent."); return Task.FromResult<object>(null); } using (AuthService _repo = new AuthService()) { client = _repo.FindClient(context.ClientId).Result; } if (client == null) { context.SetError("invalid_clientId", string.Format("Client '{0}' is not registered in the system.", context.ClientId)); return Task.FromResult<object>(null); } if (client.ApplicationType == ApplicationTypes.NativeConfidential) { if (string.IsNullOrWhiteSpace(clientSecret)) { context.SetError("invalid_clientId", "Client secret should be sent."); return Task.FromResult<object>(null); } else { if (client.Secret != Helper.GetHash(clientSecret)) { context.SetError("invalid_clientId", "Client secret is invalid."); return Task.FromResult<object>(null); } } } if (!client.Active) { context.SetError("invalid_clientId", "Client is inactive."); return Task.FromResult<object>(null); } context.OwinContext.Set<string>("as:clientAllowedOrigin", client.AllowedOrigin); context.OwinContext.Set<string>("as:clientRefreshTokenLifeTime", client.RefreshTokenLifeTime.ToString()); context.Validated(); } catch (Exception exp) { } return Task.FromResult<object>(null); }