public async Task <IHttpActionResult> SendForgotPassword(SendForgotPasswordBindingModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var user = await AppUserManager.FindByNameAsync(model.UserName); string code = await AppUserManager.GeneratePasswordResetTokenAsync(user.Id); //we need to do this otherwise the + in the string gets replaced with a space var urlCode = Uri.EscapeDataString(code); var url = $"{Request.RequestUri.Scheme}://{Request.RequestUri.Authority}/auth/reset-password?userId={user.Id}&code={urlCode}"; await AppUserManager.SendEmailAsync(user.Id, "Reset Password", "Please reset your password by clicking <a href=\"" + url + "\">here</a>"); return(Ok()); }
public async Task <ActionResult> ManageRole(UserInRoleViewModel userList) { AppRole appRole = await RoleManager.FindByIdAsync(userList.RoleID); if (appRole == null) { ViewBag.Error = $"Error occurred while looking for role with ID = {userList.RoleID ?? "NULL ID"}"; return(View("Error")); } for (int i = 0; i < userList.IsInRole.Count; i++) { AppUser user = await UserManager.FindByNameAsync(userList.Users[i]); IdentityResult result; if (userList.IsInRole[i] && !(await UserManager.IsInRoleAsync(user.Id, userList.RoleName))) { result = await UserManager.AddToRoleAsync(user.Id, userList.RoleName); } else if (!userList.IsInRole[i] && await UserManager.IsInRoleAsync(user.Id, userList.RoleName)) { result = await UserManager.RemoveFromRoleAsync(user.Id, userList.RoleName); } else { continue; } if (result.Succeeded) { if (i < userList.IsInRole.Count) { continue; } else { return(RedirectToAction("EditRole", new { id = userList.RoleID })); } } } return(RedirectToAction("EditRole", new { id = userList.RoleID })); }
public async Task <object> SignIn(LoginAccount model) { var user = await _userManager.FindByNameAsync(model.UserName); if (user == null) { return(new { message = "Invalid information" }); } var result = await _signInManager.CheckPasswordSignInAsync(user, model.Password, false); if (result.Succeeded) { var token = await GetTokenAsync(user); return(new { token }); } return(new { message = "Invalid information" }); }
public async Task <IHttpActionResult> Update(UserUpdateRequest model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var user = await AppUserManager.FindByNameAsync(User.Identity.Name); user.FirstName = model.FirstName; user.LastName = model.LastName; user.Sex = model.Sex; user.BirthDate = model.BirthDate; user.Country = model.Country; user.City = model.City; IdentityResult result = await AppUserManager.UpdateAsync(user); return(result.Succeeded ? Ok() : GetErrorResult(result)); }
public async Task <IHttpActionResult> SentMessage(MessageBindingModel messageModel) { using (var ctx = ApplicationDbContext.Create()) { var ReceiverUser = await AppUserManager.FindByNameAsync(messageModel.ReceiverUserName); var Sender = await AppUserManager.FindByIdAsync(User.Identity.GetUserId()); var message = new Message() { ReceiverId = ReceiverUser.Id, SenderId = User.Identity.GetUserId(), Content = messageModel.Message, Time = DateTime.Now }; ctx.Messages.Add(message); await ctx.SaveChangesAsync(); return(Ok()); } }
public async Task <IHttpActionResult> PutResetPassword(ResetPasswordViewModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var user = await AppUserManager.FindByNameAsync(model.Email); if (user == null) { // Don't reveal that the user does not exist return(Ok()); } var result = await AppUserManager.ResetPasswordAsync(user.Id, model.Code, model.Password); if (result.Succeeded) { return(Ok()); } return(GetErrorResult(result)); }
public async Task <IHttpActionResult> PostForgotPassword(string email) { if (ModelState.IsValid) { var user = await AppUserManager.FindByNameAsync(email); if (user == null || !(await AppUserManager.IsEmailConfirmedAsync(user.Id))) { return(Ok("Please check your Inbox to reset your password")); } string code = await AppUserManager.GeneratePasswordResetTokenAsync(user.Id); var callbackUrl = String.Format("{0}/passwordrecovery/?email={1}&token={2}", Request.RequestUri.GetLeftPart(UriPartial.Authority), email, HttpUtility.UrlEncode(code)); var emailHtml = ViewRenderer.RenderView("~/Views/Email/Forgot Password.cshtml", new System.Web.Mvc.ViewDataDictionary { { "Url", callbackUrl }, }); EmailSender.SendEmail(user.UserName, "right.now. - Reset your Password", emailHtml); return(Ok("Please check your Inbox to reset your password")); } return(Ok("Please check your Inbox to reset your password")); }
public override void OnActionExecuting(ActionExecutingContext context) { base.OnActionExecuting(context); if (context.HttpContext.User.Identity.IsAuthenticated) { string errorMessage = "You are not able to do this action."; AppDbContext _context = (AppDbContext)context.HttpContext.RequestServices.GetService(typeof(AppDbContext)) as AppDbContext; AppUserManager _userManager = context.HttpContext.RequestServices.GetService(typeof(AppUserManager)) as AppUserManager; if (_context == null || _userManager == null) { return; } var user = _userManager.FindByNameAsync(context.HttpContext.User.Identity.Name).Result; if (context.HttpContext.User.IsInRole(PharmacyRoles.Employee)) { var emp = _context.Employees.FirstOrDefault(x => x.UserId.Equals(user.Id)); if (emp == null) { context.Result = new BadRequestObjectResult(errorMessage); } if (emp.State == UserStates.Deactive) { context.Result = new BadRequestObjectResult(errorMessage); } } else if (context.HttpContext.User.IsInRole(PharmacyRoles.Doctor)) { var doc = _context.Doctors.FirstOrDefault(x => x.UserId.Equals(user.Id)); if (doc == null) { context.Result = new BadRequestObjectResult(errorMessage); } if (doc.State == UserStates.Deactive) { context.Result = new BadRequestObjectResult(errorMessage); } } } }
/* * public async Task<IdentityResult> RegisterUser(UserModel userModel) * { * IdentityUser user = new IdentityUser * { * UserName = userModel.UserName * }; * * var result = await _userManager.CreateAsync(user, userModel.Password); * * return result; * } */ public async Task <ApplicationUser> FindUser(string userName, string password) { ApplicationUser user = null; #if DEBUG user = await _userManager.FindByNameAsync(userName); #else var separateUsername = userName.ToLower().Split('\\'); if (separateUsername.Length == 2) { string domen = char.ToUpper((separateUsername[0])[0]) + separateUsername[0].Substring(1); MembershipProvider membersip = Membership.Providers["ADMembershipProvider" + domen]; if (membersip != null & membersip.ValidateUser(separateUsername[1], password)) { user = _userManager.FindByName(userName); if (user == null) { // return SignInStatus.Failure; ApplicationUser newAccount = new ApplicationUser() { UserName = userName, Email = $"{separateUsername[1]}@gsu.by" }; var result = await _userManager.CreateAsync(newAccount); user = _userManager.FindByName(userName); } } } else { user = await _userManager.FindAsync(userName, password); } #endif return(user); }
public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var user = await AppUserManager.FindByNameAsync(model.Email); if (user == null) { // Don't reveal that the user does not exist return(RedirectToAction("ResetPasswordConfirmation", "Account")); } var result = await AppUserManager.ResetPasswordAsync(user.Id, model.Code, model.Password); if (result.Succeeded) { return(RedirectToAction("ResetPasswordConfirmation", "Account")); } AddErrors(result); return(View()); }
public async Task <ActionResult> ForgotPassword(ForgotPasswordViewModel model) { if (ModelState.IsValid) { var user = await AppUserManager.FindByNameAsync(model.Email); if (user == null || !(await AppUserManager.IsEmailConfirmedAsync(user.Id))) { // Don't reveal that the user does not exist or is not confirmed return(View("ForgotPasswordConfirmation")); } // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771 // Send an email with this link // string code = await AppUserManager.GeneratePasswordResetTokenAsync(user.Id); // var callbackUrl = Url.Action("ResetPassword", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme); // await AppUserManager.SendEmailAsync(user.Id, "Reset Password", "Please reset your password by clicking <a href=\"" + callbackUrl + "\">here</a>"); // return RedirectToAction("ForgotPasswordConfirmation", "Account"); } // If we got this far, something failed, redisplay form return(View(model)); }
public async Task <RepositoryResult <UserInterfaceModel> > GetUserByNameForInterfaceAsync(string userName) { try { if (string.IsNullOrEmpty(userName)) { return(new RepositoryResult <UserInterfaceModel>(HttpStatusCode.BadRequest)); } var user = await AppUserManager.FindByNameAsync(userName); if (user == null) { return(new RepositoryResult <UserInterfaceModel>(HttpStatusCode.NotFound)); } return(new RepositoryResult <UserInterfaceModel>(HttpStatusCode.OK, Mapper.Map <UserInterfaceModel>(user))); } catch (Exception ex) { throw ex; } }
private void CheckAdminUserYN() { var adminRole = roleManager.FindByNameAsync("Administrators"); long adminRoleId = -1; if (adminRole.Result == null) { var appRole = new AppRole { Name = "Administrators" }; var result = roleManager.CreateAsync(appRole).Result; if (result.Succeeded) { adminRoleId = appRole.Id; } } var adminUser = userManager.FindByNameAsync("*****@*****.**"); if (adminUser.Result == null) { var appUser = new AppUser { UserName = "******", Email = "*****@*****.**", }; var result = userManager.CreateAsync(appUser, "dbaldud123@").Result; if (result.Succeeded) { appUser.Roles.Add(new AppUserRole { UserId = appUser.Id, RoleId = adminRoleId }); } userManager.Update(appUser); } }
public async Task <HttpResponseMessage> SetDelegateDefault(HttpRequestMessage request, string userId, string groupId, GroupCreateUpdateModel groupVm) { if (!ModelState.IsValid) { return(request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState)); } else { List <string> lstRequestId = new List <string>(); List <string> lstExplanationRequestId = new List <string>(); List <object> lstData = new List <object>(); List <Request> lstRequest = new List <Request>(); List <ExplanationRequest> lstExplanationRequest = new List <ExplanationRequest>(); var ChangeStatusById = AppUserManager.FindByNameAsync(User.Identity.Name).Result.Id; var newGroup = _groupService.GetGroupById(groupVm.ID.ToString()); newGroup.UpdateGroup(groupVm); _groupService.Update(newGroup); _groupService.SaveChange(); //Get request by user and group.Filter by StatusRequest is Pendding var model = _requestService.GetAllRequestByUser(userId, groupId); var group = _groupService.GetGroupById(groupId); var data = model.Where(x => x.StatusRequest.Name.Equals(CommonConstants.StatusPending)); if (group.DelegateId != null) { foreach (var item in data) { if (item.CreatedDate != null) { if (group.StartDate <= item.CreatedDate.Value.Date && group.EndDate >= item.CreatedDate.Value.Date) { lstRequestId.Add(item.ID.ToString()); lstRequest.Add(item); } } } lstData.AddRange(lstRequest); //Change status request by delegate default _requestService.ChangeStatusDelegateDefault(CommonConstants.StatusDelegation, newGroup.DelegateId, newGroup.StartDate.Value, newGroup.EndDate.Value, ChangeStatusById, lstRequestId.ToArray()); } //Get explanation by userid and groupid.Filter by StatusRequest is Pending var explanation = _explanationRequestService.GetListExplanationByUser(userId, groupId).Where(a => a.StatusRequest.Name.Equals(CommonConstants.StatusPending)); if (explanation.Count() > 0 && group.DelegateId != null) { foreach (var explanationItem in explanation) { if (explanationItem.CreatedDate != null) { if (group.StartDate <= explanationItem.CreatedDate.Value.Date && group.EndDate >= explanationItem.CreatedDate.Value.Date) { lstExplanationRequest.Add(explanationItem); lstExplanationRequestId.Add(explanationItem.ID.ToString()); } } } lstData.AddRange(lstExplanationRequest); //Change status explanation request by delegate default _explanationRequestService.ChangeStatusExplanationDelegateDefault(lstExplanationRequestId.ToArray(), CommonConstants.StatusDelegation, newGroup.DelegateId, newGroup.StartDate.Value, newGroup.EndDate.Value); } return(request.CreateResponse(HttpStatusCode.Created, lstData)); } }
// GET: Order public ActionResult Index() { ApplicationUser user = AppUserManager.FindByNameAsync(User.Identity.Name).Result; return(View(AppDbContext.Order.Where(o => o.UserID == user.Id).OrderByDescending(o => o.ID).ToList())); }
//[HttpPost("sign-in", Name = "PostLogin")] public async Task <IActionResult> Login(LoginAccount account, string returnTo) { if (account.Email.IndexOf('@') > -1) { //Validate email format string emailRegex = @"^([a-zA-Z0-9_\-\.]+)@((\[[0-9]{1,3}" + @"\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([a-zA-Z0-9\-]+\" + @".)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$"; Regex re = new Regex(emailRegex); if (!re.IsMatch(account.Email)) { ModelState.AddModelError("Email", "ایمیل معتبر نمیباشد"); } if (ModelState.IsValid) { var user = await _userManager.FindByEmailAsync(account.Email); if (user != null) { var result = await _signInManager.PasswordSignInAsync( userName : user.UserName, password : account.Password, isPersistent : account.RememberMe, lockoutOnFailure : true); if (result.Succeeded) { return(RedirectToLocal(returnTo)); } if (result.RequiresTwoFactor) { return(RedirectToRoute("GetSendCode", new { returnTo, rememberMe = account.RememberMe })); } if (result.IsLockedOut) { // todo create lockout view return(View("LockOut")); } if (result.IsNotAllowed) { if (_userManager.Options.SignIn.RequireConfirmedPhoneNumber) { if (!await _userManager.IsPhoneNumberConfirmedAsync(new User { UserName = account.Email })) { ModelState.AddModelError(string.Empty, "شماره تلفن شما تایید نشده است."); return(View(account)); } } if (_userManager.Options.SignIn.RequireConfirmedEmail) { if (!await _userManager.IsEmailConfirmedAsync(new User { UserName = account.Email })) { ModelState.AddModelError(string.Empty, "آدرس ایمیل شما تایید نشده است."); return(View(account)); } } } } } } else { //validate Username format string emailRegex = @"^[a-zA-Z0-9]*$"; Regex re = new Regex(emailRegex); if (!re.IsMatch(account.Email)) { ModelState.AddModelError("Email", "نام کاربری معتبر نمیباشد"); } else { if (ModelState.IsValid) { var user = await _userManager.FindByNameAsync(account.Email); if (user != null) { var result = await _signInManager.PasswordSignInAsync( userName : account.Email, password : account.Password, isPersistent : account.RememberMe, lockoutOnFailure : false); if (result.Succeeded) { return(RedirectToLocal(returnTo)); } if (result.RequiresTwoFactor) { return(RedirectToRoute("GetSendCode", new { returnTo, rememberMe = account.RememberMe })); } if (result.IsLockedOut) { // todo create lockout view return(View("LockOut")); } if (result.IsNotAllowed) { if (_userManager.Options.SignIn.RequireConfirmedPhoneNumber) { if (!await _userManager.IsPhoneNumberConfirmedAsync(new User { UserName = account.Email })) { ModelState.AddModelError(string.Empty, "شماره تلفن شما تایید نشده است."); return(View(account)); } } if (_userManager.Options.SignIn.RequireConfirmedEmail) { if (!await _userManager.IsEmailConfirmedAsync(new User { UserName = account.Email })) { ModelState.AddModelError(string.Empty, "آدرس ایمیل شما تایید نشده است."); return(View(account)); } } } } } } } ModelState.AddModelError(string.Empty, "نام کاربری و یا کلمهی عبور وارد شده معتبر نیستند."); return(View(account)); }
public async Task <HttpResponseMessage> Create(HttpRequestMessage request, AppUserViewModel applicationUserViewModel) { if (ModelState.IsValid) { if (User != null && MemoryCacheHelper.RemoveUserEditByAdmin(User.Identity.Name)) { return(request.CreateErrorResponse(HttpStatusCode.BadRequest, CommonConstants.Error_Edit_By_Admin)); } if (applicationUserViewModel.Roles.Contains(CommonConstants.GroupLead) && applicationUserViewModel.GroupId != null) { var groupleaderID = AppRoleManager.FindByNameAsync(CommonConstants.GroupLead).Result.Id; var groupLeader = AppUserManager.Users.Where(x => x.Roles.Any(r => r.RoleId.Equals(groupleaderID) && x.GroupId == applicationUserViewModel.GroupId)).FirstOrDefault(); if (groupLeader != null && !groupLeader.Equals(applicationUserViewModel)) { return(request.CreateResponse(HttpStatusCode.BadRequest, MessageSystem.Error_Create_Exist_Group_Lead)); } } var username = AppUserManager.FindByNameAsync(applicationUserViewModel.UserName).Result; var email = AppUserManager.FindByEmailAsync(applicationUserViewModel.Email).Result; //if (username != null && email != null) //{ // if (username.Status == false) // { // return request.CreateResponse(HttpStatusCode.OK, "Inaction"); // } //} if (username != null) { if (username.Status == true) { return(request.CreateErrorResponse(HttpStatusCode.BadRequest, MessageSystem.MessageDuplicateUserName)); } } if (email != null) { if (email.Status == true) { return(request.CreateErrorResponse(HttpStatusCode.BadRequest, MessageSystem.MessageDuplicateEmail)); } else { return(request.CreateResponse(HttpStatusCode.OK, "Inaction")); } } var newAppUser = new AppUser(); newAppUser.UpdateUser(applicationUserViewModel); newAppUser.Status = true; try { newAppUser.Id = Guid.NewGuid().ToString(); if (applicationUserViewModel.ListUserNo != null && applicationUserViewModel.ListUserNo.Count() > 0) { if (!ValidateUserNo(applicationUserViewModel.ListUserNo.Split('-'))) { return(request.CreateResponse(HttpStatusCode.BadRequest, MessageSystem.MessageUserNoNotValid)); } if (_fingermachineuserService.IsUserNoExist(applicationUserViewModel.ListUserNo.Split('-').ToList())) { return(request.CreateResponse(HttpStatusCode.BadRequest, MessageSystem.MessageUserNoExist)); } } var checkStartDateAndBirthDay = _userService.CheckStartDateAndBirthDay(applicationUserViewModel.BirthDay, applicationUserViewModel.StartWorkingDay); if (!string.IsNullOrEmpty(checkStartDateAndBirthDay)) { return(request.CreateErrorResponse(HttpStatusCode.BadRequest, checkStartDateAndBirthDay)); } var result = await AppUserManager.CreateAsync(newAppUser, applicationUserViewModel.Password); if (result.Succeeded) { var roles = applicationUserViewModel.Roles.ToArray(); await AppUserManager.AddToRolesAsync(newAppUser.Id, roles); //Create entitle day of user new _entitleDayAppUserService.CreateEntitleDayAppUser(newAppUser); //Add user into table config delegation var configDelegation = new ConfigDelegation(); configDelegation.UserId = newAppUser.Id; _configDelegateionService.Add(configDelegation); _configDelegateionService.SaveChange(); if (applicationUserViewModel.ListUserNo != null) { List <string> lstUserno = applicationUserViewModel.ListUserNo.Split('-').ToList(); if (lstUserno.Count() > 0) { if (_fingermachineuserService.IsUserNoExist(lstUserno)) { return(request.CreateResponse(HttpStatusCode.BadRequest, MessageSystem.MessageUserNoExist)); } else { foreach (var item in lstUserno) { _fingermachineuserService.Create(new FingerMachineUser() { ID = item, UserId = newAppUser.Id }); } _unitOfWork.Commit(); } } } return(request.CreateResponse(HttpStatusCode.OK, applicationUserViewModel)); } else { return(request.CreateErrorResponse(HttpStatusCode.BadRequest, string.Join(",", result.Errors))); } } catch (NameDuplicatedException dex) { return(request.CreateErrorResponse(HttpStatusCode.BadRequest, dex.Message)); } catch (Exception ex) { return(request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message)); } } else { return(request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState)); } }
protected async Task <ApplicationUser> GetUserByNameAsync(string username) { return(await AppUserManager.FindByNameAsync(username)); }
public async Task <ApplicationUser> FindByNameAsync(string userName) { return(await _userManager.FindByNameAsync(userName)); }
public async Task <IHttpActionResult> GetUser() { var user = await AppUserManager.FindByNameAsync(User.Identity.Name); return(user != null ? (IHttpActionResult)Ok(TheModelFactory.Create(user)) : NotFound()); }
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl) { ViewBag.ReturnUrl = returnUrl; if (!ModelState.IsValid) { return(View(model)); } if (Request.IsAuthenticated) { return(RedirectToLocal(returnUrl)); } // Require the user to have a confirmed email before they can log on. var allowPassOnEmailVerfication = false; var user = await UserManager.FindByNameAsync(model.Email); if (user != null) { if (!string.IsNullOrWhiteSpace(user.UnConfirmedEmail)) { allowPassOnEmailVerfication = true; } if (!await UserManager.IsEmailConfirmedAsync(user.Id) && !allowPassOnEmailVerfication) { string callbackUrl = await SendEmailConfirmationTokenAsync(user.Id, user.UniqueId, "Confirm your account - Resent"); this.SetNotificationMessage(NotificationType.Error, string.Format("You must have a confirmed email address to log in.{0}{0}We've resent you an email to confirm your address.", Environment.NewLine)); return(View()); } } // This doesn't count login failures towards account lockout // To enable password failures to trigger account lockout, change to shouldLockout: true var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout : true); switch (result) { case SignInStatus.Success: if (user != null) { user.LoginCount = user.LoginCount + 1; user.LastLogin = DateTime.UtcNow; UserManager.Update(user); // Create a trial subscription if one doesn't exist for all companies of this user. This is necessary for creating subscriptions for all the users that // were in the system before subscriptions were introduced. _subscriptionManager.CreateMissingSubscriptions(user.Id); } return(RedirectToLocal(returnUrl)); case SignInStatus.LockedOut: return(View("Lockout")); case SignInStatus.RequiresVerification: // allow user to log in if its the new email address that's awaiting verification return(allowPassOnEmailVerfication ? RedirectToLocal(returnUrl) : RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe })); case SignInStatus.Failure: default: this.SetNotificationMessage(NotificationType.Error, "Invalid login attempt."); return(View(model)); } }
public Task <User> GetByUserName(string userName) { return(_userManager.FindByNameAsync(userName)); }
public async System.Threading.Tasks.Task <string> GetCurrentUserId() { var user = await AppUserManager.FindByNameAsync(User.Identity.Name); return(user.Id); }
public async Task <IHttpActionResult> Login(LoginBindingModel LoginModel) { var ctx = ApplicationDbContext.Create(); if (string.IsNullOrWhiteSpace(LoginModel.username) || string.IsNullOrWhiteSpace(LoginModel.password)) { return(NotFound()); } var user = await AppUserManager.FindByNameAsync(LoginModel.username); if (user == null) { return(NotFound()); } var passwordSignInResult = await AppUserManager.CheckPasswordAsync(user, LoginModel.password); if (!passwordSignInResult) { ctx.Login_Logs.Add(new Login_Logs() { Ip_Address = Request.GetOwinContext().Request.RemoteIpAddress, Status = "The password is incorrect.", Time = DateTime.Now, UserId = user.Id, }); await ctx.SaveChangesAsync(); return(NotFound()); } //Get Token from ~//oauth/token HttpClient client = new HttpClient(); client.BaseAddress = new Uri(Startup.address); client.DefaultRequestHeaders .Accept .Add(new MediaTypeWithQualityHeaderValue("application/json")); client.DefaultRequestHeaders.TryAddWithoutValidation("Content-Type", "application/json; charset=utf-8"); var json = new JavaScriptSerializer().Serialize(LoginModel); HttpResponseMessage response = await client.PostAsJsonAsync("/oauth/token", json); if (response.StatusCode == System.Net.HttpStatusCode.OK) { ctx.Login_Logs.Add(new Login_Logs() { Ip_Address = Request.GetOwinContext().Request.RemoteIpAddress, Status = "Login Successful.", Time = DateTime.Now, UserId = user.Id, }); await ctx.SaveChangesAsync(); return(Ok(response.Content)); } else { return(BadRequest(response.ReasonPhrase)); } }
public async Task <HttpResponseMessage> Create(HttpRequestMessage request, RequestViewModel requestViewModel) { return(await CreateHttpResponse(request, () => { HttpResponseMessage response = null; if (!ModelState.IsValid) { response = request.CreateResponse(HttpStatusCode.BadRequest, ModelState); } var dateNow = DateTime.Now.Date; if (requestViewModel.StartDate < dateNow) { return request.CreateResponse(HttpStatusCode.BadRequest, MessageSystem.ERROR_CREATE_REQUEST_IN_PAST_NOT_MSG); } else { requestViewModel.AppUser = new Models.AppUserViewModel(); requestViewModel.CreatedDate = DateTime.Now; requestViewModel.UserId = AppUserManager.FindByNameAsync(User.Identity.Name).Result.Id; requestViewModel.AppUser.GroupId = AppUserManager.FindByNameAsync(User.Identity.Name).Result.GroupId ?? 0; requestViewModel.Status = true; //requestViewModel.ChangeStatusById = __groupService.GetGroupLeadIdByGroup(requestViewModel.AppUser.GroupId.Value); Request newRequest = new Request(); newRequest.UpdateRequest(requestViewModel); //Check Request Day Off var model = _requestService.GetAllRequest(newRequest); if (model == 0) { if (_requestService.checkUnitEntitleday(newRequest)) { if (_requestService.Add(newRequest)) { var responseData = Mapper.Map <Request, RequestViewModel>(newRequest); var group = __groupService.GetGroupById(requestViewModel.AppUser.GroupId.ToString()); responseData.GroupName = group.Name; var dataDelegation = _configDelegationService.GetDelegationByUserId(newRequest.UserId); if (dataDelegation.StartDate <= newRequest.CreatedDate.Value.Date && dataDelegation.EndDate >= newRequest.CreatedDate.Value.Date) { responseData.CheckConfigDelegateDefault = true; responseData.AssignConfigDelegate = dataDelegation.AssignTo; _configDelegationService.ChangeStatusAfterAddRequest(dataDelegation.AssignTo, newRequest); } else { if (newRequest.CreatedDate != null) { if (group.DelegateId != null && group.StartDate <= newRequest.CreatedDate.Value.Date && group.EndDate >= newRequest.CreatedDate.Value.Date) { responseData.CheckGroupDelegateDefault = true; responseData.AssignGroupDelegate = group.DelegateId; _requestService.CheckDelegateDefault(requestViewModel.AppUser.GroupId.ToString(), newRequest.ID, newRequest.ChangeStatusById); } } } return request.CreateResponse(HttpStatusCode.Created, responseData); } } else { return request.CreateResponse(HttpStatusCode.BadRequest, MessageSystem.ERROR_REQUEST_ENTITLEDAY); } return request.CreateResponse(HttpStatusCode.BadRequest, MessageSystem.ERROR_CREATE_REQUEST_NOT_MSG); } if (model == 1) { return request.CreateResponse(HttpStatusCode.BadRequest, MessageSystem.ERROR_REQUEST_FULLTIME); } if (model == 2) { return request.CreateResponse(HttpStatusCode.BadRequest, MessageSystem.ERROR_REQUEST_FULLTIME_MORNING); } if (model == 3) { return request.CreateResponse(HttpStatusCode.BadRequest, MessageSystem.ERROR_REQUEST_FULLTIME_AFTERNOON); } if (model == 4) { return request.CreateResponse(HttpStatusCode.BadRequest, MessageSystem.ERROR_REQUEST_FULLTIME_LATECOMING); } if (model == 5) { return request.CreateResponse(HttpStatusCode.BadRequest, MessageSystem.ERROR_REQUEST_FULLTIME_EARLYLEAVING); } if (model == 6) { return request.CreateResponse(HttpStatusCode.BadRequest, MessageSystem.ERROR_REQUEST_FULLTIME); } if (model == 7) { return request.CreateResponse(HttpStatusCode.BadRequest, MessageSystem.ERROR_REQUEST_MORNING); } if (model == 8) { return request.CreateResponse(HttpStatusCode.BadRequest, MessageSystem.ERROR_REQUEST_MORNING_LATECOMING); } if (model == 9) { return request.CreateResponse(HttpStatusCode.BadRequest, MessageSystem.ERROR_REQUEST_FULLTIME); } if (model == 10) { return request.CreateResponse(HttpStatusCode.BadRequest, MessageSystem.ERROR_REQUEST_AFTERNOONLEAVE); } if (model == 11) { return request.CreateResponse(HttpStatusCode.BadRequest, MessageSystem.ERROR_REQUEST_AFTERNOONLEAVE_EARLYLEAVING); } if (model == 12) { return request.CreateResponse(HttpStatusCode.BadRequest, MessageSystem.ERROR_REQUEST_FULLTIME); } if (model == 13) { return request.CreateResponse(HttpStatusCode.BadRequest, MessageSystem.ERROR_REQUEST_MORNING_LATECOMING); } if (model == 14) { return request.CreateResponse(HttpStatusCode.BadRequest, MessageSystem.ERROR_REQUEST_LATECOMING_EARLYLEAVING); } if (model == 15) { return request.CreateResponse(HttpStatusCode.BadRequest, MessageSystem.ERROR_REQUEST_FULLTIME); } if (model == 16) { return request.CreateResponse(HttpStatusCode.BadRequest, MessageSystem.ERROR_REQUEST_EARLYLEAVING_AFTERNOONLEAVE); } if (model == 17) { return request.CreateResponse(HttpStatusCode.BadRequest, MessageSystem.ERROR_REQUEST_EARLYLEAVING); } } return response; })); }
public async Task <IHttpActionResult> PictureUploadPost() { var request = HttpContext.Current.Request; var validationRules = new FlowValidationRules(); validationRules.AcceptedExtensions.AddRange(new List <string> { "jpeg", "jpg", "png", "bmp" }); validationRules.MaxFileSize = 50000000; try { var status = _flowJs.PostChunk(request, _folder, validationRules); if (status.Status == PostChunkStatus.Done) { var filePath = Path.Combine(_folder, status.FileName); string extension = ImageResizer.Util.PathUtils.GetExtension(filePath); string basePath = ImageResizer.Util.PathUtils.RemoveExtension(filePath); string fileName = Guid.NewGuid() + "." + status.FileName.Split('.').Last(); string userPhotoPath = basePath + "_user_photo" + extension; ImageBuilder.Current.Build(filePath, userPhotoPath, new ResizeSettings("maxwidth=" + ConfigurationManager.AppSettings["userPhotoMaxWidth"] + "&format=jpg")); using (var fileStream = File.OpenRead(userPhotoPath)) { _blobRepository.UploadImageFromStream(fileStream, fileName); } File.Delete(filePath); File.Delete(userPhotoPath); var user = await AppUserManager.FindByNameAsync(User.Identity.Name); // Remove old user photo from storage (but not the default one): if (user.PhotoPath != ConfigurationManager.AppSettings["userDefaultImageName"]) { _blobRepository.RemoveImage(user.PhotoPath); } user.PhotoPath = fileName; IdentityResult result = await AppUserManager.UpdateAsync(user); if (!result.Succeeded) { return(GetErrorResult(result)); } return(Ok(fileName)); } if (status.Status == PostChunkStatus.PartlyDone) { return(Ok()); } status.ErrorMessages.ForEach(x => ModelState.AddModelError("file", x)); return(BadRequest(ModelState)); } catch (Exception) { ModelState.AddModelError("file", "exception"); return(BadRequest(ModelState)); } }
public async Task <IHttpActionResult> GetUserByName(string username) { var user = await AppUserManager.FindByNameAsync(username); return(user != null?Ok(TheModelFactory.Create(user)) : GetErrorFromModel("username", "Не удается найти пользователя")); }
protected async Task <ApplicationUser> GetCurrentUserAsync() { return(await AppUserManager.FindByNameAsync(CurrentUserName)); }
public static MvcHtmlString GetName(this HtmlHelper html, string username) { AppUserManager mgr = HttpContext.Current.GetOwinContext().GetUserManager <AppUserManager>(); return(new MvcHtmlString(mgr.FindByNameAsync(username).Result.UserName)); }
public static async Task Initialize(ApplicationDbContext context, AppUserManager userManager, RoleManager <ApplicationRole> roleManager, AppSetupOptions options, ILogger logger) { logger.LogInformation("Data Seeder Started"); if (context is null) { throw new ArgumentNullException(nameof(context)); } if (userManager is null) { throw new ArgumentNullException(nameof(userManager)); } if (roleManager is null) { throw new ArgumentNullException(nameof(roleManager)); } if (options is null) { throw new ArgumentNullException(nameof(options)); } if (logger is null) { throw new ArgumentNullException(nameof(logger)); } context.Database.EnsureCreated(); try { if (await roleManager.FindByNameAsync(options.AdminRoleName) == null) { await roleManager.CreateAsync(new ApplicationRole { Name = options.AdminRoleName }); var adminRole = await roleManager.FindByNameAsync(options.AdminRoleName); await roleManager.AddClaimAsync(adminRole, new Claim(CustomClaimTypes.Permission, Permissions.AdminUser.Read)); } if (await roleManager.FindByNameAsync(options.ManagerRoleName) == null) { await roleManager.CreateAsync(new ApplicationRole { Name = options.ManagerRoleName }); } if (await roleManager.FindByNameAsync(options.NormalRoleName) == null) { await roleManager.CreateAsync(new ApplicationRole { Name = options.NormalRoleName }); } ApplicationUser user = await userManager.FindByNameAsync(options.AdminUserName); if (user == null) { user = new ApplicationUser(); user.UserName = options.AdminUserName; user.EmailConfirmed = true; user.Email = options.AdminUserName; var result = await userManager.CreateAsync(user, options.AdminUserPass); var tenantresult = await userManager.CreateTenantAsync(options.DefaultTenantName, user); if (result.Succeeded && tenantresult.Succeeded) { ApplicationTenant tenant = userManager.FindTenantByName(options.DefaultTenantName); await userManager.AddToRoleAsync(user, tenant, options.AdminRoleName); } } List <GeoCity> listOfLocations = new List <GeoCity>(); IOrderedEnumerable <Country> countries = null; if (!context.Countries.Any()) { listOfLocations.AddRange(File.ReadLines("Data\\worldcities.csv").Select(line => new GeoCity(line)).ToList()); countries = listOfLocations.Select(s => new Country { Name = s.Country, CountryCode = s.Iso2 }).GroupBy(g => g.Name).Select(q => q.First()).OrderBy(o => o.Name); var i = countries.Count(); await context.Countries.AddRangeAsync(countries); await context.SaveChangesAsync(); } if (!context.GeoLocations.Any() || countries == null) { foreach (var location in listOfLocations) { GeoLocation Location = new GeoLocation(); Location.isCity = true; Location.Name = location.City; Location.Latitude = location.Lat; Location.Longitude = location.Lng; Location.Country = countries.FirstOrDefault(q => q.CountryCode == location.Iso2); await context.GeoLocations.AddAsync(Location); } } await context.SaveChangesAsync(); } catch (Exception ex) { logger.LogError(ex, "An error occurred while seeding the database."); //throw; } }