public IAsyncResult BeginLogin(string format, LoginContract user, AsyncCallback callback, object asyncState)
{
return(APIHelper.WrapperService(format, callback, asyncState, true, delegate()
{
return ServiceManager.Instance.UserManager.AccountService.LoginAsync(user);
}));
}
public GenericResponse <LoginContract> UserLogin(LoginRequest request)
{
DbOperation dbOperation = new DbOperation();
LoginContract loginContract = new LoginContract();
SqlParameter[] parameters = new SqlParameter[] {
new SqlParameter("@UserName", request.DataContract.LoginName),
new SqlParameter("@Password", request.DataContract.Password)
};
SqlDataReader reader = dbOperation.GetData("COR.sel_UserLogin", parameters);
while (reader.Read())
{
loginContract.Id = Convert.ToInt32(reader["Id"]);
loginContract.LoginName = Convert.ToString(reader["UserName"]);
}
try
{
return(new GenericResponse <LoginContract>()
{
Value = loginContract, IsSuccess = true
});
}
catch
{
return(new GenericResponse <LoginContract>()
{
ErrorMessage = "Başarısız login denemesi", IsSuccess = false
});
}
}
public async Task Login_Fail(string phone, string password)
{
Setup();
var listClients = new List <Dal.Models.Client>()
{
new()
{
Id = 0,
Login = "******",
Password = "******"
}
};
_applicationContextMock.Setup(x => x.Clients).ReturnsDbSet(listClients);
_testedService = new ClientsService(Logger, _applicationContextMock.Object);
var model = new LoginContract()
{
Login = phone,
Password = password
};
var result = await _testedService.Login(model, CancellationToken.None);
Assert.Empty(result);
}
}
public async Task <CommandResult> LoginAsync(LoginContract model)
{
try
{
var adminEntity = await query.SingleOrDefaultAsync <AdminEntity>(x => x.Login == model.Login);
if (adminEntity != null)
{
if (PasswordHash.ValidatePassword(model.Password, adminEntity.Password))
{
var claims = new List <Claim>
{
new Claim(ClaimTypes.Name, adminEntity.Login),
new Claim(ClaimTypes.NameIdentifier, adminEntity.Id.ToString()),
new Claim(ClaimTypes.Role, IdentityConsts.RoleAdmin),
new Claim("http://schemas.microsoft.com/accesscontrolservice/2010/07/claims/identityprovider", IdentityConsts.IdentityInstanceClientCookieName),
};
var claimsIdentity = new ClaimsIdentity(claims, "ApplicationCookie", ClaimTypes.Name, ClaimTypes.Role);
await _httpContextAccessor.HttpContext.SignInAsync(IdentityConsts.IdentityInstanceClientCookieName, new ClaimsPrincipal(claimsIdentity));
return(CommandResult.Ok);
}
}
return(new CommandResult(Localization.Resource.Validation_BadLoginOrPassword));
}
catch (Exception e)
{
log.Error(nameof(LoginAsync), e);
return(new CommandResult(e));
}
}
public async Task <IActionResult> Login(LoginContract contract)
{
var user = await _userService.Login(contract.Email, contract.Password);
var token = CreateToken(user);
return(Ok(token));
}
public async Task <IActionResult> Login([FromBody] LoginContract model)
{
var result = await _userService.Authenticate(new UserDto { Email = model.Email, Password = model.Password }, model.RememberMe);
if (string.IsNullOrEmpty(result))
{
return(BadRequest());
}
return(Ok(new { token = result }));
}
public UserProfile GetUser(LoginContract contract)
{
var user = loginRepository.GetUser(contract);
if (user.IsActive)
{
user.Permissions = authorizationService.GetUserPermissions(user);
}
return(user);
}
private void requestLogin(object sender, JavascriptMethodEventArgs e)
{
JSObject callbackarg = e.Arguments[0];
JSObject cb = callbackarg.Clone();
if (File.Exists("loginDetails.xml"))
{
LoginContract details = Storage.DeSerializeObject <LoginContract>("loginDetails.xml");
cb?.Invoke("call", callbackarg, details.username, details.password);
}
}
public async Task <IActionResult> PostAsync([FromBody] LoginContract loginContract)
{
var uri = _appSettings.Value.ApiUrls.CalculateMD5;
var response = await _httpClient.PostAsync(uri, new StringContent(JsonConvert.SerializeObject(loginContract), Encoding.UTF8, "application/json"));
var responseData = await response.Content.ReadAsStringAsync();
var result = JsonConvert.DeserializeObject <LoginHashContract>(responseData);
return(Ok(result));
}
public async void PostTest()
{
var loginContract = new LoginContract {
Login = "******", Password = "******"
};
var loginHashContract = new LoginHashContract {
HashValue = "hashhashhashhash"
};
var mockFactory = new Mock <IHttpClientFactory>();
var handlerMock = new Mock <HttpMessageHandler>();
var response = new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(JsonConvert.SerializeObject(loginHashContract), Encoding.UTF8, "application/json"),
};
handlerMock
.Protected()
.Setup <Task <HttpResponseMessage> >(
"SendAsync",
ItExpr.IsAny <HttpRequestMessage>(),
ItExpr.IsAny <CancellationToken>())
.ReturnsAsync(response);
var httpClient = new HttpClient(handlerMock.Object);
mockFactory.Setup(_ => _.CreateClient(It.IsAny <string>())).Returns(httpClient);
Settings app = new Settings()
{
ApiUrls = new ApiUrls()
{
CalculateMD5 = "http://test"
}
};
var mockOptions = new Mock <IOptions <Settings> >();
// We need to set the Value of IOptions to be the SampleOptions Class
mockOptions.Setup(ap => ap.Value).Returns(app);
var hashController = new HashController(mockFactory.Object, mockOptions.Object);
var result = await hashController.PostAsync(loginContract);
var actual = JsonConvert.SerializeObject(((OkObjectResult)result).Value);
var expected = JsonConvert.SerializeObject(loginHashContract);
Assert.Equal(expected, actual);
}
public LoginReturn ValidateLogin(int id, LoginContract loginContract)
{
var emp = context.Employee.Include(e => e.Designation).FirstOrDefault(e => e.Username == loginContract.Username && e.Password == loginContract.Password && e.MerchantId == id);
LoginReturn loginReturn = new LoginReturn();
if (emp != null)
{
loginReturn.designation = emp.Designation.Name;
}
return(loginReturn);
}
public bool GetLogin(LoginContract loginContract)
{
int dr = dbOperation.SpLogin("cus.sel_login", new SqlParameter[] {
new SqlParameter("@UserName", loginContract.UserName),
new SqlParameter("@Password", ComputeSha256Hash(loginContract.Password))
});
if (dr == 1)
{
return(true);
}
return(false);
}
public async Task <IActionResult> Login(LoginContract model)
{
var result = await _identityService.LoginAsync(model);
if (result.Succeeded)
{
// redirect
string redirect = Path.Combine(Request.PathBase + "/#/admin");
return(Redirect(redirect));
}
ViewBag.ErrorMessage = result.ErrorMessage;
return(View(model));
}
public async Task <ObjectResult <LoginResult> > LoginAsync(LoginContract user)
{
ObjectResult <LoginResult> result = new ObjectResult <LoginResult>();
try
{
string _password = HelperMethod.encrypt(user.Password);
var query = userRepository.GetTable.Where(d => d.Username.Equals(user.Username) && d.Password.Equals(_password)).AsQueryable();
var data = await userRepository.GetDataAsync(query);
if (data != null)
{
ServiceResult loginResult = new ServiceResult();
loginResult.OK();
var loginQuery = userLoginRepository.GetTable.Where(d => d.UserName.Equals(user.Username) && d.DeviceID.Equals(user.DeviceID)).AsQueryable();
if (await userLoginRepository.GetCountAsync(loginQuery) == 0)
{
tUserLogin _loginData = new tUserLogin
{
UserLoginID = HelperMethod.GenerateID(),
UserName = user.Username,
DeviceID = user.DeviceID,
Token = HelperMethod.GenerateID().ToString()
};
var saveLogin = await userLoginRepository.AddAsync(_loginData);
loginResult = saveLogin.status;
}
if (loginResult.succeeded)
{
var loginData = await userLoginRepository.GetDataAsync(loginQuery);
result.obj = GetLoginResult(loginData);
result.status.OK();
}
else
{
result.status = loginResult;
}
}
else
{
result.status.NotFound("Data Not Found");
}
}
catch (Exception ex)
{
result.status.Error("Error", ex.Message);
}
return(result);
}
public async Task <IActionResult> Login(LoginContract contract)
{
using var store = Service.DataStore.OpenSession();
var account = await store
.Query <Account>()
.FirstOrDefaultAsync(a => a.Username == contract.Username);
if (account == null || !BCrypt.Net.BCrypt.Verify(contract.Password, account.Password))
{
return(Unauthorized("Failed to authenticate"));
}
return(Ok(GetToken(account)));
}
public UserProfile GetUser(LoginContract contract)
{
DynamicParameters parameters = new DynamicParameters();
parameters.Add("@username", contract.UserName);
parameters.Add("@password", contract.Password);
var user = _repository.ExecuteStoredProcedureQuery <UserProfile>(DomainStoredProcedures.GetUserByLoginContract, parameters)
.FirstOrDefault() ?? new UserProfile()
{
LoginName = InvalidUser
};
return(user);
}
private void btnLogin_Click(object sender, RoutedEventArgs e)
{
Connect();
if (txtId.Text == "" || txtPwd.Password == "")
{
ShowMsg(null, "请输入用户ID和密码");
}
else
{
string ID = txtId.Text.Trim();
string Pwd = txtPwd.Password.Trim();
LoginContract login = new LoginContract(ID, Pwd);
helper.SendMessage(string.Format("LOGIN@{0}", DataHelpers.XMLSer <LoginContract>(login)));
this.btnLogin.IsEnabled = false;
}
}
public async Task <LoginResult> Login([FromBody] LoginContract contract)
{
var refreshToken = Guid.NewGuid();
var loginServiceContract = _mapper.Map <LoginServiceContract>(contract);
loginServiceContract.RefreshToken = refreshToken;
var loginServiceResult = await _authenticationService.Login(loginServiceContract);
string encodedJwt = null;
var now = DateTime.UtcNow;
if (loginServiceResult.Success)
{
// authentication successful so generate jwt token
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(contract.Login, loginServiceResult.UserId.ToString())
}),
Expires = DateTime.UtcNow.AddDays(7),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
encodedJwt = tokenHandler.WriteToken(token);
}
return(await Task.FromResult(new LoginResult
{
Login = contract.Login,
UserId = loginServiceResult.UserId,
UserName = loginServiceResult.UserName,
GiveinPlaceId = contract.GiveinPlaceId,
AccessToken = encodedJwt,
RefreshToken = refreshToken,
ExpirationTime = now
.AddMinutes(30)
.AddSeconds(-10), //чтобы из-за задержек не получалось так, что токен уже просрочился, но ещё не обновился.
IdleTimeout = 30,
Error = loginServiceResult.Error,
}));
}
public LoginResultContract Login(string uid, string pwd, string verCode)
{
LoginContract loginContract = new LoginContract
{
Uid = uid,
Pwd = pwd,
VerCode = verCode
};
MessagePacket message = new MessagePacket(uid, GloblParams.CurrentClientID, GloblParams.CurrentClientType, MessageType.Login, 0, loginContract.ToByteArray());
byte[] array = null;
try
{
array = this.BasicOutter.Query(message);
}
catch (TimeoutException e)
{
LoginResultContract loginResultContract = new LoginResultContract();
loginResultContract.Result = 1;
loginResultContract.Failure = "登录请求超时，检查网络或是服务器";
}
catch
{
LoginResultContract loginResultContract = new LoginResultContract();
loginResultContract.Result = 2;
loginResultContract.Failure = "unkonw cause";
}
LoginResultContract result;
if (array == null)
{
result = null;
}
else
{
LoginResultContract loginResultContract = LoginResultContract.Parser.ParseFrom(array);
if (loginResultContract.Result == 0)
{
GloblParams.CurrentClientID = uid;
this.channelClientHandler.CanSendHeartMessage = true;
}
result = loginResultContract;
}
return(result);
}
public UserContract Login(LoginContract loginContract)
{
var userToCheck = _uow.UserRepository.Get(filter: x => x.Username == loginContract.Username).FirstOrDefault();
if (userToCheck == null)
{
return(null);
}
var inputFromUserHashPassword = loginContract.Password.GenerateHash(userToCheck.Salt);
if (inputFromUserHashPassword != userToCheck.Password)
{
return(null);
}
return(userToCheck.ToContract());
}
/// <summary>
/// Log in in a registered client.
/// </summary>
/// <param name="model"></param>
/// <param name="token"></param>
/// <returns></returns>
public async Task <string> Login(LoginContract model, CancellationToken token)
{
var user = await _context.Clients.FirstOrDefaultAsync(m => m.Login == model.Login, token);
if (user == null)
{
_logger.LogInformation($"Client {model.Login} not found");
return(string.Empty);
}
if (model.Password.GenerateHash().Equals(user.Password))
{
return(Authenticate(user.Login, user.Id));
}
_logger.LogInformation($"{model.Login}:\tIncorrect login or password");
return(string.Empty);
}
public string TestLogin(LoginContract contract)
{
var user = loginService.GetUser(contract);
switch (user.LoginStatus)
{
case LoginStatus.InvalidPassword:
return("Invalid password");
case LoginStatus.UserNotFound:
return("No user found with that name");
case LoginStatus.Success:
return(user.IsActive ? "Logged In" : "Your account has been deactivated");
default:
return("Something went wrong");
}
}
public UserProfile GetUser(LoginContract contract)
{
DynamicParameters parameters = new DynamicParameters();
parameters.Add("@username", contract.UserName);
parameters.Add("@password", contract.Password);
var user = _repository.ExecuteStoredProcedureQuery <UserProfile>(DomainStoredProcedures.GetUserByLoginContract, parameters)
.FirstOrDefault() ?? new UserProfile()
{
LoginStatus = LoginStatus.UserNotFound
};
if (!string.IsNullOrEmpty(user.LoginName))
{
user.LoginStatus = LoginStatus.Success;
}
return(user);
}
public async Task <IActionResult> Login([FromBody] LoginContract model, CancellationToken cancellationToken)
{
if (model == null)
{
return(BadRequest());
}
if (ModelState.IsValid)
{
var result = await _clientsService.Login(model, cancellationToken);
if (!string.IsNullOrEmpty(result))
{
return(Ok(result));
}
return(BadRequest());
}
return(BadRequest());
}
public UserProfile GetUser(LoginContract contract)
{
var user = loginRepository.GetUser(contract);
if (!LoginStatus.UserNotFound.Equals(user.LoginStatus))
{
if (!string.IsNullOrEmpty(user.Password) && passwordEncryption.CheckPassword(contract.Password, user.Password))
{
if (user.IsActive)
{
user.Permissions = authorizationService.GetUserPermissions(user);
}
}
else
{
user.LoginStatus = LoginStatus.InvalidPassword;
}
}
return(user);
}
public GolferContract GetGolfer(LoginContract loginContract)
{
using (NeedAGolferDataContext dataContext = new NeedAGolferDataContext())
{
Logging loggingInfo = new Logging();
loggingInfo.CreatedDate = DateTime.Now;
loggingInfo.DeviceId = loginContract.DeviceId;
loggingInfo.OSVersion = loginContract.OSVersion;
loggingInfo.UserAccount = loginContract.UserAccount;
loggingInfo.DeviceType = loginContract.DeviceType;
dataContext.Loggings.InsertOnSubmit(loggingInfo);
dataContext.SubmitChanges();
dataContext.Connection.Close();
}
var golferRetriever = RetrieverFactory.CreateInterface <IGolferRetriever>();
var golfer = golferRetriever.LoadByGolferId(CurrentSession.GolferId);
GolferContract contract = new GolferContract(golfer);
return(contract);
}
public void Process(RequestInfo request)
{
var message = request.MessagePacket;
try
{
#region Noraml
if (message.MessageHeader.MessageType == MessageType.Noraml)
{
if (message.MessageHeader.DestUserID == GloblParams.DefaultServerID)
{
customizeHandler.Handle(message.MessageHeader.SourceUserID, message.ContractID, message.BodyContent);
}
else
{
basicController.Send(message.MessageHeader.DestUserID, message);
}
}
#endregion
#region Ack_Req
else if (message.MessageHeader.MessageType == MessageType.Ack_Req)
{
if (message.MessageHeader.DestUserID == GloblParams.DefaultServerID)
{
ResponseAck(request.Channel, message);
customizeHandler.Handle(message.MessageHeader.SourceUserID, message.ContractID, message.BodyContent);
}
else
{
basicController.Send(message.MessageHeader.DestUserID, message);
}
}
#endregion
#region Blob
else if (message.MessageHeader.MessageType == MessageType.Blob)
{
if (message.MessageHeader.DestUserID == GloblParams.DefaultServerID)
{
BlobContract contract = BlobContract.Parser.ParseFrom(message.BodyContent);
string keyStr = message.MessageHeader.SourceUserID + contract.BlobID.ToString();
BlobItem item = hotDic.Get(keyStr);
if (item == null)
{
item = new BlobItem();
hotDic.Add(keyStr, item);
}
item.Add(contract.FragmentIndex, contract.Fragment);
if (contract.IsLast)
{
BlobItem blob = this.hotDic.GetAndRemove(keyStr);
MemoryStream stream = new MemoryStream();
foreach (var blobItem in blob)
{
blobItem.Value.WriteTo(stream);
}
byte[] bytes = stream.ToArray();
stream.Dispose();
customizeHandler.Handle(message.MessageHeader.SourceUserID, message.ContractID, bytes);
}
}
else
{
basicController.Send(message.MessageHeader.DestUserID, message);
}
}
#endregion
#region Ack_Resp
else if (message.MessageHeader.MessageType == MessageType.Ack_Resp)
{
basicController.Send(message.MessageHeader.DestUserID, message);
}
#endregion
#region Query_Req
else if (message.MessageHeader.MessageType == MessageType.Query_Req)
{
if (message.MessageHeader.DestUserID == GloblParams.DefaultServerID)
{
byte[] result = customizeHandler.HandleQuery(message.MessageHeader.SourceUserID, message.ContractID, message.BodyContent);
ResponseQuery(request.Channel, MessageType.Query_Resp, message, result);
}
else
{
basicController.Send(message.MessageHeader.DestUserID, message);
}
}
#endregion
#region Query_Resp
else if (message.MessageHeader.MessageType == MessageType.Query_Resp)
{
basicController.Send(message.MessageHeader.DestUserID, message);
}
#endregion
#region Login
else if (message.MessageHeader.MessageType == MessageType.Login)
{
LoginContract loginContract = LoginContract.Parser.ParseFrom(message.BodyContent);
string cause;
LoginResultContract result = null;
bool verResult = basicHandler.VerifyUser(loginContract, request.Channel, out cause);
this.basicController.userManager.Add(loginContract.Uid, request.Channel);
result = new LoginResultContract()
{
Result = verResult ? 0 : 1,
Failure = cause
};
ResponseQuery(request.Channel, MessageType.LoginResp, message, result.ToByteArray());
}
#endregion
else
{
//handler.HandleQuery(request);
}
}
catch
{
}
}
public IHttpActionResult Login(LoginContract loginContract)
{
return(Ok(_loginHandler.Login(loginContract)));
}
public bool VerifyUser(LoginContract loginContract, IChannel channel, out string failureCause)
{
throw new NotImplementedException();
}
public async Task <IActionResult> Login([FromBody] LoginContract loginContract)
{
return(Ok(await _userService.Login(loginContract.Email, loginContract.Password)));
}
