public static async Task <TokenVM> GenerateJwt(ClaimsIdentity identity, IJwtFactory jwtFactory, string userName, JwtIssuerOptions jwtOptions, JsonSerializerSettings serializerSettings)
{
TokenVM response = new TokenVM()
{
// id = identity.Claims.Single(c => c.Type == "id").Value,
Auth_token = await jwtFactory.GenerateEncodedToken(userName, identity),
Expires_in = (int)jwtOptions.ValidFor.TotalSeconds
};
return(response);
}
public static async Task <string> GenerateRegistrationJwt(ClaimsIdentity identity, IJwtFactory jwtFactory, string userName, JwtIssuerOptions jwtOptions, Guid id)
{
var response = new
{
id = id,//identity.Claims.Single(c => c.Type == "id").Value,
auth_token = await jwtFactory.GenerateEncodedToken(userName, identity),
expires_in = (int)jwtOptions.ValidFor.TotalSeconds,
};
return(JsonConvert.SerializeObject(response));
}
public AuthController(UserManager <AppUser> userManager, IJwtFactory jwtFactory, IOptions <JwtIssuerOptions> options)
{
_userManager = userManager;
_jwtFactory = jwtFactory;
_options = options.Value;
}
public UsersController(UserManager <ApplicationUser> userManager, IJwtTokenFactory jwtFactory, IOptions <JwtIssuerOptions> jwtOptions)
{
_userManager = userManager;
_jwtFactory = jwtFactory;
_jwtOptions = jwtOptions.Value;
}
public AuthController(IJwtFactory jwtFactory, UserManager <User> userManager, JwtIssuerOptions jwtIssuerOptions, IService service, SignInManager <User> signInManager, UserLogic userLogic)
{
JwtFactory = jwtFactory;
UserManager = userManager;
Service = service;
JwtIssuerOptions = jwtIssuerOptions;
SignInManager = signInManager;
UserLogic = userLogic;
}
public static async Task <string> GenerateJwt(ClaimsIdentity identity, IJwtFactory jwtFactory, string userName, JwtIssuerOptions jwtOptions, JsonSerializerSettings serializerSettings)
{
try
{
ApplicationDbContext Db = new ApplicationDbContext();
var id = identity.Claims.Single(a => a.Type == "id").Value;
var user1 = Db.Users.Include(u => u.Identity).FirstOrDefault(u => u.IdentityId == id);
var userfeatures = (from user in Db.Users
join rolefeatures in Db.RoleFeatures on user.RoleId equals rolefeatures.RoleId
join features in Db.Features on rolefeatures.FeatureId equals features.FeatureId
join modules in Db.Modules on features.ModuleId equals modules.ModuleId
where user.UserId == user1.UserId
group features.Name by features.Module.Name into g
select new FeatureModule()
{
ModuleName = g.Key,
Features = g.ToList()
}).ToList();
AuthResponseViewModel ar = new AuthResponseViewModel
{
UserLevel = user1?.UserLevel,
FullName = user1.FullName,
UserId = user1.UserId,
ModuleFeatures = userfeatures,
AssignedId = new UserAssignedIds
{
CompanyId = user1.CompanyId,
BranchId = user1.BranchId,
CityId = user1.CityId,
CountryId = user1.CountryId
},
Response = new Response
{
Id = id,
AuthToken = await jwtFactory.GenerateEncodedToken(userName, identity),
Expiry = (int)jwtOptions.ValidFor.TotalMinutes,
},
IsSuperAdmin = false,
Status = true,
Message = "Login Successful"
};
return(JsonConvert.SerializeObject(ar, serializerSettings));
}
catch (Exception e)
{
throw e;
}
}
public JwtFactoryService(IOptions <JwtIssuerOptions> jwtIssuerOption)
{
_jwtIssuerOption = jwtIssuerOption.Value;
}
public JwtFactory(IOptions <JwtIssuerOptions> jwtOptions, JwtSecurityTokenHandler tokenHanlder)
{
this.tokenHanlder = tokenHanlder;
this.jwtOptions = jwtOptions.Value;
}
public JwtController(IOptions <JwtIssuerOptions> jwtOptions)
{
_jwtOptions = jwtOptions.Value;
}
public JwtTokenGenerator(IOptions <JwtIssuerOptions> jwtOptions)
{
_jwtOptions = jwtOptions.Value;
}
public static async Task <dynamic> GenerateJwt(ClaimsIdentity identity, IJwtService jwtService, string userName, JwtIssuerOptions jwtOptions, JsonSerializerSettings serializerSettings)
{
var response = new
{
id = identity.Claims.Single(c => c.Type == ClaimTypes.NameIdentifier).Value,
accessToken = await jwtService.GenerateEncodedToken(userName, identity),
expiresIn = (int)jwtOptions.ValidFor.TotalSeconds
};
return(response);
}
public static async Task <string> GenerateJwt(ClaimsIdentity identity, IJwtFactory jwtFactory, string userName, JwtIssuerOptions issuerOptions, JsonSerializerSettings serializerSettings)
{
var response = new
{
id = identity.Claims.Single(c => c.Type == "id").Value,
auth_token = await jwtFactory.CreateEncodedToken(userName, identity),
expires_in = (int)issuerOptions.ValidFor.TotalSeconds
};
return(JsonConvert.SerializeObject(response, serializerSettings));
}
public static async Task <JsonResponse> GenerateJwt(User user, string fullName, JwtIssuerOptions _jwtOptions, UserManager <User> _userManager)
{
var claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.Sub, user.UserName),
new Claim(JwtRegisteredClaimNames.Jti, await _jwtOptions.JtiGenerator()),
new Claim(JwtRegisteredClaimNames.Iat, ToUnixEpochDate(_jwtOptions.IssuedAt).ToString(), ClaimValueTypes.Integer64)
};
var userRoles = await _userManager.GetRolesAsync(user);
foreach (var userRole in userRoles)
{
claims.Add(new Claim(ClaimTypes.Role, userRole));
}
// Create the JWT security token and encode it.
var jwt = new JwtSecurityToken(
issuer: _jwtOptions.Issuer,
audience: _jwtOptions.Audience,
claims: claims,
notBefore: _jwtOptions.NotBefore,
expires: _jwtOptions.Expiration,
signingCredentials: _jwtOptions.SigningCredentials);
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
var response = new JsonResponse
{
fullName = fullName,
id = user.Id,
token = encodedJwt,
expires_in = (int)_jwtOptions.ValidFor.TotalSeconds
};
return(response);
//return JsonConvert.SerializeObject(response, new JsonSerializerSettings { Formatting = Formatting.Indented });
}
public static async Task <string> GenerateJwt(ClaimsIdentity identity, IJwtService jwtFactory, string userName, JwtIssuerOptions jwtOptions, JsonSerializerSettings serializerSettings)
{
try
{
var response = new
{
username = userName,
id = identity.Claims.Single(c => c.Type == "id").Value,
role = identity.Claims.Single(x => x.Type == "http://schemas.microsoft.com/ws/2008/06/identity/claims/role").Value,
auth_token = await jwtFactory.GenerateEncodedToken(userName, identity),
expires_in = (int)jwtOptions.ValidFor.TotalSeconds
};
return(JsonConvert.SerializeObject(response, serializerSettings));
}
catch (Exception ex)
{
throw;
}
}
public TokenFactory(JwtIssuerOptions issuerOptions)
{
_issuerOptions = issuerOptions;
ThrowInvalidOptions(_issuerOptions);
}
public JwtGenerator(IOptions <JwtIssuerOptions> jwtOptions)
{
_jwtOptions = jwtOptions.Value;
ThrowIfInvalidOptions(_jwtOptions);
}
public static async Task <string> GenerateJwt(IJwtFactory jwtFactory, string userId, JwtIssuerOptions jwtOptions, JsonSerializerSettings serializerSettings)
{
var response = new
{
id = userId,
auth_token = await jwtFactory.GenerateEncodedToken(userId),
expires_in = (int)jwtOptions.ValidFor.TotalSeconds
};
return(JsonConvert.SerializeObject(response, serializerSettings));
}
public TokenService(IOptions <JwtIssuerOptions> jwtOptions)
{
_jwtOptions = jwtOptions.Value;
}
public static async Task <string> GenerateJwtForSuperAdmin(ClaimsIdentity identity, IJwtFactory jwtFactory, string userName, JwtIssuerOptions jwtOptions, JsonSerializerSettings serializerSettings)
{
try
{
AuthResponseViewModel ar = new AuthResponseViewModel
{
Response = new Response
{
Id = identity.Claims.Single(a => a.Type == "id").Value,
AuthToken = await jwtFactory.GenerateEncodedToken(userName, identity),
Expiry = (int)jwtOptions.ValidFor.TotalMinutes,
},
IsSuperAdmin = true,
Status = true,
Message = "Login Successful"
};
return(JsonConvert.SerializeObject(ar, serializerSettings));
}
catch (Exception e)
{
throw e;
}
}
public AuthController(UserManager <MLS.Infrastructure.Data.Entities.AppUser> userManager, IJwtFactory jwtFactory, IOptions <JwtIssuerOptions> jwtOptions)
{
_userManager = userManager;
_jwtFactory = jwtFactory;
_jwtOptions = jwtOptions.Value;
}
public static async Task <string> GenerateJwt(ClaimsIdentity identity, IJwtGenerator jwtGenerator, string emailAddress, JwtIssuerOptions jwtOptions, JsonSerializerSettings serializerSettings)
{
var response = new
{
id = identity.Claims.Single(c => c.Type == "id").Value,
role = identity.Claims.Single(c => c.Type == "rol").Value,
auth_token = await jwtGenerator.GenerateEncodedToken(emailAddress, identity),
expires_in = (int)jwtOptions.ValidFor.TotalSeconds
};
return(JsonConvert.SerializeObject(response, serializerSettings));
}
public JwtFactory(IOptions <JwtIssuerOptions> jwtOptions)
{
_jwtOptions = jwtOptions.Value;
}
public static async Task <string> GenerateJwt(ClaimsIdentity identity, IJwtTokenFactory jwtFactory, string userName, JwtIssuerOptions jwtOptions, JsonSerializerSettings serializerSettings)
{
var response = new
{
id = identity.Claims.Single(c => c.Type == "id").Value,
auth_token = await Task.FromResult(jwtFactory.GenerateEncodedToken(userName, identity)),
expires_in = (int)TimeSpan.FromMinutes(1).TotalSeconds
};
return(JsonConvert.SerializeObject(response, serializerSettings));
}
/// <summary>
/// Initializes a new instance of the <see cref="AuthController"/> class.
/// </summary>
/// <param name="userBll">User service.</param>
/// <param name="jwtFactory">Jwt tokens factory.</param>
/// <param name="jwtOptions">Jwt tokens options.</param>
public AuthController(IUserBll userBll, IJwtFactory jwtFactory, IOptions <JwtIssuerOptions> jwtOptions)
{
this.userBll = userBll;
this.jwtFactory = jwtFactory;
this.jwtOptions = jwtOptions.Value;
}
public AuthController(UserManager <IdentityUser> userManager, IJwtFactory jwtFactory, IOptions <JwtIssuerOptions> jwtOptions)
{
_userManager = userManager;
_jwtFactory = jwtFactory;
_jwtOptions = jwtOptions.Value;
}
public JwtFactory(IOptions <JwtIssuerOptions> jwtOptions, IOptions <AppSettings> appSettings)
{
_appSettings = appSettings.Value;
_jwtOptions = jwtOptions.Value;
}
// 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_1);
var sendGridApiKey = Environment.GetEnvironmentVariable("HouseholdPlannerApiKeySendgrid");
var key = Environment.GetEnvironmentVariable("HouseholdPlannerApiKey");
var sqlPassword = Environment.GetEnvironmentVariable("SqlServerPassword");
var signingKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(key));
var jwtIssuerOptions = new JwtIssuerOptions();
var jwtAppSettingOptions = Configuration.GetSection(nameof(JwtIssuerOptions));
jwtAppSettingOptions.Bind(jwtIssuerOptions);
jwtIssuerOptions.SigningCredentials = new SigningCredentials(signingKey, SecurityAlgorithms.HmacSha256);
var emailOptions = new EmailOptions();
Configuration.GetSection(nameof(EmailOptions)).Bind(emailOptions);
var sendGridOptions = new SendGridOptions();
Configuration.GetSection(nameof(SendGridOptions)).Bind(sendGridOptions);
sendGridOptions.SendGridApiKey = sendGridApiKey;
var applicationSettings = new ApplicationSettings();
Configuration.GetSection(nameof(ApplicationSettings)).Bind(applicationSettings);
services.AddSingleton <JwtIssuerOptions>(jwtIssuerOptions);
services.AddSingleton <EmailOptions>(emailOptions);
services.AddSingleton <SendGridOptions>(sendGridOptions);
services.AddSingleton <ApplicationSettings>(applicationSettings);
var httpClient = new HttpClient();
services.AddSingleton <HttpClient>(httpClient);
services.AddTransient <IRepositoryFactory, RepositoryFactory>();
services.AddTransient <IUnitOfWorkFactory, UnitOfWorkFactory>();
services.AddTransient <IFamilyService, FamilyService>();
services.AddTransient <IMemberService, MemberService>();
services.AddTransient <IInvitationService, InvitationService>();
services.AddTransient <IHouseholdTaskService, HouseholdTaskService>();
services.AddTransient <IFileService, FileService>();
services.AddTransient <IEmailService, SendGridEmailService>();
services.AddTransient <ITokenFactory, TokenFactory>();
services.AddTransient <IUserService, UserService>();
var tokenValidationParameters = new TokenValidationParameters
{
ValidateIssuer = true,
ValidIssuer = jwtIssuerOptions.Issuer,
ValidateAudience = true,
ValidAudience = jwtIssuerOptions.Audience,
ValidateIssuerSigningKey = true,
IssuerSigningKey = signingKey,
RequireExpirationTime = false,
ValidateLifetime = true,
ClockSkew = TimeSpan.Zero
};
services.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(configureOptions =>
{
configureOptions.ClaimsIssuer = jwtIssuerOptions.Issuer;
configureOptions.TokenValidationParameters = tokenValidationParameters;
configureOptions.SaveToken = true;
});
// api user claim policy
services.AddAuthorization(options =>
{
options.AddPolicy("ApiUser", policy => policy.RequireClaim(JwtConstants.JwtClaimIdentifiers.Rol, JwtConstants.JwtClaims.ApiAccess));
});
var connectionString = Configuration.GetConnectionString("DefaultConnection");
connectionString = string.Format(connectionString, sqlPassword);
services.AddDbContext <ApplicationDbContext>(options =>
options.UseSqlServer(connectionString,
b => b.MigrationsAssembly("HouseholdPlanner.Data.EntityFramework")));
var contextFactory = new DbContextFactory(connectionString);
services.AddSingleton <IDbContextFactory <ApplicationDbContext> >(contextFactory);
services.AddDefaultIdentity <HouseholdPlanner.Data.EntityFramework.Models.ApplicationUser>(options =>
{
options.Password.RequiredLength = 1;
options.Password.RequireNonAlphanumeric = false;
options.Password.RequireDigit = false;
options.Password.RequireUppercase = false;
options.Password.RequireLowercase = false;
}).AddEntityFrameworkStores <ApplicationDbContext>();
var corsBuilder = new CorsPolicyBuilder();
corsBuilder.AllowAnyHeader();
corsBuilder.AllowAnyMethod();
corsBuilder.AllowAnyOrigin(); // For anyone access.
//corsBuilder.WithOrigins("http://localhost:56573"); // for a specific url. Don't add a forward slash on the end!
corsBuilder.AllowCredentials();
services.AddCors(options =>
{
options.AddPolicy("SiteCorsPolicy", corsBuilder.Build());
});
}
public JwtController(IOptions <JwtIssuerOptions> jwtOptions, PubeoAPIdbContext context)
{
_jwtOptions = jwtOptions.Value;
_context = context;
}
public JwtFactory(IOptions <JwtIssuerOptions> jwtOptions)
{
_jwtOptions = jwtOptions.Value;
ThrowIfInvalidOptions(_jwtOptions);
}
private static async Task <Token> Generate(ClaimsIdentity identity, IJwtFactory jwtFactory, string userName, JwtIssuerOptions jwtOptions)
{
var token = new Token
{
UserId = identity.Claims.Single(c => c.Type == "id").Value,
AuthToken = await jwtFactory.GenerateEncodedToken(userName, identity),
ExpiresIn = (int)jwtOptions.ValidFor.TotalSeconds
};
return(token);
}
