protected IdentityRole GetIdentityRole(string userId)
{
if (string.IsNullOrEmpty(userId))
{
return(null);
}
if (roleDict == null)
{
roleDict = new Dictionary <string, IdentityRole>();
}
if (!roleDict.ContainsKey(userId))
{
var role = IdentityExtensions.GetIdentityRole(context, userId);
if (role != null)
{
roleDict.Add(userId, role);
}
}
return(roleDict.ContainsKey(userId)
? roleDict[userId]
: null);
}
public async Task <ActionResult <string> > Login([FromBody] LoginDTO model)
{
var appUser = await _userManager.FindByEmailAsync(model.Email);
if (appUser == null)
{
_logger.LogInformation($"Web-Api login. User {model.Email} not found!");
return(StatusCode(403));
}
var result = await _signInManager.CheckPasswordSignInAsync(appUser, model.Password, false);
if (result.Succeeded)
{
var claimsPrincipal = await _signInManager.CreateUserPrincipalAsync(appUser); //get the User analog
var jwt = IdentityExtensions.GenerateJWT(claimsPrincipal.Claims,
_configuration["JWT:SigningKey"],
_configuration["JWT:Issuer"],
_configuration.GetValue <int>("JWT:ExpirationInDays")
);
_logger.LogInformation($"Token generated for user {model.Email}");
return(Ok(new JwtResponseDTO()
{
Token = jwt,
Status = "Logged in",
FirstName = appUser.FirstName,
LastName = appUser.LastName,
Roles = _userManager.GetRolesAsync(appUser)?.Result ?? new Collection <string>()
}));
}
_logger.LogInformation($"Web-Api login. User {model.Email} attempted to log-in with bad password!");
return(StatusCode(403));
}
protected ApplicationUser GetUser(string userId)
{
if (string.IsNullOrEmpty(userId))
{
return(null);
}
if (userDict == null)
{
userDict = new Dictionary <string, ApplicationUser>();
}
if (!userDict.ContainsKey(userId))
{
var user = IdentityExtensions.GetUser(context, userId);
if (user != null)
{
userDict.Add(userId, user);
}
}
return(userDict.ContainsKey(userId)
? userDict[userId]
: null);
}
public PartialViewResult ProfileInfo(string name = "xxxxx", int age = 12, bool married = false)
{
var m = new Service.UserService().getUserSelfProfile(IdentityExtensions.GetUserId(User.Identity));
return(PartialView("PP/_profile", m));
}
public void PortraitUrl_Should_Return_Url_SpecificSize()
{
string characterId = "12345";
EveImageHelper.CharacterAvatarSize size = EveImageHelper.CharacterAvatarSize.Thirty_Two;
string expectedUrl = $"https://image.eveonline.com/Character/{characterId}_{(int)size}.jpg";
var user = new ClaimsPrincipal(
new ClaimsIdentity(
new Claim[] {
new Claim("PrimaryCharacterId", characterId),
new Claim(ClaimTypes.Name, "fakeusername")
})
);
ApplicationUser expectedApplicationUser = new ApplicationUser()
{
PrimaryCharacterId = characterId,
Id = "1"
};
Mock <UserManager <ApplicationUser> > mockUserManager = MockUserManager <ApplicationUser>();
mockUserManager.Setup(x => x.GetUserAsync(user)).ReturnsAsync(expectedApplicationUser);
string result = IdentityExtensions.AvatarUrl(user, mockUserManager.Object, size);
Assert.AreEqual(expectedUrl, result);
}
public ActionResult OfferPage(String OfferID)
{
WorkWithOffers WWO = new WorkWithOffers(Server);
Offers ShowOffer = new Offers();
if (OfferID == null)
{
ShowOffer = (Offers)Session["ShowOffer"];
}
else
{
ShowOffer = WWO.GetOfferByID(OfferID);
}
Session["ShowOffer"] = ShowOffer;
if (User.Identity.Name != "")
{
WorkWithUsers WWU = new WorkWithUsers();
if (WWU.GetUserRole(IdentityExtensions.GetUserId(User.Identity)) == "Banned")
{
return(RedirectToAction("UserBanned", "AccessDenied"));
}
}
return(View(ShowOffer));
}
public async Task <IActionResult> Login([FromBody] LoginDTO dto)
{
var appUser = await _userManager.FindByEmailAsync(dto.Email);
if (appUser == null)
{
_logger.LogInformation($"WebApi login. User {dto.Email} not found!");
return(NotFound(new MessageDTO("User not found!")));
}
var result = await _signInManager.CheckPasswordSignInAsync(appUser, dto.Password, false);
if (result.Succeeded)
{
var claimsPrincipal = await _signInManager.CreateUserPrincipalAsync(appUser);
var jwt = IdentityExtensions.GenerateJWT(
claimsPrincipal.Claims
.Append(new Claim(ClaimTypes.GivenName, appUser.FirstName))
.Append(new Claim(ClaimTypes.Surname, appUser.LastName)),
_configuration["JWT:SigningKey"],
_configuration["JWT:Issuer"],
_configuration.GetValue <int>("JWT:ExpirationInDays")
);
_logger.LogInformation($"WebApi login. User {appUser.Email} logged in.");
return(Ok(new JwtResponseDTO()
{
Token = jwt, Status = $"User {appUser.Email} logged in.", FirstName = appUser.FirstName,
LastName = appUser.LastName
}));
}
_logger.LogInformation($"WebApi login. User {appUser.Email} failed login attempt!");
return(NotFound(new MessageDTO("User not found!")));
}
public async Task <ActionResult <string> > Login([FromBody] LoginDTO model)
{
var appUser = await _userManager.FindByEmailAsync(model.Email);
if (appUser == null)
{
_logger.LogInformation($"Web-Api login. User {model.Email} not Found!");
return(StatusCode(403));
}
var result = await _signInManager.CheckPasswordSignInAsync(appUser, model.Password, false);
if (result.Succeeded)
{
var claimPrincipal = await _signInManager.CreateUserPrincipalAsync(appUser);
var jwt = IdentityExtensions.GenerateJWT(claimPrincipal.Claims,
_configuration["JWT:Key"],
_configuration["JWT:Issuer"],
_configuration.GetValue <int>("JWT:ExpireDays"));
_logger.LogInformation($"Token generated for user {model.Email}");
var isAdministrator = _userManager.IsInRoleAsync(appUser, "Admin").Result;
return(Ok(new { token = jwt, isAdmin = isAdministrator }));
}
_logger.LogInformation($"Web-Api login. User {model.Email} bad log-in password!");
return(StatusCode(403));
}
public async Task <ActionResult <string> > ChangeEmail([FromBody] ChangeEmailDTO model)
{
var user = await _userManager.FindByEmailAsync(model.Email);
Console.WriteLine(user.ToString());
if (user == null)
{
_logger.LogInformation("User not found!");
return(StatusCode(403));
}
var claimsPrincipal = await _signInManager.CreateUserPrincipalAsync(user); //get the User analog
var jwt = IdentityExtensions.GenerateJWT(claimsPrincipal.Claims,
_configuration["JWT:SigningKey"],
_configuration["JWT:Issuer"],
_configuration.GetValue <int>("JWT:ExpirationInDays")
);
var email = await _userManager.GetEmailAsync(user);
if (model.NewEmail != email)
{
var code = await _userManager.GenerateChangeEmailTokenAsync(user, model.NewEmail);
await _userManager.ChangeEmailAsync(user, model.NewEmail, code);
await _userManager.SetUserNameAsync(user, model.NewEmail);
_logger.LogInformation("Token generated for user");
return(Ok(new { token = jwt, status = "Email changed", email = model.NewEmail }));
}
return(Ok(new { token = jwt, status = "Email was not changed", email = model.Email }));
}
public async Task <ActionResult <string> > Login([FromBody] Login dto)
{
var appUser = await _userManager.FindByNameAsync(dto.UserName);
if (appUser == null)
{
_logger.LogInformation($"Web-api login. User with User name {dto.UserName} not found");
return(StatusCode(403));
}
var result = await _signInManager.CheckPasswordSignInAsync(appUser, dto.Password, false);
if (result.Succeeded)
{
var claimsPrincipal = await _signInManager.CreateUserPrincipalAsync(appUser);
var jwt = IdentityExtensions.GenerateJWT(
claimsPrincipal.Claims,
_configuration.GetSection("JWT").GetValue <string>("SigningKey"),
_configuration.GetSection("JWT").GetValue <string>("Issuer"),
_configuration.GetSection("JWT").GetValue <int>("ExpireInDays")
);
_logger.LogInformation($@"Token generated for user {dto.UserName}");
return(Ok(new LoginResponse
{
Token = jwt,
Status = "Logged in",
HasActiveRoutine = await _bll.WorkoutRoutines.UserWithIdHasActiveRoutineAsync(appUser.Id)
}));
}
_logger.LogInformation("Web-api login. Login attempt with incorrect password.");
return(StatusCode(403));
}
public ActionResult RemoveAccountList()
{
var linkedAccounts = this.UserManager.GetLogins(IdentityExtensions.GetUserId <int>(this.User.Identity));
this.ViewBag.ShowRemoveButton = this.HasPassword() || linkedAccounts.Count > 1;
return(this.PartialView(linkedAccounts));
}
public async Task <ActionResult <string> > Login([FromBody] LoginDTO model)
{
var appUser = await _userManager.FindByEmailAsync(model.Email);
if (appUser is null)
{
_logger.LogInformation($"Web-Api login. User {model.Email} not found!");
return(StatusCode(403));
}
var result = await _signInManager.CheckPasswordSignInAsync(appUser, model.Password, false);
if (result.Succeeded)
{
var claimsPrincipal = await _signInManager.CreateUserPrincipalAsync(appUser); //get the User analog
var jwt = IdentityExtensions.GenerateJWT(claimsPrincipal.Claims
.Append(new Claim(ClaimTypes.GivenName, appUser.FirstName))
.Append(new Claim(ClaimTypes.Surname, appUser.LastName)),
_configuration["JWT:SigningKey"],
_configuration["JWT:Issuer"],
_configuration.GetValue <int>("JWT:ExpirationInDays")
);
_logger.LogInformation($"Token generated for user {model.Email} ");
return(Ok(new { token = jwt }));
}
_logger.LogInformation($"Web-Api login. User {model.Email} attempted to log-in with bad password!");
return(StatusCode(403));
}
public async Task <ActionResult <string> > Register([FromBody] RegisterDTO model)
{
var appUser = new AppUser()
{
UserName = model.Email,
Email = model.Email,
Name = model.Name
};
var result = await _userManager.CreateAsync(appUser, model.Password);
if (result.Succeeded)
{
var claimsPrincipal = await _signInManager.CreateUserPrincipalAsync(appUser); //get the User analog
var jwt = IdentityExtensions.GenerateJWT(claimsPrincipal.Claims,
_configuration["JWT:SigningKey"],
_configuration["JWT:Issuer"],
_configuration.GetValue <int>("JWT:ExpirationInDays")
);
return(Ok(new { token = jwt, status = "Registered and logged-in" }));
}
return(StatusCode(500));
}
public static ExternalLoginData FromIdentity(ClaimsIdentity identity)
{
if (identity == null)
{
return(null);
}
Claim providerKeyClaim = identity.FindFirst(ClaimTypes.NameIdentifier);
if (providerKeyClaim == null || String.IsNullOrEmpty(providerKeyClaim.Issuer) ||
String.IsNullOrEmpty(providerKeyClaim.Value))
{
return(null);
}
if (providerKeyClaim.Issuer == ClaimsIdentity.DefaultIssuer)
{
return(null);
}
return(new ExternalLoginData
{
LoginProvider = providerKeyClaim.Issuer,
ProviderKey = providerKeyClaim.Value,
UserName = IdentityExtensions.FindFirstValue(identity, ClaimTypes.Name)
});
}
public async Task <IHttpActionResult> RemoveLogin(RemoveLoginBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
IdentityResult result;
if (model.LoginProvider == LocalLoginProvider)
{
result = await UserManager.RemovePasswordAsync(IdentityExtensions.GetUserId <Int32>(User.Identity));
}
else
{
result = await UserManager.RemoveLoginAsync(IdentityExtensions.GetUserId <Int32>(User.Identity),
new UserLoginInfo(model.LoginProvider, model.ProviderKey));
}
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok());
}
public async Task <IHttpActionResult> AddExternalLogin(AddExternalLoginBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Authentication.SignOut(DefaultAuthenticationTypes.ExternalCookie);
AuthenticationTicket ticket = AccessTokenFormat.Unprotect(model.ExternalAccessToken);
if (ticket == null || ticket.Identity == null || (ticket.Properties != null &&
ticket.Properties.ExpiresUtc.HasValue &&
ticket.Properties.ExpiresUtc.Value < DateTimeOffset.UtcNow))
{
return(BadRequest("External login failure."));
}
ExternalLoginData externalData = ExternalLoginData.FromIdentity(ticket.Identity);
if (externalData == null)
{
return(BadRequest("The external login is already associated with an account."));
}
IdentityResult result = await UserManager.AddLoginAsync(IdentityExtensions.GetUserId <Int32>(User.Identity),
new UserLoginInfo(externalData.LoginProvider, externalData.ProviderKey));
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok());
}
public async Task <HttpResponseMessage> Upload()
{
UploadApp updApp = new UploadApp();
if (!Request.Content.IsMimeMultipartContent())
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Ошибка при загрузке файла"));
}
updApp.App = new Application();
updApp.GetProvider();
await Request.Content.ReadAsMultipartAsync(updApp.Provider);
await updApp.ReadFileAsync();
List <Error> errors = await updApp.ValidateAsync();
//Валидация
foreach (Error error in errors)
{
ModelState.AddModelError(error.Name, error.Text);
}
updApp.App.ApplicationUserId = IdentityExtensions.GetUserId(User.Identity);
updApp.App.Date = DateTime.Now.ToString("dd MMMM yyyy | HH:mm:ss");
//updApp.App.Id = Guid.NewGuid().ToString();
ApplicationUserManager userManager = Request.GetOwinContext().GetUserManager <ApplicationUserManager>();
// если не админ то подтверждение нужно
if (!userManager.IsInRole(IdentityExtensions.GetUserId(User.Identity), "Admin"))
{
updApp.App.Hide = true;
}
updApp.App.Delete = false;
updApp.App.Path = updApp.Path;
updApp.App.PathIcon = updApp.PathIcon;
if (!ModelState.IsValid) //валидация
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ModelState));
}
_db.Applications.Add(updApp.App);
_db.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.Created, updApp.App));
}
private void RegisterServicesForIdentity(IServiceCollection services, DatabaseOptions databaseOptions)
{
if (databaseOptions.ConnectionType == ConnectionType.MongoDB)
{
services.AddTransient(a => new MongoConnection(databaseOptions));
}
IdentityExtensions.RegisterRepos(services, databaseOptions, true);
}
public async Task <IActionResult> Register([FromBody] RegisterDTO dto)
{
var appUser = await _userManager.FindByEmailAsync(dto.Email);
if (appUser != null)
{
_logger.LogInformation($"WebApi register. User {dto.Email} already registered!");
return(NotFound(new MessageDTO("User already registered!")));
}
appUser = new Domain.App.Identity.AppUser()
{
Email = dto.Email,
UserName = dto.Email,
FirstName = dto.FirstName,
LastName = dto.LastName,
};
var result = await _userManager.CreateAsync(appUser, dto.Password);
if (result.Succeeded)
{
_logger.LogInformation($"User {appUser.Email} created a new account with password.");
var user = await _userManager.FindByEmailAsync(appUser.Email);
if (user != null)
{
var claimsPrincipal = await _signInManager.CreateUserPrincipalAsync(user);
var jwt = IdentityExtensions.GenerateJWT(
claimsPrincipal.Claims
.Append(new Claim(ClaimTypes.GivenName, appUser.FirstName))
.Append(new Claim(ClaimTypes.Surname, appUser.LastName)),
_configuration["JWT:SigningKey"],
_configuration["JWT:Issuer"],
_configuration.GetValue <int>("JWT:ExpirationInDays")
);
_logger.LogInformation($"WebApi register. User {user.Email} logged in.");
return(Ok(new JwtResponseDTO()
{
Token = jwt, Status = $"User {user.Email} created and logged in.",
FirstName = appUser.FirstName, LastName = appUser.LastName
}));
}
_logger.LogInformation($"User {appUser.Email} not found after creation!");
return(BadRequest(new MessageDTO("User not found after creation!")));
}
var errors = result.Errors.Select(error => error.Description).ToList();
return(BadRequest(new MessageDTO()
{
Messages = errors
}));
}
private bool HasPassword()
{
var user = this.UserManager.FindById(IdentityExtensions.GetUserId <int>(this.User.Identity));
if (user != null)
{
return(!user.PasswordHash.IsNullOrWhiteSpace());
}
return(false);
}
public ActionResult History()
{
ViewBag.Title = "User History";
var ID = IdentityExtensions.GetUserId(HttpContext.User.Identity);
var UserBeeInfo = context.UserBees.Where(u => u.UserID == ID.ToString());
var beelist = CreateHistoryDisplay(UserBeeInfo.ToList());
return(View(beelist));
}
//public ActionResult Create()
//{
// return View();
//}
public ActionResult CreateUserBee(TempBeeBuilder BeeBuilder)
{
var userbee = new UserBees();
var ID = IdentityExtensions.GetUserId(HttpContext.User.Identity);
userbee.BeeID = BeeBuilder.BeeID;
userbee.Location = BeeBuilder.Location;
userbee.UserID = ID;
return(View());
}
private async Task <string> CreateJwtTokenForUser(AppUser user)
{
var claimsPrincipal = await _signInManager.CreateUserPrincipalAsync(user); //get the User analog
var jwt = IdentityExtensions.GenerateJwt(claimsPrincipal.Claims,
_configuration["JWT:SigningKey"],
_configuration["JWT:Issuer"],
_configuration.GetValue <int>("JWT:ExpirationInDays")
);
return(jwt);
}
public static String GetUserName()
{
if (HttpContext.Current.Session["UserName"] != null)
{
return(Convert.ToString(HttpContext.Current.Session["UserName"]));
}
else
{
var identity = HttpContext.Current.User.Identity;
HttpContext.Current.Session.Add("UserName", IdentityExtensions.GetUserName(identity));
return(Convert.ToString(HttpContext.Current.Session["UserName"]));
}
}
public static string GetName(this IIdentity identity)
{
if (identity == null)
{
throw new ArgumentNullException("identity");
}
ClaimsIdentity identity1 = identity as ClaimsIdentity;
if (identity1 != null)
{
return(IdentityExtensions.FindFirstValue(identity1, "Name"));
//return IdentityExtensions.FindFirstValue(identity1, "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name");
}
return((string)null);
}
/// <summary>
/// Returns Group SID (OrganizationID)
/// </summary>
/// <param name="identity">IIdentity</param>
/// <returns>Group Sid</returns>
public static Guid GetUserGroupId(this IIdentity identity)
{
string temp = string.Empty;
if (identity == null)
{
throw new ArgumentNullException("identity");
}
ClaimsIdentity identity1 = identity as ClaimsIdentity;
if (identity1 != null)
{
temp = IdentityExtensions.FindFirstValue(identity1, ClaimTypes.GroupSid);
}
return(new Guid(temp));
}
public async Task <IHttpActionResult> SetPassword(SetPasswordBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
IdentityResult result = await UserManager.AddPasswordAsync(IdentityExtensions.GetUserId <Int32>(User.Identity), model.NewPassword);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok());
}
public IHttpActionResult GetAllSalesPersons()
{
try
{
string Email = string.Empty;
if (User.IsInRole(EnumTypes.RoleList.SALESPERSON.ToString()))
{
Email = IdentityExtensions.GetEmailAdress(User.Identity);
}
var users = _ISalesPerson_Repository.GetSalesPersons(Email);
return(Ok(users));
}
catch (Exception ex)
{
return(NotFound());
}
}
public static int GetUserId()
{
if (HttpContext.Current.Session == null)
{
var identity = HttpContext.Current.User.Identity;
return(Convert.ToInt32(IdentityExtensions.GetUserId(identity)));
}
else if (HttpContext.Current.Session["UserId"] != null)
{
return(Convert.ToInt32(HttpContext.Current.Session["UserId"]));
}
else
{
var identity = HttpContext.Current.User.Identity;
HttpContext.Current.Session.Add("UserId", IdentityExtensions.GetUserId(identity));
return(Convert.ToInt32(HttpContext.Current.Session["UserId"]));
}
}
// GET: evaluations
public ActionResult Index()
{
var evaluations = db.evaluations.Include(e => e.course).Include(e => e.student);
if (User.IsInRole("Instructor"))
{
var sid = int.Parse(IdentityExtensions.GetSchoolId(User.Identity));
var instructorCourses = db.courses.Where(c => c.instructorid == sid);
var ctitles = instructorCourses.AsEnumerable().Select(t => t.title);
evaluations = from e in evaluations where ctitles.Contains(e.coursetitle) select e;
}
else if (User.IsInRole("Student"))
{
var sid = int.Parse(IdentityExtensions.GetSchoolId(User.Identity));
evaluations = from e in evaluations where e.studentid == sid select e;
}
return(View(evaluations.ToList()));
}
