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;
}
