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