/// <summary>
/// Implementación de Contrato para verificar un jugador antes de ser otorgado acceso al sistema
/// </summary>
/// <param name="player"></param>
public void VerifyPlayer(Dominio.Jugador player)
{
VerificationResult resultado = VerificationResult.NoExisteJugador;
JugadorDataManager jugadorManager = new JugadorDataManager();
if (jugadorManager.CheckNickname(player.Apodo))
{
if (jugadorManager.PinCorrecto(player.Apodo, player.PinConfirmacion))
{
int result = jugadorManager.VerifyNewPlayer(new DataAccess.Jugador
{
apodo = player.Apodo,
pinConfirmacion = player.PinConfirmacion,
});
if (result > 0)
{
resultado = VerificationResult.VerificacionExistosa;
}
}
else
{
resultado = VerificationResult.PinIncorrecto;
}
}
else
{
resultado = VerificationResult.NoExisteJugador;
}
PlayerCallback.GetVerifyResult(resultado);
}
/// <summary>
/// Implementación de Contrato para iniciar sesion al sistema
/// </summary>
/// <param name="player"></param>
/// <exception>
/// Este metodo puede retornar una excepcion tipo AddressAlreadyInUseEsception
/// </exception>
public void Login(Jugador player)
{
LoginResult result;
AdminDataManager adminDataManager = new AdminDataManager();
if (adminDataManager.CheckNickname(player.Apodo))
{
if (adminDataManager.EsPasswordCorrecto(player.Contrasenia, player.Apodo))
{
try
{
result = LoginResult.EsAdmin;
playersLoggedIn.Add(player.Apodo, PlayerCallback);
}
catch (AddressAlreadyInUseException)
{
result = LoginResult.LOGGED_PLAYER;
}
PlayerCallback.GetAdminLoginResult(result, player);
}
else
{
result = LoginResult.PasswordIncorrecto;
PlayerCallback.GetAdminLoginResult(result, player);
}
}
else
{
LoginPlayer(player);
}
}
/// <summary>
/// Implementación de Contrato para enviar correo al email de un jugador
/// </summary>
/// <param name="player"></param>
/// <exception>
/// Este metodo puede retornar una excepcion tipo SmtpException
/// </exception>
public void SendMail(Jugador player)
{
MailResult mailSuccesResult;
System.Net.Mail.MailMessage mailMesagge = new System.Net.Mail.MailMessage();
mailMesagge.To.Add(player.CorreoElectronico);
mailMesagge.Subject = "Account creation confirmation" + player.Apodo;
mailMesagge.Body = "Hello " + player.Apodo + " you are one step away from verifying your account!, " +
"the account verification code is as follows: " + player.PinConfirmacion;
mailMesagge.From = new System.Net.Mail.MailAddress("*****@*****.**", "Checkers Game Proyect");
System.Net.Mail.SmtpClient client = new System.Net.Mail.SmtpClient
{
Credentials = new System.Net.NetworkCredential(mailUser, mailPassword),
Port = 587,
EnableSsl = true,
Host = "smtp.gmail.com",
};
try
{
client.Send(mailMesagge);
mailSuccesResult = MailResult.MailSend;
PlayerCallback.GetResendMailResult(mailSuccesResult, player.Apodo);
}
catch (System.Net.Mail.SmtpException)
{
mailSuccesResult = MailResult.SendError;
PlayerCallback.GetResendMailResult(mailSuccesResult, player.Apodo);
}
}
/// <summary>
/// Implementación de Contrato para obtener datos de un jugador
/// </summary>
/// <param name="actualPlayer"></param>
public void GetActualPlayer(Jugador actualPlayer)
{
DataObtainedResult dataObtainedResult = DataObtainedResult.ErrorObtainingData;
DataAccess.Jugador searchedPlayer = jugadorDataManager.GetPlayerByNickname(actualPlayer.Apodo);
if (searchedPlayer != null)
{
Dominio.Jugador domainSearchedPlayer = new Dominio.Jugador
{
IdJugador = searchedPlayer.idJugador,
Apodo = searchedPlayer.apodo,
CorreoElectronico = searchedPlayer.correoElectronico,
Status = searchedPlayer.status,
PreguntaRecuperacion = searchedPlayer.preguntaRecuperacion,
IdLenguaje = searchedPlayer.idioma
};
dataObtainedResult = DataObtainedResult.DataObtained;
PlayerCallback.SendActualPlayer(dataObtainedResult, domainSearchedPlayer);
}
else
{
Dominio.Jugador emptyPlayer = new Jugador();
PlayerCallback.SendActualPlayer(dataObtainedResult, emptyPlayer);
}
}
private void SaveNewPlayer(Jugador player)
{
SaveResult saveResult;
DataAccess.Jugador newPlayer = new DataAccess.Jugador
{
apodo = player.Apodo,
contrasenia = hashText.TextToHash(player.Contrasenia),
correoElectronico = player.CorreoElectronico,
status = ACTIVATION_STATE,
respuestaConfirmacion = player.RespuestaConfirmacion,
preguntaRecuperacion = player.PreguntaRecuperacion,
pinConfirmacion = player.PinConfirmacion,
idCreador = 1,
idioma = player.IdLenguaje
};
JugadorDataManager jugadorManager = new JugadorDataManager();
int columnasAfectadas = jugadorManager.SaveNewPlayer(newPlayer);
RankingDataManager rankingData = new RankingDataManager();
rankingData.NewPlayerRank(newPlayer);
if (columnasAfectadas > 0)
{
saveResult = SaveResult.JugadorGuardado;
PlayerCallback.GetSaveResult(saveResult, player);
}
else
{
saveResult = SaveResult.ErrorGuardado;
PlayerCallback.GetSaveResult(saveResult, player);
}
}
public void RegisterPlayer(Player newPlayer)
{
int result = 0;
string token = "";
const int PLAYER_REGISTERED = 1, PLAYER_ALREADY_REGISTERED = 2, UNVERIFIED_PLAYER = 3, UNAVAILABLE_EMAIL = 4, UNAVAILABLE_USERNAME = 5;
const int PLAYER_DOESNT_EXIST = 1, REPEATED_EMAIL = 2, REPEATED_USERNAME = 3, PLAYER_REPEATED = 4;
try
{
int playerExistence = PlayerAlreadyExist(newPlayer.username, newPlayer.email);
if (playerExistence == PLAYER_DOESNT_EXIST)
{
token = new DataManager().GenerateVerificationToken();
newPlayer.verificationToken = token;
newPlayer.password = new DataManager().EncryptPassword(newPlayer.password);
new EmailVerification().SendEmail(newPlayer.email, token);
if (AddNewPlayer(newPlayer))
{
result = PLAYER_REGISTERED;
}
}
else if (playerExistence == PLAYER_REPEATED)
{
if (CheckPlayerVerification(newPlayer))
{
result = PLAYER_ALREADY_REGISTERED;
}
else
{
result = UNVERIFIED_PLAYER;
token = new DataManager().GenerateVerificationToken();
new EmailVerification().SendEmail(newPlayer.email, token);
ChangePlayerToken(newPlayer.username, token);
}
}
else if (playerExistence == REPEATED_EMAIL)
{
result = UNAVAILABLE_EMAIL;
}
else if (playerExistence == REPEATED_USERNAME)
{
result = UNAVAILABLE_USERNAME;
}
}
catch (Exception e)
{
throw e;
}
PlayerCallback.VerifyPlayerRegistration(result, newPlayer.username);
}
/// <summary>
/// Implementación de Contrato para guardar un jugador registrado a la base de datos
/// </summary>
/// <param name="player"></param>
/// <exception>
/// Este metodo puede retornar una excepcion tipo SmtpException
/// </exception>
public void SavePlayer(Dominio.Jugador player)
{
JugadorDataManager playerDataManager = new JugadorDataManager();
SaveResult saveResult;
MailResult mailResult;
bool nicknameExists = playerDataManager.CheckNickname(player.Apodo);
if (!nicknameExists)
{
bool emailExists = playerDataManager.CheckEmail(player.CorreoElectronico);
if (!emailExists)
{
System.Net.Mail.MailMessage mensaje = new System.Net.Mail.MailMessage();
mensaje.To.Add(player.CorreoElectronico);
mensaje.Subject = "Account creation confirmation" + player.Apodo;
mensaje.Body = "Hello " + player.Apodo + " you are one step away from verifying your account!, " +
"the account verification code is as follows: " + player.PinConfirmacion;
mensaje.From = new System.Net.Mail.MailAddress("*****@*****.**", "Checkers Game Proyect");
System.Net.Mail.SmtpClient cliente = new System.Net.Mail.SmtpClient
{
Credentials = new System.Net.NetworkCredential(mailUser, mailPassword),
Port = 587,
EnableSsl = true,
Host = "smtp.gmail.com",
};
try
{
mailResult = MailResult.MailSend;
cliente.Send(mensaje);
}
catch (System.Net.Mail.SmtpException)
{
mailResult = MailResult.SendError;
PlayerCallback.GetResendMailResult(mailResult, player.Apodo);
}
if (mailResult == MailResult.MailSend)
{
SaveNewPlayer(player);
}
}
else
{
saveResult = SaveResult.CorreoExistente;
PlayerCallback.GetSaveResult(saveResult, player);
}
}
else
{
saveResult = SaveResult.NicknameExistente;
PlayerCallback.GetSaveResult(saveResult, player);
}
}
public static void Patch()
{
if (playerCallback != null)
{
UnPatch();
}
playerCallback = new PlayerCallback();
TrackingHandler <Player> .Subscribe(playerCallback, true);
}
public void CallOnStateEnd(State state, PlayerCallback callback, bool early = false)
{
if (early)
{
onAnyPlayerExitStateSubscribers_early[state] += callback;
}
else
{
onAnyPlayerExitStateSubscribers[state] += callback;
}
}
/////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////
////////////////////// IN SYSTEM ////////////////////////
/////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////
/// <summary>
/// Set Player's Callback
/// </summary>
/// <param name="select">
/// <para>0. PlayerDie : If player died, destroy all object</para>
/// <para>1. GetItem : If Player get item, signal to GamaManager.cs</para>
/// </param>
/// <param name="callback">
/// <para>0. PlayerDie</para>
/// <para>1. GetItem</para>
/// </param>
public void SetCallback(int select, PlayerCallback callback)
{
switch (select)
{
case 0:
op_CallbackPlayerDie = callback;
break;
case 1:
op_CallbackGetItem = callback;
break;
}
}
/// <summary>
/// Implementación de Contrato para iniciar sesion como Jugador
/// </summary>
/// <param name="player"></param>
public void LoginPlayer(Jugador player)
{
LoginResult result = LoginResult.NoExisteJugador;
JugadorDataManager jugadorManager = new JugadorDataManager();
if (jugadorManager.CheckNickname(player.Apodo))
{
if (jugadorManager.CheckState(player.Apodo))
{
if (jugadorManager.EsPasswordCorrecto(player.Contrasenia, player.Apodo))
{
DataAccess.Jugador searchedPlayer = jugadorManager.GetPlayerByNickname(player.Apodo);
if (!playersLoggedIn.ContainsKey(searchedPlayer.apodo))
{
result = LoginResult.ExisteJugadorVerificado;
playersLoggedIn.Add(searchedPlayer.apodo, PlayerCallback);
player.Apodo = searchedPlayer.apodo;
player.IdLenguaje = searchedPlayer.idioma;
player.IdJugador = searchedPlayer.idJugador;
player.Contrasenia = searchedPlayer.contrasenia;
player.CorreoElectronico = searchedPlayer.correoElectronico;
player.PreguntaRecuperacion = searchedPlayer.preguntaRecuperacion;
PlayerCallback.GetPlayerLoginResult(result, player);
}
else
{
result = LoginResult.LOGGED_PLAYER;
PlayerCallback.GetPlayerLoginResult(result, player);
}
}
else
{
result = LoginResult.PasswordIncorrecto;
PlayerCallback.GetPlayerLoginResult(result, player);
}
}
else
{
CheckBan(player);
}
}
else
{
PlayerCallback.GetPlayerLoginResult(result, player);
}
}
public void GetAllPlayers()
{
List <Player> players = null;
try
{
using (UNODBEntities db = new UNODBEntities())
{
players = db.Players.ToList();
}
}
catch (Exception e)
{
throw e;
}
PlayerCallback.GetPlayersResponse(players);
}
/// <summary>
/// Implementación de Contrato para actualizar la contraseña de un jugador
/// </summary>
/// <param name="userNickname"></param>
/// <param name="password"></param>
public void ChangePassword(string userNickname, string password)
{
PasswordChangeResult changeResult = PasswordChangeResult.ErrorChanging;
if (jugadorDataManager.CheckNickname(userNickname))
{
string newPassword = hashText.TextToHash(password);
int resultChange = jugadorDataManager.ChangePassword(userNickname, newPassword);
if (resultChange > 0)
{
changeResult = PasswordChangeResult.ChangedPassword;
}
}
PlayerCallback.GetPasswordChangeResult(changeResult);
}
private void CheckBan(Jugador player)
{
LoginResult result;
if (jugadorDataManager.CheckBannedState(player.Apodo))
{
result = LoginResult.EsBaneado;
PlayerCallback.GetPlayerLoginResult(result, player);
}
else
{
result = LoginResult.ExisteJugadorNoVerificado;
PlayerCallback.GetPlayerLoginResult(result, player);
}
}
/// <summary>
/// Implementación de Contrato para verificar el PIN de confirmacion para habilitar el cambio de contraseña de un jugador
/// </summary>
/// <param name="actualNickname"></param>
/// <param name="playerPin"></param>
/// <param name="answerText"></param>
public void VerifyPin(string actualNickname, string playerPin, string answerText)
{
PinResult pinResult = PinResult.UnknownPin;
if (jugadorDataManager.PinCorrecto(actualNickname, playerPin))
{
if (jugadorDataManager.CorrectAnswer(actualNickname, answerText))
{
pinResult = PinResult.VerifiedPin;
}
else
{
pinResult = PinResult.WrongAnswer;
}
}
PlayerCallback.GetPinResult(pinResult, actualNickname);
}
/// <summary>
/// Implementación de Contrato para enviar email de solicitud de cambio de contraseña a un jugador
/// </summary>
/// <param name="actualNickname"></param>
/// <exception>
/// Este metodo puede retornar una excepcion tipo SmtpException
/// </exception>
public void PasswordForgotMail(string actualNickname)
{
JugadorDataManager jugadorManager = new JugadorDataManager();
MailResult mailSuccesResult;
string securityQuestion = " ";
if (jugadorManager.CheckNickname(actualNickname))
{
DataAccess.Jugador player = jugadorManager.ChangePinByNickname(actualNickname);
securityQuestion = player.preguntaRecuperacion;
System.Net.Mail.MailMessage mailMesagge = new System.Net.Mail.MailMessage();
mailMesagge.To.Add(player.correoElectronico);
mailMesagge.Subject = "Recuperacion de cuenta del jugador " + player.apodo;
mailMesagge.Body = "Hola " + player.apodo + " has solicitado una recuperacion de cuenta, " +
"el código de verificación para cambiar tu contraseña es el siguiente: " + player.pinConfirmacion;
mailMesagge.From = new System.Net.Mail.MailAddress("*****@*****.**", "Checkers Game Proyect");
System.Net.Mail.SmtpClient client = new System.Net.Mail.SmtpClient
{
Credentials = new System.Net.NetworkCredential(mailUser, mailPassword),
Port = 587,
EnableSsl = true,
Host = "smtp.gmail.com",
};
try
{
client.Send(mailMesagge);
mailSuccesResult = MailResult.MailSend;
PlayerCallback.GetMailResult(mailSuccesResult, actualNickname, securityQuestion);
}
catch (System.Net.Mail.SmtpException)
{
mailSuccesResult = MailResult.SendError;
PlayerCallback.GetMailResult(mailSuccesResult, actualNickname, securityQuestion);
}
}
else
{
mailSuccesResult = MailResult.UnknownPlayer;
PlayerCallback.GetMailResult(mailSuccesResult, actualNickname, securityQuestion);
}
}
public void CallOnStateEnd(State state, PlayerCallback callback)
{
onAnyPlayerEndSubscribers[state] += callback;
}
public static void UnPatch()
{
TrackingHandler <Player> .Unsubscribe(playerCallback, true);
playerCallback = null;
}
public void SetCallbacks(PlayerCallback playerDie, PlayerCallback getItem, PlayerCallback spawnEnd)
{
op_CallbackPlayerDie = playerDie;
op_CallbackGetItem = getItem;
op_CallbackGameStart = spawnEnd;
}
public void CallOnStateStart(State state, PlayerCallback callback)
{
onAnyPlayerStartSubscribers[state] += callback;
}
