// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext <CoursesOnLineContext>(opt => {
opt.UseSqlServer(Configuration.GetConnectionString("Conexion"));
});
services.AddOptions();
services.Configure <ConnectionConfiguration>(Configuration.GetSection("ConnectionStrings"));
services.AddMediatR(typeof(Query.Handler).Assembly);
services.AddControllers(opt => {
var policy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
opt.Filters.Add(new AuthorizeFilter(policy));
})
.AddFluentValidation(cfg => cfg.RegisterValidatorsFromAssemblyContaining <New>());
var builder = services.AddIdentityCore <User>();
var identityBuilder = new IdentityBuilder(builder.UserType, builder.Services);
identityBuilder.AddRoles <IdentityRole>();
identityBuilder.AddClaimsPrincipalFactory <UserClaimsPrincipalFactory <User, IdentityRole> >();
identityBuilder.AddEntityFrameworkStores <CoursesOnLineContext>();
identityBuilder.AddSignInManager <SignInManager <User> >();
services.TryAddSingleton <ISystemClock, SystemClock>();
services.AddScoped <IJwtGenerator, JwtGenerator>();
services.AddScoped <IUserSession, UserSession>();
services.AddAutoMapper(typeof(Query.Handler));
services.AddTransient <IFactoryConnection, FactoryConnection>();
services.AddScoped <IInstructor, InstructorRepository>();
services.AddScoped <IPagination, PaginationRepository>();
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("1234567890 a very long word"));
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(opt => {
opt.TokenValidationParameters = new TokenValidationParameters {
ValidateIssuerSigningKey = true,
IssuerSigningKey = key,
ValidateAudience = false,
ValidateIssuer = false
};
});
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "Api Service Manteince of Course",
Version = "v1"
});
c.CustomSchemaIds(c => c.FullName);
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext <ContextoCurso>(options => options.UseSqlServer(Configuration.GetConnectionString("CursoConection")));
services.AddOptions();
services.Configure <DbConectionConfig>(Configuration.GetSection("ConnectionStrings"));
services.AddMediatR(typeof(Consulta.Manejador).Assembly);
services.AddControllers(opt => {
var policy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
opt.Filters.Add(new AuthorizeFilter(policy));
})
.AddFluentValidation(c => c.RegisterValidatorsFromAssemblyContaining <NuevoCurso>());
var builder = services.AddIdentityCore <Usuario>();
var identityBuilder = new IdentityBuilder(builder.UserType, builder.Services);
identityBuilder.AddRoles <IdentityRole>();
identityBuilder.AddClaimsPrincipalFactory <UserClaimsPrincipalFactory <Usuario, IdentityRole> >();
identityBuilder.AddEntityFrameworkStores <ContextoCurso>();
identityBuilder.AddSignInManager <SignInManager <Usuario> >();
services.TryAddSingleton <ISystemClock, SystemClock>();
services.AddScoped <IJwtGenerator, JwtGenerador>();
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("mipalabra esta es mi palabra secreta para autenticar"));
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(opt => opt.TokenValidationParameters
= new Microsoft.IdentityModel.Tokens.TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = key,
ValidateAudience = false,
ValidateIssuer = false
});
services.AddScoped <IUsuarioSesion, UsuarioSesion>();
services.AddAutoMapper(typeof(Consulta.Manejador));
services.AddTransient <IFactoryConection, FactoryConnection>();
services.AddScoped <IInstructor <InstructoModel>, InstructorRepository>();
services.AddSwaggerGen(a =>
{
a.SwaggerDoc("v1", new Microsoft.OpenApi.Models.OpenApiInfo
{
Title = "Servicios para mantenimiento de cursos",
Version = "v1"
});
a.CustomSchemaIds(c => c.FullName);
});
services.AddScoped <IPaginacion, PaginacionRespository>();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddCors(o => o.AddPolicy("corsApp", builder => {
builder.AllowAnyOrigin();
builder.AllowAnyMethod();
builder.AllowAnyHeader();
}));
services.AddDbContext <CursosOnlineContext>(opt => {
opt.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"));
});
services.AddControllers(opt => {
var policy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
opt.Filters.Add(new AuthorizeFilter(policy));
}
)
.AddFluentValidation(cfg => cfg.RegisterValidatorsFromAssemblyContaining <Nuevo>());
services.AddMediatR(typeof(Consulta.Manejador).Assembly);
//services.AddScoped(typeof(Consulta.Manejador));
var Builder = services.AddIdentityCore <Usuario>();
var IdentityBuilder = new IdentityBuilder(Builder.UserType, Builder.Services);
IdentityBuilder.AddRoles <IdentityRole>();
IdentityBuilder.AddClaimsPrincipalFactory <UserClaimsPrincipalFactory <Usuario, IdentityRole> >();
IdentityBuilder.AddEntityFrameworkStores <CursosOnlineContext>();
IdentityBuilder.AddSignInManager <SignInManager <Usuario> >();
services.TryAddSingleton <ISystemClock, SystemClock>();
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("Tileria palabra secreta 050"));
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(opt =>
{ opt.TokenValidationParameters = new TokenValidationParameters {
ValidateIssuerSigningKey = true,
IssuerSigningKey = key,
ValidateAudience = false,
ValidateIssuer = false
}; });
services.AddScoped <IJwtGenerador, JwtGenerador>();
services.AddScoped <IUsuarioSesion, UsuarioSesion>();
services.AddAutoMapper(typeof(Consulta.Manejador));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext <SistemaTaxisContext>(opt =>
{
opt.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"));
});
var builder = services.AddIdentityCore <Usuario>();
var identityBuilder = new IdentityBuilder(builder.UserType, builder.Services);
identityBuilder.AddRoles <IdentityRole>();
identityBuilder.AddClaimsPrincipalFactory <UserClaimsPrincipalFactory <Usuario, IdentityRole> >();
identityBuilder.AddEntityFrameworkStores <SistemaTaxisContext>();
identityBuilder.AddSignInManager <SignInManager <Usuario> >();
services.TryAddSingleton <ISystemClock, SystemClock>();
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("Mi Palabra Secreta"));
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(opt =>
{
opt.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = key,
ValidateAudience = false,
ValidateIssuer = false
};
});
services.AddScoped <IJwtGenerator, JwtGenerator>();
services.AddScoped <IUsuarioSesion, UsuarioSesion>();
services.AddAutoMapper(typeof(ChoferController));
services.AddControllersWithViews();
services.AddControllers().AddNewtonsoftJson(options =>
options.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore);
// In production, the Angular files will be served from this directory
services.AddSpaStaticFiles(configuration =>
{
configuration.RootPath = "ClientApp/dist";
});
}
/// <summary>
/// Configures the identity builder with ElasticIdentity components,
/// and registers dependencies for that component which have not already been
/// registered.
/// </summary>
/// <param name="elasticClient">
/// The <see cref="IElasticClient"/> which will be used by the <see cref="ElasticUserStore"/>.
/// </param>
public static IdentityBuilder AddElasticIdentity(this IdentityBuilder identityBuilder,
IElasticClient elasticClient)
{
identityBuilder.AddUserStore <ElasticUserStore <string, ElasticIdentityUser> >();
identityBuilder.AddRoleStore <ElasticIdentityUserRole>();
identityBuilder.AddUserValidator <UserValidator <ElasticIdentityUser> >();
identityBuilder.AddPasswordValidator <PasswordValidator <ElasticIdentityUser> >();
identityBuilder.AddSignInManager <SignInManager <ElasticIdentityUser> >();
identityBuilder.AddUserManager <UserManager <ElasticIdentityUser> >();
identityBuilder.AddClaimsPrincipalFactory <UserClaimsPrincipalFactory <ElasticIdentityUser> >();
identityBuilder.AddErrorDescriber <IdentityErrorDescriber>();
identityBuilder.Services.TryAddSingleton <IElasticClient>(elasticClient);
identityBuilder.Services.TryAddSingleton <IPasswordHasher <ElasticIdentityUser>, PasswordHasher <ElasticIdentityUser> >();
//identityBuilder.Services.TryAddSingleton<ILookupNormalizer, LowerInvariantLookupNormalizer>();
identityBuilder.Services.TryAddSingleton <ISecurityStampValidator, SecurityStampValidator <ElasticIdentityUser> >();
return(identityBuilder);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// builder va a permitir consumir cualquier endpoint del proyecto para cualquier cliente
services.AddCors(o => o.AddPolicy("corsApp", builder => {
builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader();
}));
services.AddDbContext <CursosOnLineContext>(opt =>
{
opt.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"));
});
// Instanciar que se lance IFactoryConnection y IInstructor al arrancar el proyecto
services.AddOptions();
// Conexión a dapper
services.Configure <ConexionConfiguracion>(Configuration.GetSection("ConnectionStrings"));
services.AddMediatR(typeof(Consulta.Manejador).Assembly);
// La modificación de debajo es para incluir la librería FluentValidation
// services.AddControllers();
services.AddControllers(opt => {
var policy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
opt.Filters.Add(new AuthorizeFilter(policy));
})
.AddFluentValidation(cfg => cfg.RegisterValidatorsFromAssemblyContaining <Nuevo>());
// incluimos Core Identity <54> en WebAPI
var builder = services.AddIdentityCore <Usuario>();
var identityBuilder = new IdentityBuilder(builder.UserType, builder.Services);
// Incluir roles
identityBuilder.AddRoles <IdentityRole>();
identityBuilder.AddClaimsPrincipalFactory <UserClaimsPrincipalFactory <Usuario, IdentityRole> >();
identityBuilder.AddEntityFrameworkStores <CursosOnLineContext>();
identityBuilder.AddSignInManager <SignInManager <Usuario> >();
services.TryAddSingleton <ISystemClock, SystemClock>();
// Instanciar que se lance IFactoryConnection y IInstructor al arrancar el proyecto
services.AddTransient <IFactoryConection, FactoryConnection>();
services.AddScoped <IInstructor, InstructorRepositorio>();
// Soportar Swagger
services.AddSwaggerGen(c => {
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "Servicio de mantenimiento de cursos.",
Version = "v1"
});
c.CustomSchemaIds(c => c.FullName);
});
// Incluir seguridad del Token (posterior a JWT)
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("Mi palabra secreta"));
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(opt => {
opt.TokenValidationParameters = new TokenValidationParameters {
ValidateIssuerSigningKey = true,
IssuerSigningKey = key,
ValidateAudience = false,
ValidateIssuer = false
};
});
// JWT JSON Web Tokens
services.AddScoped <IJwtGenerador, JwtGenerador>();
services.AddScoped <IUsuarioSesion, UsuarioSesion>();
services.AddAutoMapper(typeof(Consulta.Manejador));
// Instanciar que se lance IFactoryConnection y al arrancar el proyecto
services.AddTransient <IFactoryConection, FactoryConnection>();
services.AddScoped <IInstructor, InstructorRepositorio>();
// Instanciar paginación
services.AddScoped <IPaginacion, PaginacionRepositorio>();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddCors(o => o.AddPolicy("corsApp", builder =>
{
builder.AllowAnyOrigin();
builder.AllowAnyMethod();
builder.AllowAnyHeader();
}));
services.AddDbContext <GestionContext>(opt =>
{
opt.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"));
});
services.AddOptions();
services.Configure <ConexionConfiguracion>(Configuration.GetSection("ConnectionStrings"));
services.AddMediatR(typeof(Consulta.Manejador).Assembly);
services.AddControllers(opt => {
var policy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
opt.Filters.Add(new AuthorizeFilter(policy));
})
.AddFluentValidation(cfg => cfg.RegisterValidatorsFromAssemblyContaining <Nuevo>());
var builder = services.AddIdentityCore <Usuarios>();
var identityBuilder = new IdentityBuilder(builder.UserType, builder.Services);
identityBuilder.AddRoles <IdentityRole>();
identityBuilder.AddClaimsPrincipalFactory <UserClaimsPrincipalFactory <Usuarios, IdentityRole> >();
identityBuilder.AddEntityFrameworkStores <GestionContext>();
identityBuilder.AddSignInManager <SignInManager <Usuarios> >();
services.TryAddSingleton <ISystemClock, SystemClock>();
services.AddAuthentication(options => { options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme; })
.AddCookie(options => {
options.LoginPath = "/Account/Unauthorized/";
options.AccessDeniedPath = "/Account/Forbidden/";
})
.AddJwtBearer(cfg =>
{
cfg.TokenValidationParameters = new TokenValidationParameters
{
ValidIssuer = this.Configuration["Tokens:Issuer"],
ValidAudience = this.Configuration["Tokens:Audience"],
IssuerSigningKey = new SymmetricSecurityKey(
Encoding.UTF8.GetBytes(
this.Configuration["Tokens:Key"]))
};
});
services.AddScoped <IJwtGenerador, JwtGenerador>();
services.AddScoped <IUsuarioSesion, UsuarioSesion>();
services.AddAutoMapper(typeof(Consulta.Manejador));
services.AddTransient <IFactoryConnection, FactoryConnection>();
services.AddScoped <ICliente, ClienteRepositorio>();
services.AddScoped <IPaginacion, PaginacionRepositorio>();
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Microsoft.OpenApi.Models.OpenApiInfo
{
Title = "Sistema de Gestion",
Version = "v1"
});
c.CustomSchemaIds(c => c.FullName);
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
#region Context DB
services
.AddDbContext <CoursesOnlineContext>(opt =>
{
opt.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"));
});
#endregion
//Config Dapper
services.AddOptions();
services.Configure <ConnectConfiguration>(Configuration.GetSection("ConnectionStrings"));
#region Configuration MediatR
services.AddMediatR(typeof(Consult.Handler).Assembly);
// services.AddMediatR(AppDomain.CurrentDomain.GetAssemblies());
#endregion
#region AddFluentValidation
//Configuration Unatorized 401 for all methods
services.AddControllers(opt => {
var policy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
opt.Filters.Add(new AuthorizeFilter(policy));
})
.AddFluentValidation(cfg =>
{
cfg.RegisterValidatorsFromAssembly(Assembly.GetExecutingAssembly());
});
#endregion
#region Core Identity
//Configure Core Identity
var builder = services.AddIdentityCore <User>();
var identityBuilder = new IdentityBuilder(builder.UserType, builder.Services);
// Add new Role CoreIdentity
identityBuilder.AddRoles <IdentityRole>();
identityBuilder.AddClaimsPrincipalFactory <UserClaimsPrincipalFactory <User, IdentityRole> >();
identityBuilder.AddEntityFrameworkStores <CoursesOnlineContext>();
identityBuilder.AddSignInManager <SignInManager <User> >();
services.TryAddSingleton <ISystemClock, SystemClock>();
#endregion
// Config Security Controller
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("This is muy secret word"));
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(opt =>
{
opt.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = key,
//Changes this for Company private IP
ValidateAudience = false,
// for some ips
ValidateIssuer = false
};
});
//Jwt Generator
services.AddScoped <IJwtGenerator, JwtGenerator>();
services.AddScoped <IUserSession, UserSession>();
//Automapper
// services.AddAutoMapper(typeof(MappingProfile));
services.AddAutoMapper(typeof(Consult));
// services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies());
// initialize dapper connection
services.AddTransient <IFactoryConnection, FactoryConnection>();
// interface instructors
services.AddScoped <IInstructor, InstructorRepository>();
services.AddScoped <IPagination, PaginationRepository>();
//Swagger
services.AddSwaggerGen(c => {
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "Service Courses",
Version = "v1"
});
c.CustomSchemaIds(c => c.FullName);
});
}
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext <CoursesContext> (options => {
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"));
});
services.AddOptions();
services.Configure <ConnectionConfig>(Configuration.GetSection("ConnectionStrings"));
services.AddMediatR(typeof(Query.Handler).Assembly);
services.AddControllers(opt => {
var policy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
opt.Filters.Add(new AuthorizeFilter(policy));
}).AddFluentValidation(config => config.RegisterValidatorsFromAssemblyContaining <Create>());
//Auth con Identity
var builder = services.AddIdentityCore <User>();
var identityBuilder = new IdentityBuilder(builder.UserType, builder.Services);
identityBuilder.AddRoles <IdentityRole>();
identityBuilder.AddClaimsPrincipalFactory <UserClaimsPrincipalFactory <User, IdentityRole> >();
identityBuilder.AddEntityFrameworkStores <CoursesContext>();
identityBuilder.AddSignInManager <SignInManager <User> >();
services.TryAddSingleton <ISystemClock, SystemClock>();
services.Configure <IdentityOptions>(options =>
{
options.Password.RequireDigit = false;
options.Password.RequireUppercase = false;
options.Password.RequireNonAlphanumeric = false;
options.Password.RequiredLength = 4;
});
//Mapper
services.AddAutoMapper(typeof(Query.Handler));
// JWT
services.AddScoped <IJwtGenerator, JwtGenerator>();
services.AddScoped <IUserSession, UserSession>();
// Repository
services.AddTransient <IFactoryConnection, FactoryConnection>();
services.AddScoped <ITeacherRepository, TeacherRepository>();
services.AddScoped <IPagination, PaginationRepository>();
services.AddSwaggerGen(opt => {
opt.SwaggerDoc("v1", new OpenApiInfo {
Title = "Servicios para mantenimiento de cursos",
Version = "v1"
});
// Toma las clases que reciben los datos desde los controladores junto con el namespace
// para no confundirse al encontrar clases con el mismo nombre
opt.CustomSchemaIds(s => s.FullName);
});
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("Mi llave secreta"));
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(opt => {
opt.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = key,
ValidateIssuer = false,
ValidateAudience = false
};
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var connectionString = Configuration.GetConnectionString("DefaultConnection");
services.AddDbContext <ApplicationDbContext>(options =>
options.UseSqlServer(connectionString));
// services.AddIdentity<ApplicationUser, IdentityRole>(options =>
// {
// // Password settings.
// options.Password.RequireDigit = true;
// options.Password.RequiredLength = 8;
// options.Password.RequireNonAlphanumeric = false;
// options.Password.RequireUppercase = true;
// options.Password.RequireLowercase = false;
// // Lockout settings.
// options.Lockout.AllowedForNewUsers = true;
// options.Lockout.MaxFailedAccessAttempts = 3;
// options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromDays(1);
// }
// )
// .AddEntityFrameworkStores<ApplicationDbContext>()
// .AddDefaultTokenProviders();
// Identity options.
// services.Configure<IdentityOptions>(options =>
// {
// // Password settings.
// options.Password.RequireDigit = true;
// options.Password.RequiredLength = 8;
// options.Password.RequireNonAlphanumeric = false;
// options.Password.RequireUppercase = true;
// options.Password.RequireLowercase = false;
// // Lockout settings.
// options.Lockout.AllowedForNewUsers = true;
// options.Lockout.MaxFailedAccessAttempts = 3;
// options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromDays(1);
// });
IdentityBuilder builder = services.AddIdentityCore <IdentityUser>(options =>
{
// Password settings.
options.Password.RequireDigit = true;
options.Password.RequiredLength = 8;
options.Password.RequireNonAlphanumeric = false;
options.Password.RequireUppercase = true;
options.Password.RequireLowercase = false;
// Lockout settings.
options.Lockout.AllowedForNewUsers = true;
options.Lockout.MaxFailedAccessAttempts = 3;
options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromDays(1);
}
);
//builder = new IdentityBuilder(builder.UserType, typeof(IdentityRole), builder.Services);
builder.AddEntityFrameworkStores <ApplicationDbContext>();
builder.AddRoleValidator <RoleValidator <IdentityRole> >();
builder.AddRoleManager <RoleManager <IdentityRole> >();
builder.AddSignInManager <SignInManager <IdentityUser> >();
//builder.AddUserManager<UserManager<ApplicationUser>>();
builder.AddDefaultTokenProviders();
builder.AddUserStore <ApplicationUser>();
builder.AddClaimsPrincipalFactory <ApplicationUser>();
//services.AddScoped<IUserStore<ApplicationUser>, UserStore<ApplicationUser>>();
//services.AddScoped<IUserClaimsPrincipalFactory<ApplicationUser>, UserClaimsPrincipalFactory<ApplicationUser>>();
//services.AddScoped<UserManager<ApplicationUser>>();
// Role based Authorization: policy based role checks.
services.AddAuthorization(options =>
{
// Policy for dashboard: only administrator role.
options.AddPolicy("Manage Accounts", policy => policy.RequireRole("administrator"));
// Policy for resources: user or administrator roles.
options.AddPolicy("Access Resources", policy => policy.RequireRole("administrator", "user"));
});
// Adds application services.
services.AddTransient <IEmailSender, EmailSender>();
services.AddTransient <IDbInitializer, DbInitializer>();
var migrationsAssembly = typeof(Startup).GetTypeInfo().Assembly.GetName().Name;
// Adds IdentityServer.
services.AddIdentityServer()
// The AddDeveloperSigningCredential extension creates temporary key material for signing tokens.
// This might be useful to get started, but needs to be replaced by some persistent key material for production scenarios.
// See http://docs.identityserver.io/en/release/topics/crypto.html#refcrypto for more information.
//.AddDeveloperSigningCredential()
.AddSigningCredential(Certificate.Get())
.AddAspNetIdentity <ApplicationUser>() // IdentityServer4.AspNetIdentity.
//.AddInMemoryPersistedGrants()
// To configure IdentityServer to use EntityFramework (EF) as the storage mechanism for configuration data (rather than using the in-memory implementations),
// see https://identityserver4.readthedocs.io/en/release/quickstarts/8_entity_framework.html
//.AddInMemoryIdentityResources(Config.GetIdentityResources())
//.AddInMemoryApiResources(Config.GetApiResources())
//.AddInMemoryClients(Config.GetClients())
.AddConfigurationStore(options =>
{
options.ConfigureDbContext = obuilder =>
obuilder.UseSqlServer(connectionString,
sql => sql.MigrationsAssembly(migrationsAssembly));
})
// this adds the operational data from DB (codes, tokens, consents)
.AddOperationalStore(options =>
{
options.ConfigureDbContext = obuilder =>
obuilder.UseSqlServer(connectionString,
sql => sql.MigrationsAssembly(migrationsAssembly));
// this enables automatic token cleanup. this is optional.
options.EnableTokenCleanup = true;
options.TokenCleanupInterval = 3600;
});
// if (currentEnvironment.IsProduction())
// {
// else
// {
// }
/////////AddAuthentication will send cookie, replace with AddIdentityCore
services.AddAuthentication(IdentityServerAuthenticationDefaults.AuthenticationScheme)
.AddIdentityServerAuthentication(options =>
{
options.Authority = "http://localhost:5000/";
options.RequireHttpsMetadata = false;
options.ApiName = "WebAPI";
});
services.AddMvc();
services.AddCors();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
//Agrego CORS cuando ya voy a trabajar con el front que esta en otra app
services.AddCors(o => o.AddPolicy("corsApp", builder => {
builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader();
}));
//This is for EFCore
services.AddDbContext <CursosOnlineContext>(opt => {
opt.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"));
});
//This is for Dapper. Adding connection for dapper.
services.AddOptions();
services.Configure <ConexionConfiguracion>(Configuration.GetSection("ConnectionStrings"));
services.AddMediatR(typeof(Consulta.Manejador).Assembly);
//Agrego el AddFluentValidation y el using de la libreria para las validaciones.
//Luego al addController le paso las politicas para filtrar y chequear que se acceda con token, con authorizacion.
services.AddControllers(opt => {
var policy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
opt.Filters.Add(new AuthorizeFilter(policy));
})
.AddFluentValidation(cfg => cfg.RegisterValidatorsFromAssemblyContaining <Nuevo>());
//Agrego un builder y un identityBuilder y le asigno un store...
var builder = services.AddIdentityCore <Usuario>();
var identityBuilder = new IdentityBuilder(builder.UserType, builder.Services);
//Agrego la siguiente linea para manejar el tema de roles. Instancio el servicio de RoleManager.
identityBuilder.AddRoles <IdentityRole>();
identityBuilder.AddClaimsPrincipalFactory <UserClaimsPrincipalFactory <Usuario, IdentityRole> >();
identityBuilder.AddEntityFrameworkStores <CursosOnlineContext>();
//Le indico que quien va manejar el login va ser coreIdentity
identityBuilder.AddSignInManager <SignInManager <Usuario> >();
//
services.TryAddSingleton <ISystemClock, SystemClock>();
//Agrego la seguridad, para que no me deje consumir los controllers si no tengo un token.
//Ademas agregar en el configure que uso autentication
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("Mi palabra secreta"));
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(opt => {
//Aqui puedo indicar de donde acepto el token/las llamadas por ejemplo. Restricciones de url/dns.
opt.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = key,
ValidateAudience = false, //Esta abierto para cualquiera, si es algo cerrado deberia poner el ip de donde pueden acceder
ValidateIssuer = false //Valida quien dio el token
};
});
//Agrego el servicio del generador de token para jwt
//Haciendo esta inyection de servicios webapi para poder ingresar a los servicios del generador de token.
services.AddScoped <IJwtGenerador, JwtGenerador>();
//Agrego el servicio que me devuelve el usuario actual.
services.AddScoped <IUsuarioSesion, UsuarioSesion>();
services.AddAutoMapper(typeof(Consulta.Manejador));
services.AddTransient <IFactoryConnection, FactoryConnection>();
services.AddScoped <IInstructor, InstructorRepositorio>();
services.AddScoped <IPaginacion, PaginacionRepositorio>();
//Agregado para incluir swagger
services.AddSwaggerGen(c => {
c.SwaggerDoc("v1", new OpenApiInfo
{
Title = "Services para mantenimiento de cursos",
Version = "v1"
});
//Le indico que tome todo el nombre de las clases (con namespace), sino me va dar error porque tengo en aplicación varios similares-> Nuevo.Ejecuta por ejem.
c.CustomSchemaIds(x => x.FullName);
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers().AddNewtonsoftJson(options => // evita la referencia circular
{
options.SerializerSettings.ContractResolver = new DefaultContractResolver();
options.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
})
.AddFluentValidation(s => // registra el validador para todas las clases que hereden de AbstractValidator
{
s.RegisterValidatorsFromAssemblyContaining <Users>();
s.RunDefaultMvcValidationAfterFluentValidationExecutes = false;
});
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "JwtIdentityApi", Version = "v1"
});
});
services.AddDbContext <ApplicationDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
var builder = services.AddIdentityCore <Users>();
var identityBuilder = new IdentityBuilder(builder.UserType, builder.Services).AddDefaultTokenProviders();
identityBuilder.AddRoles <IdentityRole>();
identityBuilder.AddClaimsPrincipalFactory <UserClaimsPrincipalFactory <Users, IdentityRole> >();
identityBuilder.AddEntityFrameworkStores <ApplicationDbContext>();
identityBuilder.AddSignInManager <SignInManager <Users> >();
//jwt
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("YouSecretApiKeyString"));
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(opt => {
opt.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = key,
ValidateAudience = false,
ValidateIssuer = false
};
});
//Serilog
services.AddSingleton <Serilog.ILogger>(options =>
{
var connString = Configuration["Serilog:DefaultConnection"];
var tableName = Configuration["Serilog:TableName"];
return(new LoggerConfiguration()
.WriteTo.MSSqlServer(
connectionString: connString,
sinkOptions: new MSSqlServerSinkOptions
{
TableName = tableName,
SchemaName = "dbo",
AutoCreateSqlTable = true
}).CreateLogger());
});
//services
services.AddScoped <IIdentityRepo, IdentityRepo>();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
//para utilizar cors
services.AddCors(o => o.AddPolicy("corsApp", builder => {
builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader();
}));
//cadena de conexion
services.AddDbContext <CursosOnlineContext>(opt => {
opt.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"));
});
//dapper para pasarle la cadena de conexion a la clase
services.AddOptions();
services.Configure <ConexionConfiguracion>(Configuration.GetSection("ConnectionStrings"));
//MediatR
services.AddMediatR(typeof(Consulta.Handler).Assembly);
//para q requiera en los endpoints q el usuario este autorizado
services.AddControllers(opt => {
var policy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
opt.Filters.Add(new AuthorizeFilter(policy));
})
.AddFluentValidation(configure => configure.RegisterValidatorsFromAssemblyContaining <Nuevo>());
//configuracion del core identity
var builder = services.AddIdentityCore <Usuario>();
var identityBuilder = new IdentityBuilder(builder.UserType, builder.Services);
identityBuilder.AddRoles <IdentityRole>(); //para manejo de roles seecion 17
identityBuilder.AddClaimsPrincipalFactory <UserClaimsPrincipalFactory <Usuario, IdentityRole> >(); //para manejar token con roles seccion 17
identityBuilder.AddEntityFrameworkStores <CursosOnlineContext>();
identityBuilder.AddSignInManager <SignInManager <Usuario> >(); //administrador de login de accesos
//para registrar el usuario
services.TryAddSingleton <ISystemClock, SystemClock>();
//para q los enpoints necesiten la autenticacion
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("Mi palabra secreta"));
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(opt => {
opt.TokenValidationParameters = new TokenValidationParameters {
ValidateIssuerSigningKey = true, //cualquier tipo de request debe ser validado
IssuerSigningKey = key,
ValidateAudience = false, //para q cualquiera pueda hacer request
ValidateIssuer = false //para enviar a cualquiera
};
});
//inyectar el jwtgenerador
services.AddScoped <IJwtGenerador, JwtGenerador>();
//para poder usar la interfaz de usuariosesion
services.AddScoped <IUsuarioSesion, UsuarioSesion>();
//para q funcione el mapper
services.AddAutoMapper(typeof(Consulta.Handler));
//para poder usar el dapper
services.AddTransient <IFactoryConnection, FactoryConnection>();
services.AddScoped <IInstructor, InstructorRepositorio>();
//para usar la paginacion
services.AddScoped <IPaginacion, PaginacionRepositorio>();
//para usar swagger
services.AddSwaggerGen(c => {
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "Servicios para mantenimiento de cursos",
Version = "v1"
});
c.CustomSchemaIds(c => c.FullName);//para evitar conflictos usa el namespace
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddCors(o => o.AddPolicy("corsApp", builder => {
builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader();
}));
services.AddDbContext <PruebaBdContext>(opt =>
{
opt.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"));
});
var builder = services.AddIdentityCore <Usuario>();
var idenitityBuilder = new IdentityBuilder(builder.UserType, builder.Services);
idenitityBuilder.AddRoles <IdentityRole>();
idenitityBuilder.AddClaimsPrincipalFactory <UserClaimsPrincipalFactory <Usuario, IdentityRole> >();
idenitityBuilder.AddEntityFrameworkStores <PruebaBdContext>();
idenitityBuilder.AddSignInManager <SignInManager <Usuario> >();
services.TryAddSingleton <ISystemClock, SystemClock>();
services.AddScoped <IJWT, JWTGenerador>();
services.AddMediatR(Assembly.Load("PruebaPWC.Application"));
services.Configure <IdentityOptions>(options =>
{
options.Password.RequireDigit = false;
options.Password.RequiredLength = 4;
options.Password.RequireLowercase = true;
options.Password.RequireNonAlphanumeric = false;
options.Password.RequireUppercase = false;
});
services.AddHttpContextAccessor();
services.AddControllers(opt =>
{
//var policy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
//opt.Filters.Add(new AuthorizeFilter(policy));
}).AddJsonOptions(options2 =>
options2.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter()))
.AddNewtonsoftJson(options1 =>
options1.SerializerSettings.Converters.Add(new StringEnumConverter()))
.AddNewtonsoftJson(options =>
options.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore);;
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "PRUEBA", Version = "v1"
});
c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
Description = @"JWT Authorization header using the Bearer scheme. \r\n\r\n
Enter 'Bearer' [space] and then your token in the text input below.
\r\n\r\nExample: 'Bearer 12345abcdef'",
Name = "Authorization",
In = ParameterLocation.Header,
Type = SecuritySchemeType.ApiKey,
Scheme = "Bearer"
});
c.AddSecurityRequirement(new OpenApiSecurityRequirement()
{
{
new OpenApiSecurityScheme
{
Reference = new OpenApiReference
{
Type = ReferenceType.SecurityScheme,
Id = "Bearer"
},
Scheme = "oauth2",
Name = "Bearer",
In = ParameterLocation.Header,
},
new List <string>()
}
});
c.ResolveConflictingActions(apiDescriptions => apiDescriptions.First());
var currentAssembly = Assembly.GetExecutingAssembly();
var xmlDocs = currentAssembly.GetReferencedAssemblies()
.Union(new AssemblyName[] { currentAssembly.GetName() })
.Select(a => Path.Combine(Path.GetDirectoryName(currentAssembly.Location), $"{a.Name}.xml"))
.Where(File.Exists).ToArray();
Array.ForEach(xmlDocs, (d) =>
{
c.IncludeXmlComments(d);
});
});
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("this is my custom Secret key for authnetication"));
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(opt => {
opt.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = key,
ValidateAudience = false,
ValidateIssuer = false
};
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// * Se habilita CORS
services.AddCors(opt => opt.AddPolicy("corsApp", builder =>
{
builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader();
}));
// Se configura servicio para la base de datos
services.AddDbContext <CursosOnlineContext>(opt =>
{
opt.UseSqlServer(Configuration.GetConnectionString("CursosOnline"));
});
// * Cadena de Conexion para Dapper
services.AddOptions();
services.Configure <DapperConfiguracion>(Configuration.GetSection("ConnectionStrings"));
//Se configura el manejador MediatR
services.AddMediatR(typeof(Consulta.Manejador).Assembly);
services.AddControllers(opt =>
{
//Se exige que todos los controllers esten autenticados
var policy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
opt.Filters.Add(new AuthorizeFilter(policy));
})
//Se configura el validador para todos los controllers
.AddFluentValidation(cfg => cfg.RegisterValidatorsFromAssemblyContaining <Nuevo>())
//
.AddJsonOptions(jsonOptions =>
{
jsonOptions.JsonSerializerOptions.PropertyNamingPolicy = null;
});
// Se configura el IdentityCore
var builder = services.AddIdentityCore <Usuario>();
var identityBuilder = new IdentityBuilder(builder.UserType, builder.Services);
// * configuracion para manejo de roles
identityBuilder.AddRoles <IdentityRole>();
identityBuilder.AddClaimsPrincipalFactory <UserClaimsPrincipalFactory <Usuario, IdentityRole> >();
//
identityBuilder.AddEntityFrameworkStores <CursosOnlineContext>();
identityBuilder.AddSignInManager <SignInManager <Usuario> >();
services.TryAddSingleton <ISystemClock, SystemClock>();
//Se configura el tipo de autenticacion
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("Mi palabra secreta"));
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(opt =>
{
opt.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = key,
ValidateAudience = false,
ValidateIssuer = false,
ClockSkew = TimeSpan.Zero
};
});
//Se configura servicio para JWT
services.AddScoped <IJwtGenerador, JwtGenerador>();
services.AddScoped <IUsuarioSesion, UsuarioSesion>();
services.AddAutoMapper(typeof(Consulta.Manejador));
// Dapper
services.AddTransient <IFactoryConnection, FactoryConnection>();
services.AddScoped <IInstructor, InstructorRepositorio>();
services.AddScoped <IPaginacion, PaginacionRepositorio>();
// * Se configura servicios de Swagger
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "Servicio para mantenimiento de cursos", Version = "v1"
});
c.CustomSchemaIds(c => c.FullName);
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddCors(o => o.AddPolicy("corsApp", builder =>
{
builder.AllowAnyOrigin();
builder.AllowAnyMethod();
builder.AllowAnyHeader();
}));
services.AddDbContext <CursosContext>(opt => {
opt.UseSqlServer("Server=MSI\\SQLEXPRESS;Database=CursosOnline;User Id=magdiel;password=89878magdiel;Pooling=True;");
});
services.AddOptions();
services.Configure <ConexionConfiguracion>(Configuration.GetSection("ConecctionStrings"));
services.AddMediatR(typeof(Consulta.Manejador).Assembly);
services.AddControllers(opt =>
{
var policy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
opt.Filters.Add(new AuthorizeFilter(policy));
})
.AddFluentValidation(
cfg => cfg.RegisterValidatorsFromAssemblyContaining <Nuevo>());
var builder = services.AddIdentityCore <Usuario>();
var identityBuilder = new IdentityBuilder(builder.UserType, builder.Services);
identityBuilder.AddRoles <IdentityRole>();
identityBuilder.AddClaimsPrincipalFactory <UserClaimsPrincipalFactory <Usuario, IdentityRole> >();
identityBuilder.AddEntityFrameworkStores <CursosContext>();
identityBuilder.AddSignInManager <SignInManager <Usuario> >();
services.TryAddSingleton <ISystemClock, SystemClock>();
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("Mi palabra secreta"));
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(opt =>
{
opt.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = key,
ValidateAudience = false,
ValidateIssuer = false
};
});
services.AddScoped <IJwtGenerador, JwtGenerador>();
services.AddScoped <IUsuarioSesion, UsuarioSesion>();
services.AddAutoMapper(typeof(Consulta.Manejador));
services.AddTransient <IFactoryConnection, FactoryConnection>();
services.AddScoped <IInstructor, InstructorRepositorio>();
services.AddScoped <IPaginacion, PaginacionRespoitorio>();
//Documentación
services.AddSwaggerGen(doc =>
{
doc.SwaggerDoc("v1", new OpenApiInfo
{
Title = "Servicio para mantenimiento de cursos",
Version = "v1"
});
//var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
//var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
doc.CustomSchemaIds(c => c.FullName);
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddCors(o => o.AddPolicy("corsApp", builder =>
{
builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader();
}));
services.AddDbContext <AppDBContext>(opt =>
{
opt.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"), b => b.MigrationsAssembly("Persistence"));
});
services.AddOptions();
services.Configure <ConnConfig>(Configuration.GetSection("ConnectionStrings"));
services.AddMediatR(typeof(QueryAll.Handler).Assembly);
// ES NECESARIO AGREGAR LOS MEDIATR CON ESTRUCTURAS DIFERENTES
services.AddMediatR(typeof(Login.Handler).Assembly);
services.AddControllers(opt =>
{
var policy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
opt.Filters.Add(new AuthorizeFilter(policy));
})
.AddFluentValidation(cfg => cfg.RegisterValidatorsFromAssemblyContaining <NewCourse>());
services.TryAddSingleton <ISystemClock, SystemClock>();
var authBuilder = services.AddIdentityCore <User>();
var identityBuilder = new IdentityBuilder(authBuilder.UserType, authBuilder.Services);
identityBuilder.AddRoles <IdentityRole>();
identityBuilder.AddClaimsPrincipalFactory <UserClaimsPrincipalFactory <User, IdentityRole> >();
identityBuilder.AddEntityFrameworkStores <AppDBContext>();
identityBuilder.AddSignInManager <SignInManager <User> >();
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(opt => opt.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(Encoding.Unicode.GetBytes("Palabra secreta")),
ValidateAudience = false,
ValidateIssuer = false
});
services.AddScoped <IJWTGenerator, JWTGenerator>();
services.AddScoped <ISessionUser, SessionUser>();
services.AddAutoMapper(typeof(QueryAll));
services.AddTransient <IFactoryConnection, FactoryConnection>();
services.AddScoped <IInstructorRepo, InstructorRepo>();
services.AddScoped <IPagination, PaginationRepo>();
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo
{
Title = "Cursos Breves",
Version = "v1"
});
c.CustomSchemaIds(c => c.FullName);
var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
c.IncludeXmlComments(xmlPath);
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext <CursosOnlineContext>(opt => {
opt.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"));
});
//Agregar el Dapper
services.AddOptions();
services.Configure <ConexionConfiguracion>(Configuration.GetSection("connectionStrings"));
services.AddMediatR(typeof(Consulta.Manejador).Assembly);
//services.AddControllers(); asi estaba pero ahora se le agrega el fluentvalidation ¡h
//opt => ... es para validar la Autorizacion de el token para los metodos
services.AddControllers(opt => {
var policy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
opt.Filters.Add(new AuthorizeFilter(policy));
})
.AddFluentValidation(cfv => cfv.RegisterValidatorsFromAssemblyContaining <Nuevo>());
//Configuracion IdentityCore
var builder = services.AddIdentityCore <Usuario>();
var IdentityBuilder = new IdentityBuilder(builder.UserType, builder.Services);
//Agregar seguridad Roles
IdentityBuilder.AddRoles <IdentityRole>();
IdentityBuilder.AddClaimsPrincipalFactory <UserClaimsPrincipalFactory <Usuario, IdentityRole> >();
//instanciar entity
IdentityBuilder.AddEntityFrameworkStores <CursosOnlineContext>();
IdentityBuilder.AddSignInManager <SignInManager <Usuario> >();
services.TryAddSingleton <ISystemClock, SystemClock>();
//Agregar seguridad
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("Mi Palabra Secreta"));
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(opt => {
opt.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = key,
ValidateAudience = false,
ValidateIssuer = false
};
});
//Inyectar Jwtoken
services.AddScoped <IJwtGenerador, JwtGenerador>();
// Para retornar el usuario log
services.AddScoped <IUsuarioSesion, UsuarioSesion>();
//Automaper
services.AddAutoMapper(typeof(Consulta.Manejador));
//Dapper
services.AddTransient <IFactoryConnection, FactoryConnection>();
services.AddScoped <IInstructor, InstructorRepository>();
//Paginacion
services.AddScoped <IPaginacion, PaginacionRepositorio>();
//Swager
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo
{
Title = "Services para mantenimiento de cursos",
Version = "v1"
}
);
c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
Description = "JWT Authorization header using the Bearer scheme (Example: 'Bearer 12345abcdef')",
Name = "Authorization",
In = ParameterLocation.Header,
Type = SecuritySchemeType.ApiKey,
Scheme = "Bearer"
});
c.AddSecurityRequirement(new OpenApiSecurityRequirement
{
{
new OpenApiSecurityScheme
{
Reference = new OpenApiReference
{
Type = ReferenceType.SecurityScheme,
Id = "Bearer"
}
},
Array.Empty <string>()
}
});
c.CustomSchemaIds(c => c.FullName);
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// Configuración de CORS
services.AddCors(o => o.AddPolicy("corsApp", builder =>
{
builder
.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader();
}));
services.AddDbContext <CursosOnlineContext>(opt =>
{
opt.UseSqlServer(this.Configuration.GetConnectionString("DefaultConnection"));
});
services.Configure <ConexionConfiguracion>(this.Configuration.GetSection("ConnectionStrings"));
services.AddOptions();
services.AddMediatR(typeof(Consulta.Manejador).Assembly);
services.AddControllers(opt =>
{
// Declaro politica para requerir Autenticación y la agrego como filtro.
var policy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
opt.Filters.Add(new AuthorizeFilter(policy));
})
.AddFluentValidation(config => config.RegisterValidatorsFromAssemblyContaining <Nuevo>());
// Configuración de IdentityCore
var builder = services.AddIdentityCore <Usuario>();
var identityBuilder = new IdentityBuilder(builder.UserType, builder.Services);
//Configuración de roles y Rol con Tokens -> Ademas instanciamos el servicio de RoleManager
identityBuilder.AddRoles <IdentityRole>();
identityBuilder.AddClaimsPrincipalFactory <UserClaimsPrincipalFactory <Usuario, IdentityRole> >();
identityBuilder.AddEntityFrameworkStores <CursosOnlineContext>();
identityBuilder.AddSignInManager <SignInManager <Usuario> >();
services.TryAddSingleton <ISystemClock, SystemClock>();
// Configuración para los JWT Tokens
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("Mi palabra secreta"));
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(opt =>
{
opt.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = key,
ValidateAudience = false, // Alguien con una IP cualquiera pueda generar un Token
ValidateIssuer = false, // Es para el envio del token (?)
};
});
services.AddScoped <IJwtGenerador, JwtGenerador>();
services.AddScoped <IUsuarioSesion, UsuarioSesion>();
services.AddAutoMapper(typeof(Consulta.Manejador));
services.AddTransient <IFactoryConnection, FactoryConnection>();
services.AddScoped <IInstructor, InstructorRepositorio>();
services.AddScoped <IPaginacion, PaginacionRepositorio>();
// Configuración de Swagger
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo
{
Title = "Servicios para mantenimineto de cursos",
Version = "v1"
});
c.CustomSchemaIds(c => c.FullName);
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext <ApplicationDbContextSeed>(opt =>
{
opt.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"));
});
services.AddOptions();
//dapper cnx
services.Configure <ConexionConfiguracion>(Configuration.GetSection("ConnectionStrings"));
services.AddMediatR(typeof(Consulta.Manejador).Assembly);
//agregando fluentvalidation configurando la validacion de nuevo curso.
services.AddControllers(opt =>
{
//Authorizacion antes de recibir un request (antes de procesar)
var policy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
opt.Filters.Add(new AuthorizeFilter(policy));
})
.AddFluentValidation(cfg => cfg.RegisterValidatorsFromAssemblyContaining <Nuevo>());
var builder = services.AddIdentityCore <Usuario>();
var identityBuilder = new IdentityBuilder(builder.UserType, builder.Services);
//instanciando rol manager.
identityBuilder.AddRoles <IdentityRole>();
identityBuilder.AddClaimsPrincipalFactory <UserClaimsPrincipalFactory <Usuario, IdentityRole> >();
identityBuilder.AddEntityFrameworkStores <ApplicationDbContextSeed>();
identityBuilder.AddSignInManager <SignInManager <Usuario> >();
services.TryAddSingleton <ISystemClock, SystemClock>();
services.AddScoped <IJwtGenerador, JwtGenerador>();
//jwt
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("Mi palabra Secreta"));
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(opt =>
{
opt.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = key,
ValidateAudience = false,
ValidateIssuer = false
};
});
services.AddScoped <IUsuarioSesion, UsuarioSesion>();
//automapper
services.AddAutoMapper(typeof(Consulta.Manejador));
//iniciar sp
services.AddTransient <IFactoryConnection, FactoryConnection>();
services.AddScoped <IInstructor, InstructorRepositorio>();
//instanciar IPaginacion
services.AddScoped <IPaginacion, PaginacionRepositorio>();
//swager
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo
{
Title = "Services para mantenimiento de cursos",
Version = "v1"
});
c.CustomSchemaIds(c => c.FullName);
});
}
/// <summary>
/// use if UserAdminOptions.Field non null, this will add the handler to add the Role Claim
/// </summary>
/// <typeparam name="TUser"></typeparam>
/// <param name="builder"></param>
/// <returns></returns>
public static IdentityBuilder RegisterUserAdminClaims <TUser, TRole>(this IdentityBuilder builder)
where TUser : IdentityUser <string>
where TRole : IdentityRole <string>
{
return(builder.AddClaimsPrincipalFactory <MyRolesClaimsPrincipalFactory <TUser, TRole> >());
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddCors(o => o.AddPolicy("corsApp", builder => {
builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader();
}));
services.AddDbContext <CursosOnlineContext>(opt => {
//opt.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"));
opt.UseSqlServer("Data Source=DESKTOP-PMMA13T; Initial Catalog=CursosOnline; Integrated Security=True");
});
services.AddOptions();
services.Configure <ConexionConfiguracion>(Configuration.GetSection("ConnectionsStrings"));
services.AddMediatR(typeof(Consulta.Manejador).Assembly);
services.AddControllers(opt => {
var policy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
opt.Filters.Add(new AuthorizeFilter(policy));
});
services.AddControllers().AddFluentValidation(cfg => cfg.RegisterValidatorsFromAssemblyContaining <Nuevo>());
var builder = services.AddIdentityCore <Usuario>();
var identityBuilder = new IdentityBuilder(builder.UserType, builder.Services);
identityBuilder.AddRoles <IdentityRole>();
identityBuilder.AddClaimsPrincipalFactory <UserClaimsPrincipalFactory <Usuario, IdentityRole> >();
identityBuilder.AddEntityFrameworkStores <CursosOnlineContext>();
identityBuilder.AddSignInManager <SignInManager <Usuario> >();
services.TryAddSingleton <ISystemClock, SystemClock>();
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("Mi palabra secreta"));
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(opt => {
opt.TokenValidationParameters = new TokenValidationParameters {
ValidateIssuerSigningKey = true,
IssuerSigningKey = key,
ValidateAudience = false,
ValidateIssuer = false
};
});
services.AddScoped <IJwtGenerador, JwtGenerador>();
services.AddScoped <IUsuarioSesion, UsuarioSesion>();
services.AddAutoMapper(typeof(Consulta.Manejador));
services.AddTransient <IFactoryConnection, FactoryConnection>();
services.AddScoped <IInstructor, InstructorRepositorio>();
services.AddScoped <IPaginacion, PaginacionRepositorio>();
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo
{
Title = "Services para mantenimiento de cursos",
Version = "v1"
});
c.CustomSchemaIds(c => c.FullName);
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
/*Se agrega los Cors para que nuestro servicio pueda ser comsumido por cualquier cliente*/
services.AddCors(o => o.AddPolicy("corsApp", builder => {
/* metodo largo
* builder.AllowAnyOrigin();
* builder.AllowAnyMethod();
* builder.AllowAnyHeader();
*
* metodo corto*/
builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader();
}));
services.AddDbContext <CursosOnlineContext>(opt => {
opt.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"));
});
services.AddOptions();
services.Configure <ConexionConfiguracion>(Configuration.GetSection("ConnectionStrings"));
services.AddMediatR(typeof(Consulta.Manejador).Assembly);
//Se agrego para que nuestros controller tengan autorizacion antes de recibir un request de un cliente
//antes de procesar un request de un cliente
services.AddControllers(opt => {
var policy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
opt.Filters.Add(new AuthorizeFilter(policy));
})
.AddFluentValidation(cfg => cfg.RegisterValidatorsFromAssemblyContaining <Nuevo>());//Con esto se agrega la validacion de FluenValitadion para que trabaje en los controllers
var builder = services.AddIdentityCore <Usuario>();
var identityBuilder = new IdentityBuilder(builder.UserType, builder.Services);
//Con estas dos lineas estariamos instanciando el servicio de RolManager, en este caso el objeto va a estar listo
//cuando arranque mi aplicacion
identityBuilder.AddRoles <IdentityRole>();
identityBuilder.AddClaimsPrincipalFactory <UserClaimsPrincipalFactory <Usuario, IdentityRole> >();
identityBuilder.AddEntityFrameworkStores <CursosOnlineContext>();
identityBuilder.AddSignInManager <SignInManager <Usuario> >();
/*
* El service services.TryAddSingleton usualmente se utiliza para inyectar un objeto dependiendo si existe,
* si no existe procedera a la inyeccion caso contrario se usara la instancia que tiene en ese momento la app en tiempo de ejecucion.
* Hay un pequeno bug dentro del registro de nuevos usuarios en el Core Identity propio del framework, cuando sucede este evento
* se debe registrar tambien la hora y el tiempo del registro, pero para hacerlo el core identity se apoya en la clase SystemClock,
* por algun motivo, en el momento del registro esta clase no esta siendo instanciada correctamente por ello agregamos esta linea,
* para forzarla aque haga la instancia de esta clase si es que no existe: services.TryAddSingleton<ISystemClock, SystemClock>();
*/
services.TryAddSingleton <ISystemClock, SystemClock>();
//que diferencia existe tiene TryAddSingleton con el AddSingleton normal y por el que el uso de SystemClock?
/* La principal diferencia es que el TryAddSingleton evalua la existencia del objeto, si no existe entonces fuerza
* la instancia de la clase.
* Sobre tu segunda pregunta, existe un bug dentro del Core Identity a la hora de registrar un nuevo usuario, ya que esta
* intentando registrar la fecha de creacion del nuevo usuario, pero para hacer esto se apoya en la clase SystemClock, y al
* tratar de utilizar el objeto, este devuelve un null, por ello hacemos la instancia de esta clase con el TryAddSingleton.
*/
//Porque estamos injectando estas interfax y clas lo hago porque de esta forma podamos acceder a los metodos que van a generar
//los tokens en Seguridad, es decir WebApi va a poder acceder a esos token haciendo esta inyeccion de servicios
services.AddScoped <IJwtGenerador, JwtGenerador>();
services.AddScoped <IUsuarioSesion, UsuarioSesion>();
services.AddAutoMapper(typeof(Consulta.Manejador));
services.AddTransient <IFactoryConnection, FactoryConnection>();
services.AddScoped <IInstructor, InstructorRepositorio>();
services.AddScoped <IPaginacion, PaginacionRepository>();
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("Mi Palabra secreta"));
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(opt => {
opt.TokenValidationParameters = new TokenValidationParameters {
ValidateIssuerSigningKey = true,
IssuerSigningKey = key,
ValidateAudience = false, //Que quien podra crear estos tokens
ValidateIssuer = false //Es como el envio del token
};
});
services.AddSwaggerGen(c => {
c.SwaggerDoc("V1", new OpenApiInfo {
Title = "Servicios Para Mantenimiento de Cursos",
Version = "V1"
});
c.CustomSchemaIds(c => c.FullName);
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// agregar una politica que permite que cualquier cliente pueda consumir la API
services.AddCors(o => o.AddPolicy("corsApp", builder =>
{
// el builder o servicio permite cualquier origen, permite cualquier metodo y cualquier cabezera http
builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader();
}));
// configuracion para agregar el context al servicio web
services.AddDbContext <CursosOnlineContext>(opt =>
{
opt.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"));
});
// permite ue Dapper pueda leer la cadena de conexion para los procedimientos almacenados
services.AddOptions();
// configurar los procedimientos almacenados para la DB
services.Configure <ConexionConfiguracion>(Configuration.GetSection("ConnectionStrings"));
// configura el mediador para devolver todos los cursos
services.AddMediatR(typeof(Consulta.Manejador).Assembly);
// agregar [Authorize] a todos los controladores para validar el funcionamiento con tokens de usuario
services.AddControllers(opt =>
{
// reuiere ue el ususario este autenticado
var policy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
opt.Filters.Add(new AuthorizeFilter(policy));
})
// agregar validaciones sobre la clase NuevoCurso
.AddFluentValidation(cfg => cfg.RegisterValidatorsFromAssemblyContaining <NuevoCurso>());
// configuracion de core identity para el acceso por logins
var builder = services.AddIdentityCore <Usuario>();
// inicializacion del modulo de identidad utilizando a usuario para los login
var identityBuilder = new IdentityBuilder(builder.UserType, builder.Services);
// instanciar el uso de roles de usuario con los datos pre contrstruidos de IdentityRole
identityBuilder.AddRoles <IdentityRole>();
// Claims comunicando las entidades Usuario y IdentityRole
identityBuilder.AddClaimsPrincipalFactory <UserClaimsPrincipalFactory <Usuario, IdentityRole> >();
// instanciar el uso de roles de usuario con los datos pre contrstruidos de IdentityRole
identityBuilder.AddEntityFrameworkStores <CursosOnlineContext>();
// Claims comunicando las entidades Usuario y IdentityRole
identityBuilder.AddSignInManager <SignInManager <Usuario> >();
// configuracion de los datos de prueba para las migraciones
services.TryAddSingleton <ISystemClock, SystemClock>();
// creacion de la llave para la validacion de los controladores con seguridad
// la palabra secreta debe ser la misma ue en el JwtGenerador en la linea 34
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("Mi palabra secreta"));
// habilitar la autenticacion por tokens para obtener datos desde la API
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(opt =>
{
opt.TokenValidationParameters = new TokenValidationParameters
{
// cualquier request del cliente debe ser validado por el proyecto
ValidateIssuerSigningKey = true,
IssuerSigningKey = key,
// personas por IP que pueden acceder al servicio
ValidateAudience = false,
// envio del token falso, ya que no hay seleccion de cliente especificos en ValidateAudience
ValidateIssuer = false
};
});
// injeccion de la libreria de seguridad y la interface en applicacion.contratos
// y comenzar interfaces reconocibles parar logica de negocio
services.AddScoped <IJwtGenerador, JwtGenerador>();
// dar a concer por el webApp la clase para reconocer l usuario en sesion acltualmente.
services.AddScoped <IUsuarioSesion, UsuarioSesion>();
// Inicializar injeccion del mapping de instructores en clasesDTO
services.AddAutoMapper(typeof(Consulta.Manejador));
// instanciar los procedimientos almacenados como clases en Persistencia
services.AddTransient <IFactoryConnection, FactoryConnection>();
// instanciar operaciones de DJ como tal para los procedimientos alamcenados
services.AddScoped <IInstructor, InstructorRepositorio>();
// instancia la paginacion
services.AddScoped <IPaginacion, PaginacionRepositorio>();
// confguracion basica del Swagger - genera documentacion para una API con interfaz grafica
services.AddSwaggerGen(c =>
{
// se manda la version y la informacion de la API
c.SwaggerDoc("v1", new OpenApiInfo
{
Title = "Services para mentenimiento de Cursos",
Version = "v1"
});
// filtro para no tener conflictos con los esquemas de los Endpoints
// los metodos Ejecuta chocarian unos otros si no se agrega "FullName", de otro se usa el namespace para separar todo.
c.CustomSchemaIds(c => c.FullName);
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext <CursosOnlineContext>(opt => {
opt.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"));
});
services.AddOptions();
services.Configure <ConexionConfiguracion>(Configuration.GetSection("ConnectionStrings"));
services.AddMediatR(typeof(Consulta.Manejador).Assembly);
// services.AddControllers(opt => {
// var policy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
// opt.Filters.Add(new AuthorizeFilter(policy));
// });
// Agregar la clase a la que se requiere agregar validaciones (Aplicacion.Cursos.Nuevo.cs)
services.AddControllers(opt => {
var policy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
opt.Filters.Add(new AuthorizeFilter(policy));
}).AddFluentValidation(cfg => cfg.RegisterValidatorsFromAssemblyContaining <Nuevo>());
var builder = services.AddIdentityCore <Usuario>();
var identityBuilder = new IdentityBuilder(builder.UserType, builder.Services);
identityBuilder.AddRoles <IdentityRole>();
identityBuilder.AddClaimsPrincipalFactory <UserClaimsPrincipalFactory <Usuario, IdentityRole> >();
identityBuilder.AddEntityFrameworkStores <CursosOnlineContext>();
identityBuilder.AddSignInManager <SignInManager <Usuario> >();
// Bug de IdentityCore donde al registrar un usuario, la fecha de creación = null
// por lo que se agrega SystemClock
// TryAddSingleton hace una inyección del objeto cuando se ejecuta el programa
services.TryAddSingleton <ISystemClock, SystemClock>();
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("Mi palabra secreta"));
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(opt => {
opt.TokenValidationParameters = new TokenValidationParameters {
ValidateIssuerSigningKey = true,
IssuerSigningKey = key,
ValidateAudience = false,
ValidateIssuer = false
};
});
services.AddScoped <IJwtGenerador, JwtGenerador>();
services.AddScoped <IUsuarioSesion, UsuarioSesion>();
services.AddAutoMapper(typeof(Consulta.Manejador));
services.AddTransient <IFactoryConnection, FactoryConnection>();
services.AddScoped <IInstructor, InstructorRepositorio>();
services.AddScoped <IPaginacion, PaginacionRepositorio>();
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "WebAPI", Version = "v1"
});
c.CustomSchemaIds(c => c.FullName);
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddCors(o => o.AddPolicy("corsApp", build => {
build.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader();
}));
// Generamos un servico al EntityFramework para poder tener acceso a la base de datos
services.AddDbContext <CursosOnlineContext>(opt => {
opt.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"));
});
services.AddOptions();
// Agregamos conexion para Dapper
services.Configure <ConexionConfiguracion>(Configuration.GetSection("ConnectionStrings"));
services.AddMediatR(typeof(Consulta.Manejador).Assembly);
// Indicamos que clase es al que se va a validar RegisterValidatorsFromAssemblyContaining
services.AddControllers(opt => {
// agregamos una poliza para que cada controlador requiera la autorizacion del Token
var policy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
opt.Filters.Add(new AuthorizeFilter(policy));
})
.AddFluentValidation(cfg => cfg.RegisterValidatorsFromAssemblyContaining <Nuevo>());
// Agregamos como servicio a Usuarios con Core Identity
var builder = services.AddIdentityCore <Usuario>();
var identityBuilder = new IdentityBuilder(builder.UserType, builder.Services);
// ***** ROL Manager
// Agregamos los Roles
identityBuilder.AddRoles <IdentityRole>();
// Data de los roles dentro de la data del token
identityBuilder.AddClaimsPrincipalFactory <UserClaimsPrincipalFactory <Usuario, IdentityRole> >();
// ****************
identityBuilder.AddEntityFrameworkStores <CursosOnlineContext>();
// Manejo del loggin
identityBuilder.AddSignInManager <SignInManager <Usuario> >();
// TryAddSingleton: el registro no se agregará cuando ya existan registros para el tipo de servicio dado.
services.TryAddSingleton <ISystemClock, SystemClock>();
// Servicio de Autenticación
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("Mi palabra secreta"));
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(opt =>
{
opt.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = key,
ValidateAudience = false, // El pedido de Token va a ser free, no tenemos restricciones, va a ser publico
ValidateIssuer = false
};
});
services.AddScoped <IJwtGenerador, JwtGenerador>();
services.AddScoped <IUsuarioSesion, UsuarioSesion>();
services.AddAutoMapper(typeof(Consulta.Manejador));
services.AddTransient <IFactoryConnection, FactoryConnection>();
services.AddScoped <IInstructor, InstructorRepositorio>();
services.AddScoped <IPaginacion, PaginacionRepositorio>();
// agregamos configuracion de Swagger
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo
{
Title = "Services para mantenimiento de cursos",
Version = "v1"
});
c.CustomSchemaIds(s => s.FullName); // Para que no tire conflictos los endpoints que tienen el mismo nombre de clase
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// Coneccion a la base de datos
services.AddDbContext <SistemaDbContext>(opt =>
{
opt.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"));
});
// Automapper
services.AddAutoMapper(typeof(Get.Handler));
// Para la conexion de los procedimientos alamcenados
services.AddOptions();
services.Configure <ConnectionSettings>(Configuration.GetSection("ConnectionStrings"));
// Agregar MediatR
services.AddMediatR(typeof(Get.Handler).Assembly);
// Conexion en la base de datos para trabajor con Procedimientos Almacenados
services.AddTransient <IFactoryConnection, FactoryConnection>();
services.AddScoped <ICategoriaRepository, CategoriaRepository>();
services.AddScoped <IProductoRepository, ProductoRepository>();
services.AddScoped <IComboRepository, ComboRepository>();
services.AddScoped <IProveedorRepository, ProveedorRepository>();
services.AddScoped <ICompraRepository, CompraRepository>();
services.AddScoped <IDetalleCompraRepository, DetalleCompraRepository>();
// Agregando IdentityFrameworkCore a webAPI
var builder = services.AddIdentityCore <Usuario>();
var identityBuilder = new IdentityBuilder(builder.UserType, builder.Services);
identityBuilder.AddRoles <IdentityRole>();
identityBuilder.AddClaimsPrincipalFactory <UserClaimsPrincipalFactory <Usuario, IdentityRole> >();
identityBuilder.AddEntityFrameworkStores <SistemaDbContext>();
identityBuilder.AddSignInManager <SignInManager <Usuario> >();
services.TryAddSingleton <ISystemClock, SystemClock>();
// Json WebToken
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("Mi palabra secreta"));
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(opt =>
{
opt.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = key,
ValidateAudience = false,
ValidateIssuer = false
};
});
services.AddScoped <IJwtGenerator, JwtGenerator>();
services.AddScoped <IUserSession, UserSession>();
services.AddControllers(opt =>
{
// Para agregar authorize a todos los controllers
var policy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
opt.Filters.Add(new AuthorizeFilter(policy));
}).AddFluentValidation(cfg => cfg.RegisterValidatorsFromAssemblyContaining <Post>());
}