public async Task <ActionResult> ResetPassword([Bind(Include = "SinginId,Email")] RequestMailViewModel model)
{
if (string.IsNullOrEmpty(model.SinginId) && string.IsNullOrEmpty(model.Email))
{
ModelState.AddModelError("", AuthResources.RequestMailNoParam);
return(View(model));
}
UserModel user = null;
if (!string.IsNullOrEmpty(model.SinginId))
{
user = await UserManager.FindByNameAsync(model.SinginId);
}
else if (!string.IsNullOrEmpty(model.Email))
{
user = await UserManager.FindByEmailAsync(model.Email);
}
if (user == null || !UserManager.IsEmailConfirmed(user.Id))
{
ModelState.AddModelError("", AuthResources.ResetPasswordNoUserOrNoConfirm);
return(View(model));
}
string code = UserManager.GeneratePasswordResetToken(user.Id);
string callbackUrl = Url.Action("Reset", "Account", new { key = user.Id, code = code }, protocol: Request.Url.Scheme);
string linktext = AuthResources.MailResetPasswordBody + callbackUrl;
UserManager.SendEmail(user.Id, AuthResources.MailResetPasswordSubject, linktext);
return(View("MailSendComplete"));
}
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(model));
}
// This doen't count login failures towards lockout only two factor authentication
// To enable password failures to trigger lockout, change to shouldLockout: true
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout : false);
switch (result)
{
case SignInStatus.Success:
if (!UserManager.IsEmailConfirmed(UserManager.FindByName(model.Email).Id))
{
AuthenticationManager.SignOut();
return(View("DisplayEmail"));
}
return(RedirectToLocal(returnUrl));
case SignInStatus.LockedOut:
return(View("Lockout"));
case SignInStatus.RequiresVerification:
return(RedirectToAction("SendCode", new { ReturnUrl = returnUrl, model.RememberMe }));
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return(View(model));
}
}
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
ApplicationUser user = UserManager.Find(model.UserName, model.Password);
if (user != null)
{
if (!UserManager.IsEmailConfirmed(user.Id))
{
ModelState.AddModelError("", "Bạn cần phải xác thực Email");
return(View(model));
}
IAuthenticationManager authenticationManager = HttpContext.GetOwinContext().Authentication;
authenticationManager.SignOut(DefaultAuthenticationTypes.ExternalCookie);
ClaimsIdentity identity = _userManager.CreateIdentity(user, DefaultAuthenticationTypes.ApplicationCookie);
AuthenticationProperties props = new AuthenticationProperties();
props.IsPersistent = model.RememberMe;
authenticationManager.SignIn(props, identity);
if (Url.IsLocalUrl(returnUrl))
{
return(Redirect(returnUrl));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
else
{
ModelState.AddModelError("", "Tên đăng nhập hoặc mật khẩu không đúng.");
}
}
return(View(model));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking this link: <a href=\"" + callbackUrl + "\">link</a>");
if (!UserManager.IsEmailConfirmed(user.Id))
{
return(View("EmailNotConfirmed"));
}
else
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
}
ViewBag.Link = callbackUrl;
return(View("DisplayEmail"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl)
{
try
{
if (!ModelState.IsValid)
{
return(PartialView(model));
}
// This doen't count login failures towards lockout only two factor authentication
// To enable password failures to trigger lockout, change to shouldLockout: true
//Restricts login unless email confirmation
var userid = UserManager.FindByEmail(model.Email).Id;
if (!UserManager.IsEmailConfirmed(userid))
{
return(PartialView("EmailNotConfirmed"));
}
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout : false);
var user = await UserManager.FindByIdAsync(userid);
// var roles = await UserManager.GetRolesAsync(userid);
var roles = await UserManager.GetRolesAsync(user.Id);
switch (result)
{
case SignInStatus.Success:
if (roles[0] == "Staff")
{
return(RedirectToAction("Index", "SalesEntry"));
}
return(RedirectToLocal(returnUrl));
case SignInStatus.LockedOut:
return(View("Lockout"));
case SignInStatus.RequiresVerification:
return(RedirectToAction("SendCode", new { ReturnUrl = returnUrl }));
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return(PartialView(model));
}
}
catch (Exception e)
{
ModelState.AddModelError("", "Invalid login attempt.");
return(PartialView(model));
}
}
public ActionResult Index()
{
var userId = User.Identity.GetUserId();
var user = Database.Users.Find(userId);
if (user == null)
{
return(LogOff());
}
ViewBag.IsConfirmed = UserManager.IsEmailConfirmed(userId);
return(View(user));
}
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(model));
}
else
{
var userid = UserManager.FindByEmail(model.Email);
if (userid == null)
{
ModelState.AddModelError("", "Invalid login attempt.");
return(View(model));
}
if (!UserManager.IsEmailConfirmed(userid.Id))
{
return(View("DisplayEmail"));
}
else
{
if (userid.isReset == true)
{
var code = await UserManager.GeneratePasswordResetTokenAsync(userid.Id);
return(RedirectToAction("ResetPassword", new { code = code }));
}
else
{
// This doesn't count login failures towards lockout only two factor authentication
// To enable password failures to trigger lockout, change to shouldLockout: true
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout : false);
switch (result)
{
case SignInStatus.Success:
return(RedirectToLocal(returnUrl));
case SignInStatus.LockedOut:
return(View("Lockout"));
case SignInStatus.RequiresVerification:
return(RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe }));
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return(View(model));
}
}
}
}
}
public void CanGetEmailConfirmed()
{
var user = IdentityUserMother.BasicUser();
UserManager.Create(user);
var token = UserManager.GenerateEmailConfirmationToken(user.Id);
var result = UserManager.ConfirmEmail(user.Id, token);
result.Succeeded.ShouldBe(true);
UserManager.IsEmailConfirmed(user.Id).ShouldBe(true);
}
public void FindByEmail()
{
var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(this._session));
userManager.Create(new ApplicationUser()
{
UserName = "******", Email = "*****@*****.**", EmailConfirmed = true
}, "Welcome");
var x = userManager.FindByEmail("*****@*****.**");
Assert.IsNotNull(x);
Assert.IsTrue(userManager.IsEmailConfirmed(x.Id));
}
bool ValidLogin(Login login)
{
UserStore <IdentityUser> userStore = new UserStore <IdentityUser>();
UserManager <IdentityUser> userManager = new UserManager <IdentityUser>(userStore)
{
UserLockoutEnabledByDefault = true,
DefaultAccountLockoutTimeSpan = new TimeSpan(0, 10, 0),
MaxFailedAccessAttemptsBeforeLockout = 5
};
var user = userManager.FindByName(login.UserName);
if (user == null)
{
UserNoFound = true;
return(false);
}
// User is locked out.
if (userManager.SupportsUserLockout && userManager.IsLockedOut(user.Id))
{
Locked = true;
return(false);
}
// Validated user was locked out but now can be reset.
if (userManager.CheckPassword(user, login.Password) && userManager.IsEmailConfirmed(user.Id))
{
if (userManager.SupportsUserLockout &&
userManager.GetAccessFailedCount(user.Id) > 0)
{
userManager.ResetAccessFailedCount(user.Id);
}
}
// Login is invalid so increment failed attempts.
else
{
bool lockoutEnabled = userManager.GetLockoutEnabled(user.Id);
PasswordIncorrent = true;
if (userManager.SupportsUserLockout && userManager.GetLockoutEnabled(user.Id))
{
userManager.AccessFailed(user.Id);
return(false);
}
}
return(true);
}
public async Task <ActionResult> Login([ModelBinder(typeof(LoginViewModelBinder))] LoginViewModel model, string returnUrl)
{
//if (!ModelState.IsValid)
//{
// return View(model);
//}
// This doen't count login failures towards lockout only two factor authentication
// To enable password failures to trigger lockout, change to shouldLockout: true
var result = await SignInManager.PasswordSignInAsync(model.Username, model.Password, model.RememberMe, shouldLockout : false);
switch (result)
{
case SignInStatus.Success:
var userid = UserManager.FindByName(model.Username).Id;
if (!UserManager.IsEmailConfirmed(userid))
{
var code = await UserManager.GenerateEmailConfirmationTokenAsync(userid);
var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = userid, code = code }, protocol: Request.Url.Scheme);
await UserManager.SendEmailAsync(userid, "Xác nhận tài khoản", "Hãy xác nhận tài khoản của bạn bằng cách nhấn vào đường dẫn sau: <a href=\"" + callbackUrl + "\">link</a>");
AuthenticationManager.SignOut();
ViewBag.Message = "Bạn chưa xác nhận tài khoản.";
return(View(model));
}
return(RedirectToLocal(returnUrl));
case SignInStatus.LockedOut:
return(View("Lockout"));
case SignInStatus.RequiresVerification:
return(RedirectToAction("SendCode", new { ReturnUrl = returnUrl }));
case SignInStatus.Failure:
ModelState.AddModelError("", "Invalid login attempt.");
ViewBag.Message = "Tên đăng nhập hoặc mật khẩu không đúng.";
return(View(model));
default:
ModelState.AddModelError("", "Invalid login attempt.");
ViewBag.Message = "Tên đăng nhập hoặc mật khẩu không đúng.";
return(View(model));
}
}
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(model));
}
// This doen't count login failures towards lockout only two factor authentication
// To enable password failures to trigger lockout, change to shouldLockout: true
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout : false);
switch (result)
{
case SignInStatus.Success:
var userid = UserManager.FindByEmail(model.Email).Id;
AspNetUserExtendedModel _extUser = AspNetUserExtendedModel.LoadModel(userid);
if (!UserManager.IsEmailConfirmed(userid))
{
var code = await UserManager.GenerateEmailConfirmationTokenAsync(userid);
var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = userid, code = code }, protocol: Request.Url.Scheme);
await UserManager.SendEmailAsync(userid, "INOCRM WebAdmin Yönetim Paneli", "Lütfen hesabınızı doğrulamak için bağlantıya tıklayınız <a href=\"" + callbackUrl + "\">Hesap Doğrulama Bağlantısı</a>");
// Show message
return(RedirectToAction("DisplayEmail"));
}
Session["CurrentUserExtended"] = _extUser;
return(RedirectToLocal(returnUrl));
case SignInStatus.LockedOut:
return(View("Lockout"));
case SignInStatus.RequiresVerification:
return(RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe }));
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return(View(model));
}
}
public IHttpActionResult ForgotPassword(ForgotPasswordModel model)
{
if (ModelState.IsValid)
{
var user = UserManager.FindByEmail(model.Email);
if (user == null || !(UserManager.IsEmailConfirmed(user.Id)))
{
return(BadRequest("User does not exist in the system or this email is not confirmed"));
}
var code = UserManager.GeneratePasswordResetToken(user.Id);
var callBackUrl = new Uri(Url.Link("ResetPasswordViewRoute", new { Email = user.Email, code = code }));
UserManager.SendEmail(user.Id, "Reset Password", "Please reset your password by clicking here: <a href=\"" + callBackUrl + "\">link</a>");
return(Ok("Success"));
}
else
{
return(BadRequest());
}
}
public override Task TokenEndpoint(OAuthTokenEndpointContext context)
{
foreach (KeyValuePair <string, string> property in context.Properties.Dictionary)
{
context.AdditionalResponseParameters.Add(property.Key, property.Value);
}
context.AdditionalResponseParameters.Add("userId", context.Identity.GetUserId());
context.AdditionalResponseParameters.Add("isAuthenticated", context.Identity.IsAuthenticated);
ApplicationDbContext userscontext = new ApplicationDbContext();
var userStore = new UserStore <UserAccount>(userscontext);
var userManager = new UserManager <UserAccount>(userStore);
context.AdditionalResponseParameters.Add("isStudent", userManager.IsInRole(context.Identity.GetUserId(), "Student"));
context.AdditionalResponseParameters.Add("isTeacher", userManager.IsInRole(context.Identity.GetUserId(), "Teacher"));
context.AdditionalResponseParameters.Add("isCompany", userManager.IsInRole(context.Identity.GetUserId(), "Company"));
context.AdditionalResponseParameters.Add("isCoordinator", userManager.IsInRole(context.Identity.GetUserId(), "Coordinator"));
context.AdditionalResponseParameters.Add("emailConfirmed", userManager.IsEmailConfirmed(context.Identity.GetUserId()));
return(Task.FromResult <object>(null));
}
public ActionResult ForgotPassword(ForgotPasswordViewModel model)
{
if (ModelState.IsValid)
{
var user = UserManager.FindByName(model.Email);
if (user == null || !UserManager.IsEmailConfirmed(user.Id))
{
// Don't reveal that the user does not exist or is not confirmed
return(View(nameof(ForgotPasswordConfirmation)));
}
// For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GeneratePasswordResetTokenAsync(user.Id);
// var callbackUrl = Url.Action("ResetPassword", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.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 <ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = UserManager.FindByEmail(model.Email);
if (user != null && !UserManager.IsEmailConfirmed(user.Id))
{
ModelState.AddModelError("", "Please confirm your account by following the instructions in the confirmation email.");
return(View(model));
}
// 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 : false);
switch (result)
{
case SignInStatus.Success:
return(RedirectToLocal(returnUrl));
case SignInStatus.LockedOut:
return(View("Lockout"));
case SignInStatus.RequiresVerification:
return(RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe }));
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return(View(model));
}
}
bool ValidLogin(Login login)
{
UserStore<IdentityUser> userStore = new UserStore<IdentityUser>();
UserManager<IdentityUser> userManager = new UserManager<IdentityUser>(userStore)
{
UserLockoutEnabledByDefault = true,
DefaultAccountLockoutTimeSpan = new TimeSpan(0, 10, 0),
MaxFailedAccessAttemptsBeforeLockout = 3
};
var user = userManager.FindByName(login.UserName);
if (user == null)
return false;
// User is locked out.
if (userManager.SupportsUserLockout && userManager.IsLockedOut(user.Id))
return false;
// Validated user was locked out but now can be reset.
if (userManager.CheckPassword(user, login.Password)
&& userManager.IsEmailConfirmed(user.Id))
{
if (userManager.SupportsUserLockout
&& userManager.GetAccessFailedCount(user.Id) > 0)
{
userManager.ResetAccessFailedCount(user.Id);
}
}
// Login is invalid so increment failed attempts.
else {
bool lockoutEnabled = userManager.GetLockoutEnabled(user.Id);
if (userManager.SupportsUserLockout && userManager.GetLockoutEnabled(user.Id))
{
userManager.AccessFailed(user.Id);
return false;
}
}
return true;
}
public void FindByEmail()
{
var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(this._session));
userManager.Create(new ApplicationUser() { UserName = "******", Email = "*****@*****.**", EmailConfirmed = true }, "Welcome");
var x = userManager.FindByEmail("*****@*****.**");
Assert.IsNotNull(x);
Assert.IsTrue(userManager.IsEmailConfirmed(x.Id));
}
public virtual async Task <ActionResult> Login(LoginModel model)
{
var currentLanguage = WorkContext.CurrentLanguage;
model.CurrentLanguage = currentLanguage;
model.ExternalLoginProviders = _externalLoginProviderManager.GetAvailableLoginProvidersInfo();
if (CurrentSettings.UseGoogleRecaptchaForLogin && CurrentSettings.ShowRecaptchaAfterNFailedAttempt - 1 <= FailedAttempts)
{
ViewBag.publicKey = CurrentSettings.GoogleRecaptchaSiteKey;
if (CurrentSettings.ShowRecaptchaAfterNFailedAttempt <= FailedAttempts)
{
if (!ReCaptcha.Validate(CurrentSettings.GoogleRecaptchaSecretKey))
{
IncreaseFailedAttempts();
ViewBag.RecaptchaLastErrors = ReCaptcha.GetLastErrors(HttpContext);
return(View(model));
}
}
}
if (!ModelState.IsValid)
{
IncreaseFailedAttempts();
return(View(model));
}
var user = UserManager.FindByEmail(model.Email);
if (CurrentSettings.ConfirmUserEmailAddress)
{
if (user != null && !UserManager.IsEmailConfirmed(user.Id))
{
var code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = Url.Action("ConfirmEmail", "User", new { userId = user.Id, code = code },
Request.Url.Scheme);
await _emailService.SendEmailFromTemplateAsync("ConfirmEmail", _localizationService.GetResource("ConfirmAccount"),
model.Email, new
{
Url = callbackUrl,
UserFullName = user.FirstName + " " + user.LastName
});
return(View("DisplayEmailConfirm"));
}
}
var signIn = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe,
CurrentSettings.UserLockoutEnabled);
switch (signIn)
{
case SignInStatus.Success:
EventPublisher.Publish(new UserLoggedinEvent(user));
return(RedirectToLocal(model.ReturnUrl));
case SignInStatus.LockedOut:
IncreaseFailedAttempts();
return(View("Lockout"));
default:
IncreaseFailedAttempts();
ModelState.AddModelError("", _localizationService.GetResource("InvalidLogin"));
return(View(model));
}
}
public async Task <HttpResponseMessage> PostSetPassword(SetPasswordModel model)
{
var result = await UserManager.ResetPasswordAsync(model.UserId, model.ResetCode, model.Password);
if (result.Succeeded)
{
var lockedOut = await UserManager.IsLockedOutAsync(model.UserId);
if (lockedOut)
{
Logger.Info <AuthenticationController>(
"User {0} is currently locked out, unlocking and resetting AccessFailedCount",
() => model.UserId);
//var user = await UserManager.FindByIdAsync(model.UserId);
var unlockResult = await UserManager.SetLockoutEndDateAsync(model.UserId, DateTimeOffset.Now);
if (unlockResult.Succeeded == false)
{
Logger.Warn <AuthenticationController>("Could not unlock for user {0} - error {1}",
() => model.UserId, () => unlockResult.Errors.First());
}
var resetAccessFailedCountResult = await UserManager.ResetAccessFailedCountAsync(model.UserId);
if (resetAccessFailedCountResult.Succeeded == false)
{
Logger.Warn <AuthenticationController>("Could not reset access failed count {0} - error {1}",
() => model.UserId, () => unlockResult.Errors.First());
}
}
//They've successfully set their password, we can now update their user account to be confirmed
//if user was only invited, then they have not been approved
//but a successful forgot password flow (e.g. if their token had expired and they did a forgot password instead of request new invite)
//means we have verified their email
if (!UserManager.IsEmailConfirmed(model.UserId))
{
await UserManager.ConfirmEmailAsync(model.UserId, model.ResetCode);
}
//if the user is invited, enable their account on forgot password
var identityUser = await UserManager.FindByIdAsync(model.UserId);
//invited is not approved, never logged in, invited date present
/*
* if (LastLoginDate == default && IsApproved == false && InvitedDate != null)
* return UserState.Invited;
*/
if (identityUser != null && !identityUser.IsApproved)
{
var user = Services.UserService.GetByUsername(identityUser.UserName);
//also check InvitedDate and never logged in, otherwise this would allow a disabled user to reactivate their account with a forgot password
if (user.LastLoginDate == default && user.InvitedDate != null)
{
user.IsApproved = true;
user.InvitedDate = null;
Services.UserService.Save(user);
}
}
UserManager.RaiseForgotPasswordChangedSuccessEvent(model.UserId);
return(Request.CreateResponse(HttpStatusCode.OK));
}
return(Request.CreateValidationErrorResponse(
result.Errors.Any() ? result.Errors.First() : "Set password failed"));
}
public bool IsEmailConfirmed(string userId)
{
return(_userManager.IsEmailConfirmed(userId));
}
public async Task <IHttpActionResult> LoginUser(string UserName, string Email, string PasswordHash, bool Empresa, bool Freelance)
{
//string UserName = "******";
//string Email = "*****@*****.**";
//string PasswordHash = "j7948810";
//bool Empresa = true;
//bool Freelance = false;
var user = new ApplicationUser()
{
UserName = UserName, Email = Email, Empresa = Empresa, Freelance = Freelance
};
AspNetUsers aspuser = new AspNetUsers();
try
{
ZonaFl.Business.SubSystems.SUser usern = new Business.SubSystems.SUser();
ApplicationUser useru = null;
if (user.UserName.Contains("@"))
{
useru = UserManager.FindByEmail(user.UserName);
}
else
{
useru = UserManager.FindByName(user.UserName);
}
if (useru != null)
{
if (UserManager.IsEmailConfirmed(useru.Id))
{
bool validuser = false;
if (useru != null)
{
validuser = UserManager.CheckPassword(useru, PasswordHash);
if (validuser)
{
var identity = new System.Security.Principal.GenericIdentity(useru.UserName);
SetPrincipal(new System.Security.Principal.GenericPrincipal(identity, null));
}
else
{
return(Json(new { success = false, issue = user, errors = "Contraseña o usuario incorrecto, favor volver a ingresar los datos", tipo = user, UserEmail = aspuser.Email }));
}
var useri = HttpContext.Current.User;
HttpContext.Current.User = useri;
//RegisterBindingModel regbm = new RegisterBindingModel();
//regbm.InjectFrom(useru);
//HttpSessionStateBase session = new HttpSessionStateWrapper(HttpContext.Current.Session);
//SessionBag.Current.User = regbm;
}
if (useru.Freelance)
{
return(Json(new { success = validuser, issue = useru, errors = "", tipo = useru, UserEmail = useru.Email, Url = Url.Content("/Offer/Index/" + useru.Id).ToString() }));
}
else if (useru.Empresa)
{
return(Json(new { success = validuser, issue = useru, errors = "", tipo = useru, UserEmail = useru.Email, Url = Url.Content("/Projects/Index/" + useru.Id).ToString() }));
}
else
{
return(Json(new { success = validuser, issue = useru, errors = "", tipo = useru, UserEmail = useru.Email, Url = Url.Content("/Administration/Users/Index?email=" + useru.Email).ToString() }));
}
}
else
{
return(Json(new { success = false, issue = user, errors = "Usuario con correo electrónico no confirmado, favor revisar su correo electronico para confirmar la creación de la cuenta", tipo = user, UserEmail = aspuser.Email }));
}
}
else
{
return(Json(new { success = false, issue = user, errors = "Usuario o password incorecto, favor digitar correctamente sus credenciales", tipo = user, UserEmail = aspuser.Email }));
}
}
catch (Exception ex)
{
return(Json(new { success = false, issue = user, errors = ex.Message, tipo = user, UserEmail = aspuser.Email, Trace = ex.StackTrace }));
}
return(Json(new { success = true, issue = "Registro de usuario", errors = "", tipo = "Registro de usuario", UserEmail = user.Email, Url = Url.Content("/Freelance/Logout").ToString() }));
}
