public IdentityService( IOptions <StorageConnectionConfig> storageConnectionConfig, IOptions <TokenConfig> tokenConfig, IOptions <DefaultDataConfigs> defaultDataConfigs, IOptions <GoogleOAuthConfigs> googleOAuthConfigs, IOptions <FacebookOAuthConfigs> facebookOAuthConfigs, IUserRepository iUserRepository, IIdentityTokenRepository identityTokenRepository, IIdentityTokenBlacklistRepository identityTokenBlacklistRepository, SignInManager <ApplicationUser> signInManager, IPasswordHasher <ApplicationUser> passwordHasher, IMediator mediator, IHttpContextAccessor httpContextAccessor, IUserRepository userRepository, UserManager <ApplicationUser> userManager ) : base(mediator, httpContextAccessor, userRepository, userManager) { _storageConnectionConfig = storageConnectionConfig.Value; _tokenConfig = tokenConfig.Value; _defaultDataConfigs = defaultDataConfigs.Value; _googleOAuthConfigs = googleOAuthConfigs.Value; _facebookOAuthConfigs = facebookOAuthConfigs.Value; _iUserRepository = iUserRepository; _identityTokenRepository = identityTokenRepository; _identityTokenBlacklistRepository = identityTokenBlacklistRepository; _signInManager = signInManager; _passwordHasher = passwordHasher; }
private object CreateToken(SigningConfig signConfig, TokenConfig tokenConfig, Operator operador) { var identity = new ClaimsIdentity(AuthExts.ToClaims(operador), tokenConfig.Type); var createdAt = DateTime.UtcNow; var expires = createdAt + TimeSpan.FromHours(tokenConfig.Hours); var handler = new JwtSecurityTokenHandler(); var securityToken = handler.CreateToken(new SecurityTokenDescriptor { Issuer = tokenConfig.Issuer, Audience = tokenConfig.Audience, SigningCredentials = signConfig.SigningCredentials, Subject = identity, NotBefore = createdAt, Expires = expires }); var token = handler.WriteToken(securityToken); return(new { accessToken = token, expiresIn = expires, user = new { id = operador.Id, name = operador.Name, email = operador.Email, type = operador.Type.ToString().ToLower() } }); }
public UserController(UserManager <User> userManager, SignInManager <User> signInManager, IOptions <Data.TokenConfig> tokenConfig, IdentityStore database) { UserManager = userManager; SignInManger = signInManager; TokenConfig = tokenConfig.Value; Database = database; }
public UsuarioController(IUsuarioAcessoServico usuarioAcessoServico, SigningConfigurations signingConfigurations, TokenConfig tokenConfig, IUsuarioServico usuarioServico) { _iUsuarioAcessoServico = usuarioAcessoServico; _signingConfigurations = signingConfigurations; _tokenConfig = tokenConfig; _iUsuarioServico = usuarioServico; }
public void Configuration(IAppBuilder app) { ConfigureAuth(app); log4net.Config.XmlConfigurator.Configure(); var log = log4net.LogManager.GetLogger(typeof(Startup)); log.Debug("Logging esta habilitado"); var config = new HttpConfiguration(); config.Services.Replace(typeof(IExceptionHandler), new GlobalExceptionHandler()); DIConfig.ConfigureInjector(config); app.UseCors(CorsOptions.AllowAll); TokenConfig.ConfigureOAuth(app, config); RouteConfig.Register(config); WebApiConfig.Configure(config); app.UseWebApi(config); //Aquí ingreso datos si es que no existiesen CrearRolesyUsuarioAdmin(); AgregarCategorias(); AgregarSedes(); AgregarTubos(); AgregarEstados(); AgregarClaseElementos(); }
public async Task <IHttpActionResult> SignIn(SignInViewModel model) { var token = await WebApiService.Instance.AuthenticateAsync <TokenViewModel>(model.Email, model.Password); var loginInfo = token.LoginInfo; token.LoginInfo = null;//remove logininfo as it increases token cookie size token.UserId = loginInfo.UserId; var tokenConfig = TokenConfig.GetToken(); tokenConfig.UpdateTokenSession(token); var userPages = await WebApiService.Instance.GetAsync <List <UserPageViewModel> >($"UserPage/Get?id={token.UserId}"); var notificationCount = await WebApiService.Instance.PostAsync <int>($"Notification/Count", loginInfo); var settings = await WebApiService.Instance.GetAsync <List <SettingViewModel> >($"AccessibleToViewSetting/List"); var isHLM = await WebApiService.Instance.GetAsync <bool>($"general/ishlm?roleid={loginInfo.RoleId}"); return(Ok(new { Token = GeneralService.EncryptText(token.AccessToken), UserInfo = loginInfo, UserPages = userPages, NotificationCount = notificationCount, Settings = settings, IsHLM = isHLM })); }
public ActionResult <UserAccessViewModel> Post([FromServices] TokenConfig tokenConfig, [FromServices] UserLogin user, [FromServices] TokenSecurityConfig tokenSecurityConfig, UserAccessViewModel authModel) { if (String.IsNullOrEmpty(authModel.Email) || String.IsNullOrEmpty(authModel.Password)) { return(BadRequest(new { error = "Authentication failed" })); } else { bool validCredentials = (user != null && authModel.Email == user.Email && authModel.Password == user.Password); if (validCredentials) { ClaimsIdentity identity = new ClaimsIdentity(new GenericIdentity(authModel.Email, "Login"), new[] { new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")), new Claim(JwtRegisteredClaimNames.UniqueName, authModel.Email) }); DateTime dataCriacao = DateTime.Now; DateTime dataExpiracao = dataCriacao + TimeSpan.FromSeconds(tokenConfig.Seconds); var handler = new JwtSecurityTokenHandler(); var securityToken = handler.CreateToken(new SecurityTokenDescriptor { Issuer = tokenConfig.Issuer, Audience = tokenConfig.Audience, SigningCredentials = tokenSecurityConfig.Credentials, Subject = identity, NotBefore = dataCriacao, Expires = dataExpiracao }); var token = handler.WriteToken(securityToken); var result = new { AccessToken = token, created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"), expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"), authenticated = true }; return(Ok(result)); } else { var result = new { AccessToken = "", authenticated = false }; return(Ok(result)); } } }
public LoginAppService(IToken token, IUserService userService, SigningConfig signingConfig, TokenConfig tokenConfig) { _token = token; _userService = userService; _signingConfig = signingConfig; _tokenConfig = tokenConfig; }
public TokenService( IOptions <TokenConfig> tokenConfig, IAuthRepository repo ) { _tokenConfig = tokenConfig.Value; _repo = repo; }
public static VIEW_TokenConfig ToViewModel(TokenConfig model) { VIEW_TokenConfig item = new VIEW_TokenConfig(); item.id = model.id; item.Tim = model.Tim; return(item); }
public static TokenConfig ToEntity(VIEW_TokenConfig model) { TokenConfig item = new TokenConfig(); item.id = model.id; item.Tim = model.Tim; return(item); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddControllers(); services.AddScoped <UsuariosRepository>(); services.AddScoped <PromotoriasRepository>(); services.AddScoped <OpnioesRepository>(); services.AddScoped <CidadaosRepository>(); services.AddScoped <PromotoresRepository>(); services.AddScoped <AtendimentosRepository>(); services.AddScoped <SituacaoRepository>(); // Configurando o JWT #region Jwt var signingConfigurations = new SigningConfig(); services.AddSingleton(signingConfigurations); var tokenConfigurations = new TokenConfig(); new ConfigureFromConfigurationOptions <TokenConfig>( Configuration.GetSection("TokenConfigurations")) .Configure(tokenConfigurations); services.AddSingleton(tokenConfigurations); services.AddAuthentication(authOptions => { authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }).AddJwtBearer(bearerOptions => { var paramsValidation = bearerOptions.TokenValidationParameters; paramsValidation.IssuerSigningKey = signingConfigurations.Key; paramsValidation.ValidAudience = tokenConfigurations.Audience; paramsValidation.ValidIssuer = tokenConfigurations.Issuer; paramsValidation.ValidateIssuerSigningKey = true; paramsValidation.ValidateLifetime = true; paramsValidation.ClockSkew = TimeSpan.Zero; }); services.AddAuthorization(auth => { auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder() .AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme) .RequireAuthenticatedUser().Build()); }); #endregion // Configurando o serviço de documentação do Swagger services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new OpenApiInfo { Title = "MPSP WEB API", Version = "v1" }); }); }
public void CanGenerateFileRenamesForSymbolBasedRenames_NonString() { //environment IEngineEnvironmentSettings environment = _environmentSettingsHelper.CreateEnvironment(); //simulate template files string sourceBasePath = FileSystemHelpers.GetNewVirtualizedPath(environment); IDictionary <string, string?> templateSourceFiles = new Dictionary <string, string?>(); // template.json templateSourceFiles.Add(TemplateConfigTestHelpers.DefaultConfigRelativePath, string.Empty); // content templateSourceFiles.Add("date_name.txt", null); templateSourceFiles.Add("other_name.txt", null); TestTemplateSetup setup = new TestTemplateSetup(environment, sourceBasePath, templateSourceFiles); setup.WriteSource(); //get target directory string targetDir = FileSystemHelpers.GetNewVirtualizedPath(environment); //prepare parameters ParameterSet parameters = new ParameterSet(SimpleConfigModel.FromJObject(environment, JObject.Parse("{}"))); Parameter nameParameter = new Parameter() { Name = "name" }; Parameter intDateParameter = new Parameter() { Name = "date" }; Parameter otherParameter = new Parameter() { Name = "other" }; parameters.AddParameter(nameParameter); parameters.AddParameter(intDateParameter); parameters.AddParameter(otherParameter); parameters.ResolvedValues[nameParameter] = "testName"; parameters.ResolvedValues[intDateParameter] = 20210429; parameters.ResolvedValues[otherParameter] = new TestParameterValueClass { A = "foo", B = "bar" }; //prepare renames configuration List <IReplacementTokens> symbolBasedRenames = new List <IReplacementTokens>(); symbolBasedRenames.Add(new ReplacementTokens("date", TokenConfig.FromValue("date"))); symbolBasedRenames.Add(new ReplacementTokens("other", TokenConfig.FromValue("other"))); symbolBasedRenames.Add(new ReplacementTokens("name", TokenConfig.FromValue("name"))); IReadOnlyDictionary <string, string> allChanges = setup.GetRenames("./", targetDir, parameters, symbolBasedRenames); Assert.Equal(2, allChanges.Count); Assert.Equal("20210429_testName.txt", allChanges["date_name.txt"]); Assert.Equal("foo-bar_testName.txt", allChanges["other_name.txt"]); }
public async Task <IHttpActionResult> Signout() { await WebApiService.Instance.PostAsync("Account/Signout"); var tokenConfig = TokenConfig.GetToken(); tokenConfig.RemoveTokenSession(); return(Ok()); }
public void ConfigureServices(IServiceCollection services) { services.AddTransient <UsuarioAcesso>(); services.AddTransient <AmigoDTO>(); services.AddTransient <Amigo>(); services.AddTransient <CalculoHistoricoLog>(); var signingConfigurations = new SigningConfigurations(); services.AddSingleton(signingConfigurations); var tokenConfig = new TokenConfig(); new ConfigureFromConfigurationOptions <TokenConfig>( Configuration.GetSection("TokenConfig")) .Configure(tokenConfig); services.AddSingleton(tokenConfig); services.AddMediatR(typeof(Startup)); services.AddAuthentication(authOptions => { authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }).AddJwtBearer(bearerOptions => { var paramsValidation = bearerOptions.TokenValidationParameters; paramsValidation.IssuerSigningKey = signingConfigurations.Key; paramsValidation.ValidAudience = tokenConfig.Audiencia; paramsValidation.ValidIssuer = tokenConfig.Emissor; paramsValidation.ValidateIssuerSigningKey = true; paramsValidation.ValidateLifetime = true; paramsValidation.ClockSkew = TimeSpan.Zero; }); services.AddAuthorization(auth => { auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder() .AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme) .RequireAuthenticatedUser().Build()); }); services.AddMvc(); services.AddSingleton <IUsuarioAcessoService, UsuarioAcessoService>(); services.AddSingleton <IAmigoService, AmigoService>(); services.AddSingleton <ICalculoHistoricoLogService, CalculoHistoricoLogService>(); services.AddSingleton <IUsuarioAcessoRepository, UsuarioAcessoRepository>(); services.AddSingleton <IAmigoRepository, AmigoRepository>(); services.AddSingleton <ICalculoHistoricoLogRepository, CalculoHistoricoLogRepository>(); Container.RegisterServices(services); }
public AccountController( SignInManager <IdentityUser> signInManager, UserManager <IdentityUser> userManager, IOptions <TokenConfig> tokenConfig) { _signInManager = signInManager; _userManager = userManager; _tokenConfig = tokenConfig.Value; }
public void CanGenerateFileRenamesForSymbolBasedRenames_WhenFormsResultInSameValue() { //environment IEngineEnvironmentSettings environment = TemplateConfigTestHelpers.GetTestEnvironment(); //simulate template files string sourceBasePath = FileSystemHelpers.GetNewVirtualizedPath(environment); IDictionary <string, string> templateSourceFiles = new Dictionary <string, string>(); // template.json templateSourceFiles.Add(TemplateConfigTestHelpers.DefaultConfigRelativePath, String.Empty); // content templateSourceFiles.Add("replace1_file.txt", null); templateSourceFiles.Add("replace2_file.txt", null); TestTemplateSetup setup = new TestTemplateSetup(environment, sourceBasePath, templateSourceFiles); setup.WriteSource(); //get target directory string targetDir = FileSystemHelpers.GetNewVirtualizedPath(environment); //prepare parameters ParameterSet parameters = new ParameterSet(SimpleConfigModel.FromJObject(environment, JObject.Parse("{}"))); Parameter nameParameter = new Parameter() { Name = "name" }; Parameter testParameterIdentity = new Parameter() { Name = "test{-VALUE-FORMS-}identity" }; Parameter testParameterLC = new Parameter() { Name = "test{-VALUE-FORMS-}lc" }; parameters.AddParameter(nameParameter); parameters.AddParameter(testParameterIdentity); parameters.AddParameter(testParameterLC); parameters.ResolvedValues[nameParameter] = "testName"; parameters.ResolvedValues[testParameterIdentity] = "testproject"; parameters.ResolvedValues[testParameterLC] = "testproject"; //prepare renames configuration List <IReplacementTokens> symbolBasedRenames = new List <IReplacementTokens>(); symbolBasedRenames.Add(new ReplacementTokens("test{-VALUE-FORMS-}identity", TokenConfig.FromValue("replace"))); symbolBasedRenames.Add(new ReplacementTokens("test{-VALUE-FORMS-}lc", TokenConfig.FromValue("replace"))); IReadOnlyDictionary <string, string> allChanges = setup.GetRenames("./", targetDir, parameters, symbolBasedRenames); Assert.Equal(2, allChanges.Count); Assert.Equal("testproject1_file.txt", allChanges["replace1_file.txt"]); Assert.Equal("testproject2_file.txt", allChanges["replace2_file.txt"]); }
public PropertyController(UserManager <ApplicationUser> userManager, IOptions <TokenConfig> tokenConfig, IStringLocalizer <SharedResources> localizer, IPropertyService propertyService ) : base(userManager, localizer) { _tokenConfig = tokenConfig.Value; _propertyService = propertyService; }
public EmailService( IOptions <EmailConfigs> emailConfigs, IOptions <TokenConfig> tokenConfig, UserManager <ApplicationUser> userManager ) { _emailConfigs = emailConfigs.Value; _tokenConfig = tokenConfig.Value; _userManager = userManager; }
public void Configuration(IAppBuilder app) { var config = new HttpConfiguration(); DIConfig.ConfigureInjector(config); RouteConfig.Register(config); TokenConfig.ConfigureOAuth(app, config); WebApiConfig.Register(config); app.UseWebApi(config); }
public AuthService( IUserRepository userRepository, SigningConfig signingConfig, TokenConfig tokenConfig ) { _userRepository = userRepository; _signingConfig = signingConfig; _tokenConfig = tokenConfig; }
public NomenclatureController(UserManager <ApplicationUser> userManager, IOptions <TokenConfig> tokenConfig, IStringLocalizer <SharedResources> localizer, INomenclatureService nomenclatureService ) : base(userManager, localizer) { _tokenConfig = tokenConfig.Value; _nomenclatureService = nomenclatureService; }
public AuthController( SignInManager <User> signInManager, UserManager <User> userManager, TokenConfig tokenConfig ) { _signInManager = signInManager; _userManager = userManager; _tokenConfig = tokenConfig; _secret = Encoding.ASCII.GetBytes(tokenConfig.Secret); }
public DistraintController(UserManager <ApplicationUser> userManager, IOptions <TokenConfig> tokenConfig, IStringLocalizer <SharedResources> localizer, IDistraintService distraintService ) : base(userManager, localizer) { _tokenConfig = tokenConfig.Value; _distraintService = distraintService; }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddMvc() .SetCompatibilityVersion(CompatibilityVersion.Version_2_2) .AddFluentValidation(fv => { fv.RunDefaultMvcValidationAfterFluentValidationExecutes = false; fv.ImplicitlyValidateChildProperties = true; }); var signingConfig = new SigningConfig(); services.AddSingleton(signingConfig); var tokenConfig = new TokenConfig(); new ConfigureFromConfigurationOptions <TokenConfig>(Configuration.GetSection("TokenConfig")) .Configure(tokenConfig); services.AddSingleton(tokenConfig); BootStrapper.Register(services); services.AddAuthentication(o => { o.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; o.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }).AddJwtBearer(options => { options.RequireHttpsMetadata = true; options.SaveToken = true; options.TokenValidationParameters = new TokenValidationParameters { ValidateLifetime = true, ValidateIssuer = true, ValidateAudience = true, ValidateIssuerSigningKey = true, ValidIssuer = tokenConfig.Issuer, ValidAudience = tokenConfig.Audience, IssuerSigningKey = signingConfig.Key, ClockSkew = TimeSpan.Zero }; }); services.AddAuthorization(auth => { auth.AddPolicy( "Bearer", new AuthorizationPolicyBuilder() .AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme) .RequireAuthenticatedUser() .Build() ); }); }
//private readonly IClaimService _claimService; //private readonly IApplicationSettingsCacheService _applicationSettingsCacheService; public AccountController(UserManager <ApplicationUser> userManager, IOptions <TokenConfig> tokenConfig, IStringLocalizer <SharedResources> localizer, IPersonService personService, IEmailService mailService ) : base(userManager, localizer) { _tokenConfig = tokenConfig.Value; _personService = personService; _emailService = mailService; }
public AuthController(INotificador notificador, SignInManager <IdentityUser> signInmanager, UserManager <IdentityUser> usermanager, IOptions <TokenConfig> tokenConfig, IUsuario usuario, ILogger <AuthController> logger) : base(notificador, usuario) { _signInmanager = signInmanager; _usermanager = usermanager; _tokenConfig = tokenConfig.Value; _logger = logger; }
public static IServiceCollection AddTelegramBotClient(this IServiceCollection services, TokenConfig tokenConfig, string serviceUrl) { var client = new TelegramBotClient(tokenConfig.Token); client.SetWebhookAsync(serviceUrl).Wait(); services.AddSingleton(client); return(services); }
public void ConfigureServices(IServiceCollection services) { #region Auth Config var signingConfigurations = new SigningConfig(); services.AddSingleton(signingConfigurations); var tokenConfig = new TokenConfig(); new ConfigureFromConfigurationOptions <TokenConfig>(Configuration.GetSection("TokenConfigurations")) .Configure(tokenConfig); services.AddSingleton(tokenConfig); services .AddAuthentication(options => { options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }) .AddJwtBearer(options => { var paramsValidation = options.TokenValidationParameters; paramsValidation.IssuerSigningKey = signingConfigurations.Key; paramsValidation.ValidAudience = tokenConfig.Audience; paramsValidation.ValidIssuer = tokenConfig.Issuer; paramsValidation.ValidateIssuerSigningKey = true; paramsValidation.ValidateLifetime = true; paramsValidation.ClockSkew = TimeSpan.Zero; }); services.AddAuthorization(auth => { var jwtAuth = new AuthorizationPolicyBuilder() .AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme) .RequireAuthenticatedUser().Build(); auth.AddPolicy("JwtBearer", jwtAuth); auth.DefaultPolicy = jwtAuth; }); #endregion services.AddDbContext <TaskTopContext>(options => options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"))); services.AddAutoMapper(config => Mapping.Initialize(config)); services.AddMvc(opt => opt.CoreMvc()) .AddJsonOptions(opt => opt.CoreJson()) .SetCompatibilityVersion(CompatibilityVersion.Version_2_1); services.AddCors(); }
public AuthService(UserManager <ApplicationUser> userManager, IOptions <TokenConfig> tokenConfig, IApplicationStoreService applicationStoreService, IEmailService emailService, IPersonService personService, IStringLocalizer <SharedResources> localizer) { _userManager = userManager; _tokenConfig = tokenConfig.Value; _applicationStoreService = applicationStoreService; _emailService = emailService; _personService = personService; _localizer = localizer; }