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);
}
private void HandleLoginResponse(BaseWorldMessage message)
{
LoginResponseMessage loginResponse = (LoginResponseMessage)message;
loginFailed = !loginResponse.Success;
loginMessage = loginResponse.Message;
}
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);
}
/// <summary>
/// 客户端方法
/// </summary>
/// <param name="message"></param>
protected sealed override void OnMessage(Message message)
{
base.OnMessage(message);
if (SessionContext != null)
{
SessionContext.LastSessionTime = DateTime.Now;
}
if (message.IsMessage(MessageType.LOGIN))
{
LoginResponseMessage loginMsg = message.GetMessageBody <LoginResponseMessage>();
if (loginMsg.LoginResult)
{
StartHearteBeat(loginMsg);
OnLoginSuccess();
if (LoginSuccess != null)
{
LoginSuccess();
}
}
else
{
OnLoginFail(loginMsg.LoginFailReson);
if (LoginFail != null)
{
LoginFail();
}
}
}
else if (message.IsMessage(MessageType.HEARTBEAT))
{
ReciveHeartBeat(message);
}
else if (message.IsMessage(MessageType.LOGOUT))
{
SessionContext.IsLogin = false;
SessionContext.IsValid = false;
stop = true;
isStartClient = false;
this.timer.Stop();
}
else if (message.IsMessage(MessageType.RELOGIN))
{
if (SessionContext == null)
{
throw new Exception("请先调用login方法。");
}
SessionContext.IsLogin = false;
Login(uid, pwd);
}
else
{
ReciveMessage(message);
}
}
public async Task <LoginResponseMessage> SignIn(string username, string password)
{
var user = await _userRepository.GetByUsername(username);
var response = new LoginResponseMessage();
if (user == null)
{
response.Message = "A user with these credentials does not exist.";
response.IsSuccessful = false;
return(response);
}
var passByteArr = Encoding.UTF8.GetBytes(password);
var saltByteArr = Convert.FromBase64String(user.Salt);
var saltedHash = new Rfc2898DeriveBytes(passByteArr, saltByteArr, 1000);
var hashedPass = Convert.ToBase64String(saltedHash.GetBytes(20));
if (user.Password != hashedPass)
{
response.Message = "Your password is incorrect.";
response.IsSuccessful = false;
}
else
{
var role = user.IsAdmin ? "Admin" : "User";
var claims = new[]
{
new Claim(ClaimTypes.Name, user.Username),
new Claim(ClaimTypes.Role, role),
new Claim(ClaimTypes.GivenName, user.FirstName),
new Claim(ClaimTypes.Surname, user.LastName),
new Claim(ClaimTypes.Email, user.Email),
new Claim("Id", user.Id.ToString())
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["Jwt:SecurityKey"]));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var expiry = DateTime.Now.AddDays(Convert.ToInt32(_configuration["Jwt:ExpiryInDays"]));
var token = new JwtSecurityToken(
_configuration["Jwt:Issuer"],
_configuration["Jwt:Issuer"],
claims,
expires: expiry,
signingCredentials: creds
);
response.Token = new JwtSecurityTokenHandler().WriteToken(token);
response.Message = "Successfully signed in.";
response.IsSuccessful = true;
response.User = user;
}
return(response);
}
public async Task <(bool loggedIn, string message)> LoginAsync(string username)
{
LoginResponseMessage response = await connection.RequestAsync <LoginResponseMessage>(new LoginMessage(username));
bool loggedIn = response?.LoggedIn ?? false;
if (loggedIn)
{
Player = response.Player;
}
return(loggedIn, response?.Message);
}
private async void ConnectionServer_OnConnection(IConnectionServer connectionServer, IConnection connection)
{
TaskCompletionSource <ConnectedClient> loginTaskCompletionSource = new TaskCompletionSource <ConnectedClient>();
connection.OnDisconnection += DisconnectionHandler;
connection.OnRequest += RequestHandler;
connection.Start();
ConnectedClient client = await loginTaskCompletionSource.Task;
connection.OnDisconnection -= DisconnectionHandler;
connection.OnRequest -= RequestHandler;
if (client == null)
{
connection.Stop();
}
else
{
clients.Add(connection.ID, client);
connection.OnDisconnection += Connection_OnDisconnection;
}
Message RequestHandler(IConnection connection, Message message)
{
Message result = null;
ConnectedClient client = null;
if (message is LoginMessage loginMessage)
{
if (clients.Any(c => c.Value.Player.Username == loginMessage.Username))
{
result = LoginResponseMessage.FromError("User already connected");
}
else
{
client = new ConnectedClient(connection, loginMessage.Username);
result = LoginResponseMessage.FromSucccess(client.Player);
}
}
loginTaskCompletionSource.TrySetResult(client);
return(result);
}
void DisconnectionHandler(IConnection connection, bool userDisconnection)
{
loginTaskCompletionSource.TrySetResult(null);
}
}
private void StartHearteBeat(LoginResponseMessage message)
{
SessionContext = new Session();
SessionContext.UserName = message.LoginID;
SessionContext.ConnectTime = DateTime.Now;
SessionContext.SessionID = message.SessionID;
SessionContext.SessionTimeOut = message.SessionTimeOut;
SessionContext.HeadBeatInterVal = message.HeadBeatInterVal;
SessionContext.IsLogin = true;
SessionContext.IsValid = true;
if (_heartbeatTimer == null)
{
_heartbeatTimer = new System.Threading.Timer(new System.Threading.TimerCallback(DoHeartBeat), null, message.HeadBeatInterVal, 0);
}
}
public LoginResponseViewModel Handle(LoginResponseMessage responseMessage)
{
if (responseMessage.Success)
{
return(new LoginResponseViewModel(true, "Login successful!", responseMessage.Token));
}
var sb = new StringBuilder();
sb.AppendLine("Failed to Login");
foreach (var e in responseMessage.Errors)
{
sb.AppendLine(e);
}
return(new LoginResponseViewModel(false, sb.ToString(), responseMessage.Token));
}
private void StartHearteBeat(LoginResponseMessage message)
{
SessionContext = new Session();
SessionContext.UserName = message.LoginID;
SessionContext.ConnectTime = DateTime.Now;
SessionContext.SessionID = SocketApplicationComm.GetSeqNum();
SessionContext.SessionTimeOut = message.SessionTimeOut;
SessionContext.HeadBeatInterVal = message.HeadBeatInterVal;
SessionContext.IsLogin = true;
SessionContext.IsValid = true;
if (timer == null)
{
timer = new Timer(SessionContext.HeadBeatInterVal);
timer.Elapsed += HeartBeat_Elapsed;
timer.Start();
}
}
public ActionResult Index(LoginAndRegisterViewModel loginAndRegisterViewModel)
{
if (loginAndRegisterViewModel.loginRequestMessage != null)
{
var response = client.PostAsJsonAsync("https://mtsk-proje.herokuapp.com/api/users/login", loginAndRegisterViewModel.loginRequestMessage);
response.Wait();
var q = response.Result;
var responseString = q.Content.ReadAsStringAsync();
LoginResponseMessage message = new LoginResponseMessage();
message = JsonConvert.DeserializeObject <LoginResponseMessage>(responseString.Result);
if (message.Success == 1)
{
Session["token"] = message.Token;
return(RedirectToAction("Index", "Home"));
}
else
{
ViewBag.alert = "danger";
ViewBag.result = "Kullanıcı adı veya şifre hatalı!";
return(View());
}
}
else
{
var response = client.PostAsJsonAsync("https://mtsk-proje.herokuapp.com/api/users", loginAndRegisterViewModel.registerRequestMessage);
response.Wait();
var q = response.Result;
var responseString = q.Content.ReadAsStringAsync();
RegisterResponseMessage message = new RegisterResponseMessage();
message = JsonConvert.DeserializeObject <RegisterResponseMessage>(responseString.Result);
if (message.success == 1)
{
ViewBag.alert = "success";
ViewBag.result = "Kayıt başarılı!";
return(View());
}
else
{
ViewBag.alert = "danger";
ViewBag.result = "Kayıt yapılamadı!";
return(View());
}
}
}
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);
}
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);
}
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;
}
}
/// <summary>
/// Static method that takes in an xml String and converts it to an AbstractMessage.
///
/// Will throw an XmlException if the xml String was in an unrecognized format.
/// </summary>
/// <param name="xml">A String with xml representing an AbstractMessage</param>
/// <returns>The AbstractMessage parsed from the XML String</returns>
public override AbstractMessage Parse(String xml)
{
XmlTextReader reader = new XmlTextReader(new StringReader(xml));
AbstractMessage returnee = null;
Int32 chatId = 0;
String element = "";
String textMessage = "";
String username = "";
String password = "";
String sender = "";
Boolean accepted = false;
Boolean isAlreadyLoggedOn = true;
Boolean alreadyExisted = false;
Boolean authenticationDisabled = false;
GroupChat chat = null;
ExtendedHashSet<String> hashSet = null;
try
{
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.CDATA:
switch (element)
{
case "Message":
textMessage = reader.Value;
break;
case "Username":
username = reader.Value;
break;
case "Password":
password = reader.Value;
break;
case "User":
hashSet.Add(reader.Value);
break;
case "Participant":
hashSet.Add(reader.Value);
break;
case "Sender":
sender = reader.Value;
break;
case "Name":
hashSet.Add(reader.Value);
break;
default:
break;
}
break;
case XmlNodeType.Element:
element = reader.Name; // define last known element
switch (element)
{
case "UserList":
hashSet = new ExtendedHashSet<String>();
break;
case "Participants":
hashSet = new ExtendedHashSet<String>();
break;
case "ToBeAdded":
hashSet = new ExtendedHashSet<String>();
break;
case "ToBeRemoved":
hashSet = new ExtendedHashSet<String>();
break;
}
break;
case XmlNodeType.EndElement:
switch (reader.Name)
{
case "TextMessage":
returnee = new TextMessage(textMessage);
break;
case "LoginMessage":
returnee = new LoginMessage(username, password);
break;
case "LoginResponseMessage":
returnee = new LoginResponseMessage(accepted, isAlreadyLoggedOn, username);
break;
case "AddToUserListMessage":
returnee = new AddToUserListMessage(hashSet);
break;
case "RemoveFromUserListMessage":
returnee = new RemoveFromUserListMessage(hashSet);
break;
case "GroupChatMessage":
returnee = new GroupChatMessage(chat, textMessage, sender);
break;
case "AddMemberToGroupChatMessage":
returnee = new AddMemberToGroupChatMessage(chatId, hashSet);
break;
case "RemoveMemberFromGroupChatMessage":
returnee = new RemoveMemberFromGroupChatMessage(chatId, hashSet);
break;
case "StartGroupChatRequestMessage":
returnee = new StartGroupChatRequestMessage(hashSet);
break;
case "StartGroupChatResponseMessage":
returnee = new StartGroupChatResponseMessage(chatId, alreadyExisted);
break;
case "GroupChatInfoRequestMessage":
returnee = new GroupChatInfoRequestMessage(chatId);
break;
case "GroupChatInfoResponseMessage":
returnee = new GroupChatInfoResponseMessage(chat);
break;
case "SignupRequestMessage":
returnee = new SignupRequestMessage(username, password);
break;
case "SignupResponseMessage":
returnee = new SignupResponseMessage(accepted, alreadyExisted, authenticationDisabled);
break;
case "GroupChat":
chat = new GroupChat(hashSet, chatId);
break;
default:
break;
}
break;
case XmlNodeType.Text:
switch (element)
{
case "Accepted":
accepted = Boolean.Parse(reader.Value);
break;
case "IsAlreadyLoggedOn":
isAlreadyLoggedOn = Boolean.Parse(reader.Value);
break;
case "ChatID":
chatId = int.Parse(reader.Value);
break;
case "AlreadyExisted":
alreadyExisted = Boolean.Parse(reader.Value);
break;
case "AuthenticationDisabled":
authenticationDisabled = Boolean.Parse(reader.Value);
break;
default:
break;
}
break;
default:
break;
}
}
}
catch
{
throw new XmlException("Unrecognized XML Format...");
}
reader.Close();
if (returnee != null)
{
return returnee;
}
else
{
throw new XmlException("Unrecognized XML Format...");
}
}
