public async Task <IActionResult> Login(LoginDataModel loginDataModel)
{
var result = await signInManager.PasswordSignInAsync(loginDataModel.UserName, loginDataModel.Password, loginDataModel.RememberMe, false);
if (result.Succeeded)
{
var user = await userManager.FindByNameAsync(loginDataModel.UserName);
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Sub, user.UserName),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
};
var signinkey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("MySuperSecurityKey"));
var tocken = new JwtSecurityToken(
issuer: "http://saveafrica.com",
audience: "http://saveafrica.com",
expires: DateTime.Now.AddHours(1),
claims: claims,
signingCredentials: new Microsoft.IdentityModel.Tokens.SigningCredentials(signinkey, SecurityAlgorithms.HmacSha256)
);
// return Ok(user);
return(Ok(new
{
authonticationTocken = new JwtSecurityTokenHandler().WriteToken(tocken),
expiration = tocken.ValidTo,
userId = user.Id
}));
}
else
{
return(BadRequest("Invalid Username Or Passwrord!"));
}
}
//[ValidateAntiForgeryToken]
public ActionResult Login(LoginDataModel model, string ReturnUrl)
{
if (_config.Credentials.User.Equals(model.Login, StringComparison.InvariantCultureIgnoreCase) &&
_config.Credentials.Password.Equals(GetEncryptedString(model.Password), StringComparison.InvariantCulture))
{
ClaimsIdentity claim = new ClaimsIdentity("ApplicationCookie", ClaimsIdentity.DefaultNameClaimType, ClaimsIdentity.DefaultRoleClaimType);
claim.AddClaim(new Claim(ClaimTypes.NameIdentifier, _config.Credentials.User, ClaimValueTypes.String));
claim.AddClaim(new Claim(ClaimsIdentity.DefaultNameClaimType, _config.Credentials.User, ClaimValueTypes.String));
claim.AddClaim(new Claim("http://schemas.microsoft.com/accesscontrolservice/2010/07/claims/identityprovider",
"OWIN Provider", ClaimValueTypes.String));
AuthenticationManager.SignOut();
AuthenticationManager.SignIn(new AuthenticationProperties
{
IsPersistent = model.IsPersistent
}, claim);
//Get prev. path from Referrer
if (!string.IsNullOrEmpty(Request.UrlReferrer.Query))
{
var queryParams = HttpUtility.ParseQueryString(Request.UrlReferrer.Query);
string redirectPath = queryParams["ReturnUrl"];
return(Json(new { redirectTo = redirectPath }));
}
return(Json(new { redirectTo = DEFAULT_REDIRECT_PUTH }));
}
else
{
return(Json(new ErrorInfoDTO {
ErrorCode = ErrorCodesConst.WRONG_USER_CREDENTIALS, ErrorMessage = "Login/Password didn't match"
}));
}
}
private void PopulateLoginDetailsAndSubmit(LoginDataModel loginDataModel)
{
WaitForElementDisplayed(_driver, _username);
TypeInto(_username, loginDataModel.Username);
TypeInto(_password, loginDataModel.Password);
_loginButton.Click();
}
public async Task <IActionResult> Login([FromBody] LoginDataModel model)
{
if (!ModelState.IsValid)
{
return(Ok(new
{
ErrorMessage = string.Join(',', ModelState.Values.SelectMany(m => m.Errors)
.Select(e => e.ErrorMessage)
.ToList())
}));
}
var result = await _mediatr.Send(new AuthenticateUser.Query(model.Email, model.Password));
if (!result)
{
return(Unauthorized());
}
var user = await _mediatr.Send(new GetUserByEmail.Query(model.Email));
string tokenString = CreateToken(user.Email, user.UserName, model.RememberMe);
return(Ok(new
{
UserId = user.Id,
Username = user.UserName,
Email = user.Email,
Token = tokenString
}));
}
public HttpResponseMessage AuthenticateUser(LoginDataModel loginDetail)
{
try
{
DataTransferService service = new DataTransferService(ConfigurationManager.ConnectionStrings["AutoSaloonDbConnection"].ConnectionString);
LoginDetail detail = service.GetLoginDetail(loginDetail.UserName, loginDetail.Password);
if (detail != null)
{
HttpResponseMessage returnMessage = new HttpResponseMessage(HttpStatusCode.OK);
var jObject = JObject.Parse(JsonConvert.SerializeObject(detail));
returnMessage.Content = new StringContent(jObject.ToString(), Encoding.UTF8, "application/json");
return(returnMessage);
}
else
{
HttpResponseMessage returnMessage = new HttpResponseMessage(HttpStatusCode.Unauthorized);
var jObject = JObject.Parse(JsonConvert.SerializeObject("Invalid user!"));
returnMessage.Content = new StringContent(jObject.ToString(), Encoding.UTF8, "application/json");
return(returnMessage);
}
}
catch (Exception ex)
{
HttpResponseMessage returnMessage = new HttpResponseMessage(HttpStatusCode.ExpectationFailed);
var jObject = JObject.Parse(JsonConvert.SerializeObject(ex.Message));
returnMessage.Content = new StringContent(jObject.ToString(), Encoding.UTF8, "application/json");
return(returnMessage);
}
}
public IHttpActionResult TrySignUp(LoginDataModel dataModel)
{
try
{
AuthModel model = new AuthModel();
if (DataContext.Accounts.Any(ac => ac.Login == dataModel.Login))
{
model.Message = "Login already exist";
return(Ok(model));
}
Account newAccount = new Account()
{
Login = dataModel.Login,
Hash = dataModel.Password.MD5()
};
DataContext.Accounts.InsertOnSubmit(newAccount);
DataContext.SubmitChanges();
return(TrySignIn(dataModel));
}
catch (Exception e)
{
return(InternalServerError(e));
}
}
public async Task <IHttpActionResult> InitiateLogin([System.Web.Mvc.Bind(Exclude = "Token")] LoginDataModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
string token;
using (ModelNFCZavrsniService db = new ModelNFCZavrsniService())
{
IdentityUser user = UserManager.Users.Where(x => x.PhoneNumber == model.PhoneNumber).First();
Employee employee = db.Employee.Where(x => x.PhoneID == model.PhoneID && x.PhoneNumber == model.PhoneNumber).First();
if (user != null && employee != null && employee.Working == true)
{
token = UserManager.GenerateTwoFactorToken(user.Id, "Phone Code");
//BITNO---------------------------------------------
//await UserManager.SmsService.SendAsync(new IdentityMessage { Body = $"Your security code is {token}", Destination = user.PhoneNumber });
}
else
{
return(BadRequest("Credentials do not match."));
}
}
//return token;
return(Ok(token));
}
public ActionResult Login()
{
var loginDataModel = new LoginDataModel();
//Trying to add more security
//var encryptedLoginId = Encrypt.GetSHA256(loginDataModel.ticketIdLocal.ToString());
//ViewBag.LoginIdEncrypted = encryptedLoginId;
return(View(loginDataModel));
}
public LoginDataModel CreateModel()
{
var ldm = new LoginDataModel();
ldm.AppConfiguration = this.appConfiguration;
ldm.IrcClient = this.freenodeClient;
ldm.Version = FileVersionInfo.GetVersionInfo(Assembly.GetExecutingAssembly().Location).FileVersion;
return(ldm);
}
public LoginResultDataModel Login(LoginDataModel obj)
{
using (var chatDb = new ChatDbEntities())
{
return(new LoginResultDataModel
{
Result = (LoginResaltData)chatDb.Login(obj.Hash).FirstOrDefault()
});
}
}
public MainViewModel()
{
_isFocused = true;
_loginModel = new LoginDataModel();
currentWindow = System.Windows.Application.Current.Windows.OfType <MetroWindow>().LastOrDefault();
backupDialog = new BackupDialog();
restoreBackupDialog = new RestoreBackupDialog();
loginDialog = new Views.MainViews.LoginDialog();
startShiftDialog = new StartShiftDialog();
}
public IHttpActionResult TrySignIn(LoginDataModel dataModel)
{
try
{
Account account = DataContext.Accounts.FirstOrDefault(
ac => ac.Login == dataModel.Login && ac.Hash == dataModel.Password.MD5());
if (account == null)
{
return(Ok(new AuthModel()
{
Message = "Login or password incorrect"
}));
}
Guid token = Guid.NewGuid();
string adr = "";
if (Request.Properties.ContainsKey("MS_HttpContext"))
{
adr = ((HttpContextWrapper)Request.Properties["MS_HttpContext"]).Request.UserHostAddress;
}
AccountAccessRecord previousRecord = account.AccountAccessRecords.FirstOrDefault(r => r.Source == adr);
if (previousRecord != null)
{
DataContext.AccountAccessRecords.DeleteOnSubmit(previousRecord);
DataContext.SubmitChanges();
}
AccountAccessRecord record = new AccountAccessRecord()
{
ActiveDate = DateTime.Now,
Account = account,
Source = adr,
Token = token
};
DataContext.AccountAccessRecords.InsertOnSubmit(record);
DataContext.SubmitChanges();
return(Ok(new AuthModel()
{
IsAdmin = account.IsAdmin,
Name = account.Login,
Token = token.ToString(),
IsVisitor = false
}));
}
catch (Exception e)
{
return(InternalServerError(e));
}
}
public object LogIn(LoginDataModel model)
{
object token = _accountService.LogIn(model.UserName, model.Password);
if (token == null)
{
return(BadRequest(new { errorText = "Invalid username or password." }));
}
return(token);
}
public async Task <LoginResponse> LoginEmployee(LoginDataModel loginDataModel)
{
var response = _loginRepository.LoginEmployee(loginDataModel);
if (response == null)
{
return(null);
}
var responseData = _jwtSecurityService.GetTokenEmployee(response);
return(await Task.FromResult(responseData));
}
public void CleanUp()
{
if (DataModel == null)
{
DataModel = new LoginDataModel();
var _DataModelCharactersCount0 = DataModel.Characters.Count;
for (var i = 0; i < _DataModelCharactersCount0; i++)
{
DataModel.Characters[i] = new CharacterLoginDataModel();
}
NowSelectRole = new CharacterLoginDataModel();
}
}
public ActionResult Login(LoginDataModel loginDataModel)
{
if (ModelState.IsValid)
{
if (_authentication.Login(loginDataModel.UserName, loginDataModel.Password, loginDataModel.RememberMe))
{
return(RedirectToAction("Index", "NewsFeed"));
}
ModelState.AddModelError("", "Данные не верны");
}
ViewData["ProviderNames"] = _authentication.OAuthProviderNames;
return(View("LoginForm", loginDataModel));
}
public UserModel Login([FromBody] LoginDataModel post)
{
try
{
DataTable dt = new DataTable();
if (post.guid != null)
{
dt = DAOCRM.LoginedUser(post.guid);
}
else
{
post.guid = Guid.NewGuid().ToString();
dt = DAOCRM.LoginUser(post.login, post.password, post.guid);
}
if (dt == null)
{
return new UserModel {
error = "Incorrect login or password"
}
}
;
if (dt.Rows.Count < 1)
{
return new UserModel {
error = "Incorrect login or password"
}
}
;
return(new UserModel
{
guid = post.guid,
id = Convert.ToInt32(dt.Rows[0]["USR_Id"].ToString()),
type = Convert.ToInt32(dt.Rows[0]["USR_Type"].ToString()),
login = dt.Rows[0]["USR_Login"].ToString(),
mail = dt.Rows[0]["USR_Mail"].ToString(),
name = dt.Rows[0]["USR_Name"].ToString()
});
}
catch (Exception ex)
{
SaveErrorDB.AddError(ex, new StackTrace().GetFrame(0).GetMethod().Name, MethodBase.GetCurrentMethod().DeclaringType?.FullName);
return(new UserModel {
error = ex.Message
});
}
}
private static void Logger_OnMessageLogged(LoginDataModel.LogMessage Msg)
{
switch (Msg.Level)
{
case LoginDataModel.LogLevel.info:
Logger.LogInfo(Msg.Message);
break;
case LoginDataModel.LogLevel.error:
Logger.LogDebug(Msg.Message);
break;
case LoginDataModel.LogLevel.warn:
Logger.LogWarning(Msg.Message);
break;
}
}
public static void LoginAsAdmin()
{
var loginDataModel = new LoginDataModel().BuildModel(LoginDataModel.DataInstance.ValidDetails);
try
{
var loginPage = new LoginPage(Driver);
loginPage.LogInWithValidDetails(loginDataModel);
}
catch (Exception)
{
Driver.Quit();
throw;
}
}
public ActionResult Index(LoginDataModel pLoginData)
{
/*security check*/
if (Session["tipoDeUsuario"] == null)
{
return(RedirectToAction("Logout", "Common"));
}
else if (Session["tipoDeUsuario"].ToString() != TiposDeUsuario.E_Nav.NoRegistrado.ToString())
{
return(RedirectToAction("Logout", "Common"));
}
RepositorioSolicitante rS = new RepositorioSolicitante();
RepositorioInversor rI = new RepositorioInversor();
Inversor i = rI.LoginAttempt(pLoginData.NombreDeUsuario, pLoginData.Pass);
Solicitante s = rS.LoginAttempt(pLoginData.NombreDeUsuario, pLoginData.Pass);
if (s != null)
{
// ingresar como solicitante
Session["tipoDeUsuario"] = TiposDeUsuario.E_Nav.Solicitante;
Session["idUsuario"] = pLoginData.NombreDeUsuario;
if (s.TienePassTemporal)
{
return(RedirectToAction("Index", "CambiarPass"));
}
else
{
return(RedirectToAction("Index", "HomeSolicitante"));
}
}
else if (i != null)
{
// ingresar como inversor
Session["tipoDeUsuario"] = TiposDeUsuario.E_Nav.Inversor;
Session["idUsuario"] = pLoginData.NombreDeUsuario;
return(RedirectToAction("Index", "HomeInversor"));
}
else
{
Session["tipoDeUsuario"] = TiposDeUsuario.E_Nav.NoRegistrado;
ViewData["Mensaje"] = "Nombre de usuario y/o contraseña incorrectos.";
}
return(View());
}
public bool CheckLogin(LoginDataModel loginData)
{
bool isMatched = false;
string passwordHash = _dataAccess.GetLoginHandler().getPasswordHash(loginData.Username);
//comparing the password to the hash Value from the DB
if (passwordHash != null)
{
isMatched = BCrypt.Net.BCrypt.Verify(SecureStringToString(loginData.Password), passwordHash);
}
//getting rid of the password
loginData.Dispose();
return(isMatched);
}
private async void ExecuteCloseDialogAsync(string parameter)
{
try
{
switch (parameter)
{
case "Backup":
await currentWindow.HideMetroDialogAsync(backupDialog);
break;
case "Restore":
await currentWindow.HideMetroDialogAsync(restoreBackupDialog);
break;
case "startShift":
await currentWindow.HideMetroDialogAsync(startShiftDialog);
currentWindow.Close();
break;
case "back":
await currentWindow.HideMetroDialogAsync(startShiftDialog);
LoginModel = new LoginDataModel();
loginDialog.DataContext = this;
await currentWindow.ShowMetroDialogAsync(loginDialog);
break;
case "Login":
await currentWindow.HideMetroDialogAsync(loginDialog);
currentWindow.Close();
break;
default:
break;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
public async Task <IActionResult> LoginEmployee([FromBody] LoginDataModel loginDataModel)
{
var response = new SingleResponseModel <LoginResponse>();
try
{
var data = await _loginService.LoginEmployee(loginDataModel);
response.Model = data;
}
catch (Exception ex)
{
response.DidError = true;
response.ErrorMessage = "There was an internal error, please contact to technical support.";
}
return(response.ToHttpResponse());
}
public async Task <ActionResult> CheckLogin(LoginDataModel model)
{
int UserId = -1;
UserDTO UserDTOobject = new UserDTO();
try
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri("http://localhost:49750/");
HttpResponseMessage response = await client.GetAsync("api/Login/CheckLoginData/?UserName="******"&Password="******"api/User/GetUserByUserId/?UserId=" + UserId);
if (response2.IsSuccessStatusCode)
{
UserDTOobject = response2.Content.ReadAsAsync <UserDTO>().Result;
}
Session["UserName"] = UserDTOobject.FirstName;
if (UserDTOobject.Role.Role1 == "ADMIN")
{
Session["AdminId"] = UserId;
Session["UserId"] = null;
}
else
{
Session["AdminId"] = null;
Session["UserId"] = UserId;
}
return(RedirectToAction("HomePage", "Home"));
}
}
}
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
}
return(RedirectToAction("Index", "Home"));
}
public ActionResult Postback(LoginDataModel loginData)
{
var security = new SecurityManager(serviceFactory);
try
{
security.VerifyUserLogin(loginData.Username, loginData.Password);
var signin = new SigninManager(HttpContext);
signin.SignIn(loginData.Username);
}
catch (AuthorizationException)
{
ViewBag.Message = "Login failed";
return(View("index"));
}
return(Redirect("/"));
}
public void Login()
{
if (_password != null)
{
var loginData = new LoginDataModel(_password, Username);
bool loginSuccessfull = _loginController.CheckLogin(loginData);
_password.Clear();
if (loginSuccessfull)
{
var lVar = _loginController.GetUser(loginData.Username);
LoginStatus = lVar.Username;
}
else
{
LoginStatus = "Login Failed";
}
}
}
public ActionResult Login(LoginDataModel loginDataModel)
{
if (!ModelState.IsValid)
{
return(View(loginDataModel));
}
_peopleQueriesService = new PeopleQueriesService();
var activeUser = _peopleQueriesService.SearchPeople(loginDataModel.email, loginDataModel.password);
if (activeUser == null)
{
var msg = "Error, usuario o password incorrecto !";
TempData["ErrorMessage"] = msg;
return(RedirectToAction("Login", "Login"));
}
Session["User"] = activeUser;
//Acceso Correcto
return(RedirectToAction("Index", "Home"));
}
private async void Login_Click(object sender, RoutedEventArgs e)
{
if (string.IsNullOrWhiteSpace(usernameTextBox.Text) || string.IsNullOrWhiteSpace(passwordTextBox.Password))
{
warningLoginMessage.Visibility = Visibility.Visible;
return;
}
LoginDataModel loginData = new LoginDataModel()
{
Username = usernameTextBox.Text,
Password = passwordTextBox.Password
};
ResponseDataModel response = await Constants.sendPostRequest <ResponseDataModel>(Constants.BASE_URL + "/user", loginData);
if (response == null || response.Response == null || !response.Response.ToLower().Equals("ok"))
{
MessageBox.Show("Check internet connection. Server problem.");
return;
}
swithcWindow();
}
private void LoginAction()
{
LoginDataModel loginData = new LoginDataModel();
loginData.UserName = LoginUserNameTextbox.Text.Trim();
loginData.Password = LoginPasswordTextBox.Text.Trim();
string apiUrl = ConfigurationManager.AppSettings.Get("API_END_POINT"); //"http://localhost:26404/api/CustomerAPI";
//string inputJson = (new JavaScriptSerializer()).Serialize(loginData);
var inputJson = JsonConvert.SerializeObject(loginData);
HttpClient client = new HttpClient();
client.BaseAddress = new Uri(apiUrl);
client.DefaultRequestHeaders.Accept.Clear();
var buffer = System.Text.Encoding.UTF8.GetBytes(inputJson);
var byteContent = new ByteArrayContent(buffer);
byteContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
HttpResponseMessage response = client.PostAsync("api/AutoSaloonAPI/Authenticate", byteContent).Result;
if (response.IsSuccessStatusCode)
{
var Json = response.Content.ReadAsStringAsync().Result;//response.Content.ReadAsStringAsync();
LoginDetail loggedInUserDetails = (new JavaScriptSerializer()).Deserialize <List <LoginDetail> >(Json).FirstOrDefault();
if (loggedInUserDetails != null)
{
}
}
else
{
MessageBox.Show("Error Code" + response.StatusCode + " : Message - " + response.ReasonPhrase);
}
}
public UserCollectionDataModel GetOnlineUsers(LoginDataModel obj)
{
Hash = obj.Hash;
return(OnlineUsers);
}
public UserPartialDataModel GetCurrentUser(LoginDataModel obj)
{
Hash = obj.Hash;
return(CurrentUser);
}
