public LoginResponseMessage AuthenticateUser(LoginRequestMessage RequestMessage)
{
LoginResponseMessage response = null;
try
{
response = ValidateAuthenticateUser(RequestMessage);
if (response != null && response.Error==null)
{
loginDataProvider = new LoginDataProvider();
response = loginDataProvider.AuthenticateUser(RequestMessage);
if (response != null && response.Error == null)
{
//Generate token
response.Success = true;
}
}
}
catch(Exception ex)
{
ErrorLogManager.WriteLog(response, "999", ex.Message);
}
return response;
}
public LoginResponseMessage AuthenticateUser(LoginRequestMessage RequestMessage)
{
LoginResponseMessage response = null;
try
{
response = ValidateAuthenticateUser(RequestMessage);
if (response != null && response.Error == null)
{
loginDataProvider = new LoginDataProvider();
response = loginDataProvider.AuthenticateUser(RequestMessage);
if (response != null && response.Error == null)
{
//Generate token
response.Success = true;
}
}
}
catch (Exception ex)
{
ErrorLogManager.WriteLog(response, "999", ex.Message, ex: ex);
}
return(response);
}
public LoginResponseMessage AuthenticateUser(LoginRequestMessage RequestMessage)
{
LoginResponseMessage response = new LoginResponseMessage();
try
{
StringBuilder sqlString = new StringBuilder();
sqlString.Append("select Loginid from LoginDtls where LoginName='");
sqlString.Append(RequestMessage.LoginName);
sqlString.Append("' and cast(Password as varbinary(20))=cast('");
sqlString.Append(RequestMessage.Password);
sqlString.Append("' as varbinary(50)) and IsActive=1");
var login = DataAccessLayer.ExecuteScalar(sqlString.ToString());
if (login != null)
{
response.SecurityToken = "G";
}
else
{
ErrorLogManager.WriteLog(response, "000", "Unable to find user.");
}
}
catch (Exception ex)
{
//ErrorLogManager.WriteLog(response, "999", ex.Message,ex:ex);
ErrorLogManager.WriteLog(response, "012", ex.Message, ex: ex);
}
return(response);
}
public async Task<IActionResult> LoginAsync([FromBody] LoginRequestMessage requestMessage)
{
var response = Response<LoginResponseMessage>.Create();
var loginResponse = await UserService.LoginAsync(requestMessage);
if (loginResponse.HasError)
return StatusCode(401, response.WithMessages(loginResponse.Messages));
return GenerateResponseAsync(response, loginResponse);
}
public override LoginResponeMessage VerifyLogin(LoginRequestMessage request, TAccount account)
{
var result = new LoginResponeMessage {
LoginResult = LoginResutlCode.UnKnown
};
if (request.Password == account.FPassword)
{
result.LoginResult = LoginResutlCode.Success;
SetRespose(result, account);
}
return(result);
}
/// <summary>
/// Uses the credentials to authenticate with the remote server.
/// Goes to states <c>Create</c>, <c>Receive</c>, and <c>Close</c>.
/// </summary>
/// <returns>Time to wait till next state is run, in milliseconds.</returns>
private int Authenticate()
{
ChangeStatus(QuoteProviderStatus.Authenticate);
try
{
SessionKeyRequestMessage sessionKeyRequest = new SessionKeyRequestMessage(m_username);
int length = sessionKeyRequest.GetBytes(m_buffer, 0);
int count = m_client.Send(m_buffer, 0, length, SocketFlags.None);
count = m_client.Receive(m_buffer);
length = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(m_buffer, 0));
SessionKeyReplyMessage sessionKeyReply = (SessionKeyReplyMessage)BidMessage.Create(FunctionCodes.SessionKeyReply, m_buffer, 0, length);
uint sessionKey = sessionKeyReply.SessionKey;
LoginRequestMessage LoginRequest = new LoginRequestMessage(m_username, m_password, sessionKey);
length = LoginRequest.GetBytes(m_buffer, 0);
count = m_client.Send(m_buffer, 0, length, SocketFlags.None);
count = ReceiveMessage();
length = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(m_buffer, 0));
LoginReplyMessage loginReply = (LoginReplyMessage)BidMessage.Create(FunctionCodes.LoginReply, m_buffer, 0, length);
m_maxHeartbeatInterval = loginReply.MaxHeartbeatInterval;
if (m_maxHeartbeatInterval > 0)
{
m_retryTimes = 0;
m_readIndex = m_writeIndex = 0;
m_lastReception = m_lastHeartbeat = (uint)Environment.TickCount;
m_runByState = Receive;
}
else
{
throw new Exception("Invalid login.");
}
}
catch (SocketException se)
{
OnErrorOccurred(se, false);
return(RetryOrGiveup(m_status));
}
catch (Exception ex)
{
OnErrorOccurred(ex, true);
m_runByState = Close;
}
return(0);
}
private LoginResponseMessage HandleLoginRequest(LoginRequestMessage msg)
{
try
{
PluginDriver sessionDriver = new PluginDriver();
// Remove white space around username
if (string.IsNullOrEmpty(msg.Username))
{
sessionDriver.UserInformation.Username = msg.Username;
}
else
{
sessionDriver.UserInformation.Username = msg.Username.Trim();
}
sessionDriver.UserInformation.Password = msg.Password;
sessionDriver.LogonInformation.Reason = msg.Reason.ToString();
m_logger.DebugFormat("Processing LoginRequest for: {0} in session: {1} reason: {2}",
sessionDriver.UserInformation.Username, msg.Session, msg.Reason);
BooleanResult result = sessionDriver.PerformLoginProcess();
if (msg.Reason == LoginRequestMessage.LoginReason.Login)
{
lock (m_sessionPropertyCache)
{
m_sessionPropertyCache.Add(msg.Session, sessionDriver.SessionProperties);
}
}
return(new LoginResponseMessage()
{
Result = result.Success,
Message = result.Message,
Username = sessionDriver.UserInformation.Username,
Domain = sessionDriver.UserInformation.Domain,
Password = sessionDriver.UserInformation.Password
});
}
catch (Exception e)
{
m_logger.ErrorFormat("Internal error, unexpected exception while handling login request: {0}", e);
return(new LoginResponseMessage()
{
Result = false, Message = "Internal error"
});
}
}
public async Task <IActionResult> Login([FromBody] LoginRequestViewModel model)
{
LoginInteractor loginRequestInteractor = new LoginInteractor(_authenticationService, _accountRepository, _jwtFactory, _jwtOptions);
var requestMessage = new LoginRequestMessage(model.Email, model.Password);
var responseMessage = await loginRequestInteractor.Handle(requestMessage);
var presenter = new LoginResponsePresenter();
var viewModel = presenter.Handle(responseMessage);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(new OkObjectResult(viewModel));
}
private LoginResponseMessage ValidateAuthenticateUser(LoginRequestMessage RequestMessage)
{
LoginResponseMessage response = new LoginResponseMessage();
if (RequestMessage==null)
{
ErrorLogManager.WriteLog(response, "002", "Request message should not be empty.");
}
else
{
if (string.IsNullOrEmpty(RequestMessage.LoginName))
ErrorLogManager.WriteLog(response, "003", "Login name is mandatory.");
if (string.IsNullOrEmpty(RequestMessage.Password))
ErrorLogManager.WriteLog(response, "004", "Password is mandatory.");
}
return response;
}
public HttpResponseMessage AuthenticateUser([FromBody] LoginRequestMessage requestMessage)
{
string filepath = System.Web.Hosting.HostingEnvironment.MapPath("~\\FileUpload\\");
loginBusinessProvider = new LoginBusinessAccessProvider(filepath);
//requestMessage = new LoginRequestMessage();
//requestMessage.LoginName = "frankanders";
//requestMessage.Password = "******";
LoginResponseMessage response = loginBusinessProvider.AuthenticateUser(requestMessage);
HttpResponseMessage tempResponse = Request.CreateResponse(HttpStatusCode.OK, response);
//string jsonMessage;
//using (Stream responseStream = tempResponse.Content.ReadAsStreamAsync().Result)
//{
// jsonMessage = new StreamReader(responseStream).ReadToEnd();
//}
return(tempResponse);
}
public async void OnLogin(Network network, LoginRequestMessage message)
{
LoginResponeMessage response = null;
switch (message.LoginType)
{
case LoginType.Account:
{
var login = LoginFactory.Create(LoginType.Account);
var account = await Game.Scene.GetComponent <AccountRpository>().GetByName(message.Account);
response = login.VerifyLogin(message, account);
if (response.LoginResult == LoginResutlCode.Success)
{
Game.Scene.GetComponent <ActorComponentStorage>().AddActor <PlayerComponent, TAccount>(account);
}
}
break;
case LoginType.AliPayLogin:
break;
case LoginType.SMSLogin:
break;
case LoginType.WXLogin:
break;
default:
response = new LoginResponeMessage()
{
LoginResult = LoginResutlCode.LoginTypeError
};
break;
}
network.Response(response);
}
public void Login(string uid, string pwd)
{
this.uid = uid;
this.pwd = pwd;
Message message = new Message(MessageType.LOGIN);
LoginRequestMessage msg = new LoginRequestMessage();
msg.LoginID = this.uid;
msg.LoginPwd = this.pwd;
message.SetMessageBody(msg);
if (!SendMessage(message))
{
OnLoginFail("发送请求失败");
if (LoginFail != null)
{
LoginFail();
}
}
}
public void ReceiveMessage <T> (T message)
{
if (typeof(T) == typeof(LoginRequestMessage))
{
}
if (typeof(T) == typeof(LoginRequestMessage))
{
LoginRequestMessage payload = message as LoginRequestMessage;
Debug.Log(payload.payload.message);
if (payload.payload.message == "LOGIN_SUCCESSFUL")
{
currentUser = new User(payload.payload.username, payload.payload.token);
if (this.gsManager)
{
this.gsManager.ChangeState(GameState.CHARACTER_SELECT);
}
}
}
}
private LoginResponseMessage ValidateAuthenticateUser(LoginRequestMessage RequestMessage)
{
LoginResponseMessage response = new LoginResponseMessage();
if (RequestMessage == null)
{
ErrorLogManager.WriteLog(response, "002", "Request message should not be empty.");
}
else
{
if (string.IsNullOrEmpty(RequestMessage.LoginName))
{
ErrorLogManager.WriteLog(response, "003", "Login name is mandatory.");
}
if (string.IsNullOrEmpty(RequestMessage.Password))
{
ErrorLogManager.WriteLog(response, "004", "Password is mandatory.");
}
}
return(response);
}
public void Login(long userId, string userToken)
{
var handshake = new HandshakeRequestMessage
{
AppStore = 2,
Build = 709,
DeviceType = 2,
Hash = "2f2c3464104feb771097b42ebf4dfe871bd56062",
KeyVersion = 20,
MajorVersion = 8,
MinorVersion = 0,
Protocol = 1,
};
_lrMessage = new LoginRequestMessage
{
// To make a new account
UserId = userId,
UserToken = userToken,
MajorVersion = 8,
MinorVersion = 709,
ContentVersion = 0,
LocaleKey = 2000000,
Language = "en",
AdvertisingGuid = "",
OSVersion = "4.4.2",
IsAdvertisingTrackingEnabled = true,
MasterHash = "2f2c3464104feb771097b42ebf4dfe871bd56062",
FacebookDistributionID = "",
VendorGUID = "",
ClientVersion = "8.709.2",
Seed = new Random().Next()
};
_networkManager.SendMessage(handshake);
_state = 1;
}
public static bool Login(string email, string password, string ipAddress, out bool isLockedOut, out bool isDellEmployee)
{
isLockedOut = false;
isDellEmployee = false;
using (var client = new SSOServiceClient("BasicHttpBinding_ISSOService", "https://externalsso.quest.com/sso/ssoservice.svc"))
{
var request = new LoginRequestMessage
{
UserName = email,
Password = password,
IPAddress = ipAddress
};
if (ipAddress == "::1")
request.IPAddress = "127.0.0.1";
try
{
var response = client.Login(request);
isDellEmployee = response.IsEmployee;
return true;
}
catch (FaultException<ADFault> ex)
{
if (ex.Detail.Code == 5017 || // Logon failure: unknown user name or bad password.
ex.Detail.Code == 5039) // UserName is invalid
{
return false;
}
if (ex.Detail.Code == 5001) //Account is temporary locked out
{
isLockedOut = true;
return false;
}
throw;
}
}
}
public async Task <Response <User> > LoginAsync(LoginRequestMessage requestMessage)
{
var response = Response <User> .Create();
if (requestMessage == null)
{
requestMessage = new LoginRequestMessage();
}
var user = await UserRepository.FindAsync(requestMessage.Identification);
if (!user.HasValue)
{
return(response.WithBusinessError(nameof(requestMessage.Password), "Usuário e/ou senha inválido(s)."));
}
if (response.WithMessages(user.Value.Login(requestMessage.Password, JWTSettings.Value.Secret).Messages).HasError)
{
return(response);
}
return(response.SetValue(user));
}
private void App_Login(Message message, Session session)
{
Exception ex = null;
LoginRequestMessage request = message.GetMessageBody <LoginRequestMessage>();
//string uid = message.Get<string>(FieldEnum.LoginID);
//string pwd = message.Get<string>(FieldEnum.LoginPwd);
Message LoginSuccessMessage = new Message(MessageType.LOGIN);
LoginResponseMessage responsemsg = new LoginResponseMessage();
string loginFailMsg = string.Empty;
bool canLogin = false;
try
{
canLogin = OnUserLogin(request.LoginID, request.LoginPwd, out loginFailMsg);
}
catch (Exception e)
{
ex = e;
loginFailMsg = "服务器出错";
}
if (canLogin)
{
responsemsg.LoginResult = true;
session.IsLogin = true;
session.UserName = request.LoginID;
//session.Socket = s;
//session.IPAddress = ((System.Net.IPEndPoint)s.RemoteEndPoint).Address.ToString();
lock (appLoginSockets)
{
if (appLoginSockets.ContainsKey(session.SessionID))
{
appLoginSockets.Remove(session.SessionID);
}
appLoginSockets.Add(session.SessionID, session);
}
Console.WriteLine("{0}成功登陆", request.LoginID);
}
else
{
responsemsg.LoginResult = false;
}
string heartBeatConfig = ConfigHelper.AppConfig("HeartBeat");
//int headBeatInt = int.Parse(ConfigurationManager.AppSettings["HeartBeat"]);
int headBeatInt;
if (!int.TryParse(heartBeatConfig, out headBeatInt))
{
headBeatInt = 5000;
}
responsemsg.SessionID = session.SessionID;
responsemsg.LoginID = request.LoginID;
responsemsg.HeadBeatInterVal = headBeatInt;
responsemsg.SessionTimeOut = headBeatInt * 3;
responsemsg.LoginFailReson = loginFailMsg;
LoginSuccessMessage.SetMessageBody(responsemsg);
session.SendMessage(LoginSuccessMessage);
if (!canLogin)
{
session.Close();
Console.WriteLine("{0}登录失败", request.LoginID);
}
if (ex != null)
{
throw ex;
}
}
public abstract LoginResponeMessage VerifyLogin(LoginRequestMessage request, TAccount account);
public override LoginResponeMessage VerifyLogin(LoginRequestMessage request, TAccount account)
{
throw new NotImplementedException();
}
/// <summary>
/// Try to login client. Send response about result.
/// </summary>
/// <param name="client">client.</param>
/// <param name="message">client's message.</param>
private void LoginClient(MpClient client, LoginRequestMessage message)
{
bool isLoggedIn = false;
Message response;
if (string.IsNullOrEmpty(message.Login) ||
string.IsNullOrEmpty(message.Password) ||
message.Login.Length > 20 ||
message.Password.Length > 30)
{
response = new LoginRegisterResponseMessage {
Response = LoginRegisterResponse.Error
};
}
else if (usersHandler.GetOnlineUser(message.Login) != null)
{
response = new LoginRegisterResponseMessage {
Response = LoginRegisterResponse.AlreadyLogin
};
}
else
{
// client's id in db
if (DBoperations.Login(message.Login, message.Password, out int id))
{
log.Info($"Client logged in: {message.Login}");
// user is online
OnlineUser user = new OnlineUser(id, message.Login, client);
usersHandler.AddUser(user);
isLoggedIn = true;
response = new LoginRegisterResponseMessage {
Response = LoginRegisterResponse.Success
};
}
else
{
response = new LoginRegisterResponseMessage {
Response = LoginRegisterResponse.Fail
};
}
}
try
{
// response to client
client.SendMessage(response);
}
catch (ConnectionInterruptedException e)
{
log.Error("Connection with client broke.", e);
}
// close connection with client if client not logged in
if (!isLoggedIn)
{
log.Info($"Client disconnected. ip {((IPEndPoint)client.tcpClient.Client.RemoteEndPoint).Address.ToString()}");
try
{
client.Close();
}
catch (ConnectionInterruptedException e)
{
log.Error(e);
}
}
}
