/// <summary>
/// Verifica si la cuenta se encuentra en una sala
/// </summary>
/// <param name="Cuenta">CuentaModel</param>
/// <returns>Verdadero si la cuenta se encuentra en la sala, falso si no</returns>
public bool VerificarSiEstoyEnSala(CuentaModel Cuenta)
{
Boolean SeEncuentraEnSala = false;
foreach (Sala sala in SalasCreadas)
{
if (sala.EstaLaCuentaEnLaSala(Cuenta))
{
SeEncuentraEnSala = true;
}
}
return(SeEncuentraEnSala);
}
public void VerificarCuentaTest()
{
CuentaModel cuenta = new CuentaModel()
{
NombreUsuario = "WingXstar",
Contrasena = "PepitoElgrillo45",
CorreoElectronico = "*****@*****.**"
};
EnumEstadoVerificarCuenta expectedResut = EnumEstadoVerificarCuenta.NoCoincideElCodigo;
CuentaService service = new CuentaService();
Assert.AreEqual(expectedResut, service.VerificarCuenta("432", cuenta));
}
public void RegistrarseTestRegistroExitoso()
{
CuentaModel cuenta = new CuentaModel()
{
NombreUsuario = "chino3",
Contrasena = "hola9011",
CorreoElectronico = "*****@*****.**"
};
EnumEstadoRegistro expectedResut = EnumEstadoRegistro.RegistroCorrecto;
CuentaService service = new CuentaService();
Assert.AreEqual(expectedResut, service.Registrarse(cuenta));
}
public void Eliminar(MovimientosModel datos)
{
using (var c = new Contexto())
{
CuentasRepository RepoCuentas = new CuentasRepository();
CuentaModel _cuenta = RepoCuentas.Devolver(datos.CuentaId);
RepoCuentas.MovimientosCuenta(null, _cuenta, datos.Monto);
_cuenta.Movimientos = null;
datos.Cuenta = null;
c.Entry(_cuenta).State = EntityState.Modified;
c.Entry(datos).State = EntityState.Deleted;
c.SaveChanges();
}
}
/// <summary>
/// Le solcita al servicio de sesion logearse con los datos de los campos
/// </summary>
public void ButtonLogIn()
{
try
{
SessionServiceClient clienteSesion = SessionCliente.clienteDeSesion.servicioDeSesion;
if (CamposDeLogeoValidos())
{
SessionCliente.clienteDeSesion.ReiniciarServicio();
CuentaModel cuentaIniciarSesion = RecuperarDatosDeLogin();
EnumEstadoInicioSesion estadoDeInicioDeSesion = clienteSesion.IniciarSesion(cuentaIniciarSesion);
switch (estadoDeInicioDeSesion)
{
case EnumEstadoInicioSesion.Correcto:
Debug.Log("Credenciales Validas, ingreso exitoso.");
InicioDeSesionCorrecto(cuentaIniciarSesion);
break;
case EnumEstadoInicioSesion.CredencialesInvalidas:
Debug.Log("Credenciales Invalidas, ingrese una validas porfavor.");
PanelException.SetActive(true);
PanelException.GetComponentInChildren <Text>().text = "Credenciales Invalidas, ingrese una validas porfavor";
break;
case EnumEstadoInicioSesion.CuentaYaLogeada:
Debug.Log("La cuenta ya se encuentra logeada.");
PanelException.SetActive(true);
PanelException.GetComponentInChildren <Text>().text = "La cuenta ya se encuentra logeada.";
break;
case EnumEstadoInicioSesion.ErrorBD:
Debug.Log("Error en Base de Datos.");
PanelException.SetActive(true);
PanelException.GetComponentInChildren <Text>().text = "Surgio un Error, porfavor intente más tarde";
break;
case EnumEstadoInicioSesion.CuentaNoVerificada:
Debug.Log("Cuenta No Verificada.");
PanelException.SetActive(true);
PanelException.GetComponentInChildren <Text>().text = "Su cuenta no está verificada aun, porfavor verifiquela.";
CuentaNoVerificada(cuentaIniciarSesion);
break;
}
}
}catch (SocketException ex)
{
Debug.Log("Conexion al servidor no valida." + ex);
PanelException.SetActive(true);
PanelException.GetComponentInChildren <Text>().text = "Conexion al servidor no valida";
}
}
public void ObtenerCuentasEnMiSalaTest()
{
CuentaModel cuenta = new CuentaModel()
{
NombreUsuario = "WingXstar",
Contrasena = "PepitoElgrillo45",
CorreoElectronico = "*****@*****.**"
};
List <CuentaModel> expectedResut = new List <CuentaModel>();
GameService service = new GameService();
Assert.AreEqual(expectedResut, service.ObtenerCuentasEnMiSala(cuenta));
}
// GET: Cuenta/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
CuentaModel cuentaModel = _repository.Devolver(id);
if (cuentaModel == null)
{
return(HttpNotFound());
}
return(View(cuentaModel));
}
/// <summary>
/// Regresa la cuenta con todos los datos que tiene almacenada la sesion
/// </summary>
/// <param name="cuenta">CuentaModel</param>
/// <returns>La cuentaModel que contiene los datos completos de la cuenta que se le pasa como parametro</returns>
public CuentaModel ObtenerCuentaCompleta(CuentaModel cuenta)
{
CuentaModel CuentaCompleta = null;
foreach (CuentaModel cuentaLoegada in CuentasLogeadas.Keys)
{
if (cuenta.NombreUsuario == cuentaLoegada.NombreUsuario)
{
CuentaCompleta = cuentaLoegada;
break;
}
}
return(CuentaCompleta);
}
/// <summary>
/// Verifica si una cuenta ya se encuentra en la sesion
/// </summary>
/// <param name="cuenta">CuentaModel</param>
/// <returns>Verdadero si la cuenta se cuentra en la sesion, falso si no</returns>
public Boolean VerificarCuentaLogeada(CuentaModel cuenta)
{
lock (ObjetoSincronizador)
{
foreach (CuentaModel cuentaLogeada in CuentasLogeadas.Keys)
{
if (cuentaLogeada.NombreUsuario == cuenta.NombreUsuario)
{
return(true);
}
}
}
return(false);
}
/// <summary>
/// Recupera la cuenta en la lista de Jugadores en sesion que tenga el mismo nombre de usuario
/// </summary>
/// <param name="NombreUsuario">String</param>
/// <returns>La cuenta del nombre de usuario</returns>
private CuentaModel ObtenerCuentaDeNombreDeUsuario(string NombreUsuario)
{
CuentaModel CuentaAMover = null;
foreach (CuentaModel cuentaEnElDiccionario in Jugadores.Keys)
{
if (cuentaEnElDiccionario.NombreUsuario == NombreUsuario)
{
CuentaAMover = cuentaEnElDiccionario;
break;
}
}
return(CuentaAMover);
}
/// <summary>
/// Recupera la CuentaModel que se encuentra en el diccionario de jugadores a partir de una cuenta
/// </summary>
/// <param name="cuentaABuscar">CuentaModel</param>
/// <returns>La cuenta que se encuentra en el diccionario de la cuneta</returns>
private CuentaModel ObtenerCuentaDelDiccionario(CuentaModel cuentaABuscar)
{
CuentaModel cuenta = null;
foreach (CuentaModel cuentaEnElDiccionario in Jugadores.Keys)
{
if (cuentaABuscar.NombreUsuario == cuentaEnElDiccionario.NombreUsuario)
{
cuenta = cuentaEnElDiccionario;
break;
}
}
return(cuenta);
}
public void VerificarSiEstoyEnSalaTest()
{
CuentaModel cuenta = new CuentaModel()
{
NombreUsuario = "WingXstar",
Contrasena = "PepitoElgrillo45",
CorreoElectronico = "*****@*****.**"
};
bool expectedResut = false;
GameService service = new GameService();
Assert.AreEqual(expectedResut, service.VerificarSiEstoyEnSala(cuenta));
}
public void RecuperarIdDeMiSalaTest()
{
CuentaModel cuenta = new CuentaModel()
{
NombreUsuario = "WingXstar",
Contrasena = "PepitoElgrillo45",
CorreoElectronico = "*****@*****.**"
};
string expectedResut = String.Empty;
GameService service = new GameService();
Assert.AreEqual(expectedResut, service.RecuperarIdDeMiSala(cuenta));
}
public void MiSalaEsPublicaTestExito()
{
CuentaModel cuenta = new CuentaModel()
{
NombreUsuario = "WingXstar",
Contrasena = "PepitoElgrillo45",
CorreoElectronico = "*****@*****.**"
};
bool expectedResut = true;
GameService service = new GameService();
Assert.AreEqual(expectedResut, service.MiSalaEsPublica(cuenta));
}
public ActionResult Editar(CuentaModel model)
{
try
{
using (CPMEntities datos = new CPMEntities())
{
datos.sp_EditarCuenta(model.IdCuenta, model.NCuenta, model.IdBanco, model.Saldo);
}
return(Redirect("~/Cuenta/"));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// Descuenta una vida al personaje de la cuenta
/// </summary>
/// <param name="CuentaADescontarVidas">Cuenta del personaje a la que se le descontara una vida</param>
private void DescontarVida(CuentaModel CuentaADescontarVidas, int CantidadDeVidas)
{
if (CuentaADescontarVidas.Jugador.RolDelJugador == EnumTipoDeJugador.Corredor)
{
ColocarPersonajesEnPosicionInicial();
}
if (EsElJugadorPrincipal(CuentaADescontarVidas))
{
JugadorActual.DescontarVida(CantidadDeVidas);
}
else
{
ScriptsDeMovimiento[CuentaADescontarVidas].DescontarVida(CantidadDeVidas);
}
}
/// <summary>
/// Cambia el estado de la cuenta de no verificada a verificada
/// </summary>
/// <param name="Cuenta">CuentaModel</param>
/// <returns>Verdadero si la cuenta se verifico correctamente, falso si no</returns>
public Boolean VerificarCuenta(CuentaModel Cuenta)
{
using (PersistenciaContainer Persistencia = new PersistenciaContainer())
{
Cuenta CuentaAVerificar = Persistencia.CuentaSet.Where(cuentaRecuperada =>
cuentaRecuperada.Usuario == Cuenta.NombreUsuario).FirstOrDefault();
if (CuentaAVerificar != null)
{
CuentaAVerificar.Valida = true;
Persistencia.SaveChanges();
return(true);
}
return(false);
}
}
/// <summary>
/// Recupera del diccionario de listas conectadas la cuenta que tenga el mismo nombre que la parcial que se paso por parametro
/// </summary>
/// <param name="Parcial">CuentaModel</param>
/// <returns>CuentaModel</returns>
private CuentaModel ObtenerCuentaEnElDiccionario(CuentaModel Parcial)
{
lock (SincronizarObjeto)
{
foreach (CuentaModel CuentaClave in CuentasConetadas.Keys)
{
if (CuentaClave.NombreUsuario == Parcial.NombreUsuario)
{
return(CuentaClave);
}
}
}
return(null);
}
/// <summary>
/// Recupera las cuentas que estan en la sala de la cuenta
/// </summary>
/// <param name="Cuenta">CuentaModel</param>
/// <returns>Una lista con las cuentas de la sala del jugagor</returns>
public List <CuentaModel> RecuperarCuentasDeSalaDeJugador(CuentaModel Cuenta)
{
List <CuentaModel> CuentasDeLaSala;
Sala SalaDondeSeEncuentraLaCuenta = RecuperarSalaDeCuenta(Cuenta);
if (SalaDondeSeEncuentraLaCuenta != null)
{
CuentasDeLaSala = SalaDondeSeEncuentraLaCuenta.RecuperarCuentasEnLaSala();
}
else
{
CuentasDeLaSala = new List <CuentaModel>();
}
return(CuentasDeLaSala);
}
public void UnirseASalaPrivadaTest()
{
CuentaModel cuenta = new CuentaModel()
{
NombreUsuario = "WingXstar",
Contrasena = "PepitoElgrillo45",
CorreoElectronico = "*****@*****.**"
};
bool expectedResut = false;
EnumEstadoDeUnirseASala estado = EnumEstadoDeUnirseASala.NoSeEncuentraEnSesion;
GameService service = new GameService();
Assert.AreEqual(expectedResut, service.UnirseASalaPrivada("1234", cuenta));
}
public void RegistrarseTest()
{
CuentaModel cuenta = new CuentaModel()
{
NombreUsuario = "chino4",
Contrasena = "PepitoElgrillo45",
CorreoElectronico = "*****@*****.**"
};
CuentaModel expectedResut = new CuentaModel()
{
NombreUsuario = "chino4"
};
CuentaDAO cuentaDAO = new CuentaDAO();
Assert.AreEqual(expectedResut.NombreUsuario, cuentaDAO.Registrarse(cuenta).NombreUsuario);
}
public async virtual Task <IEnumerable <CuentaModel> > GetCuentas()
{
List <CuentaModel> result = new List <CuentaModel>();
foreach (ApplicationUser user in this.UserManager.Users.ToList())
{
if (user.Id == "BE75D823412D4DA9AEC6236C6CD73BF8" || user.UserName.Equals("anon", StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
CuentaModel model = await this.ToLoginModel(user);
result.Add(model);
}
return(result);
}
/// <summary>
/// Agrega una CuentaModelYaLogeada en la sesion, si esta aun no se encuentra en la sesion
/// </summary>
/// <param name="cuenta">CuentaModel</param>
/// <param name="hiloDeSeguimientoDelCliente">Thread</param>
/// <returns>Verdadeo si la cuenta se logeo correctamente, falso si no</returns>
public Boolean AgregarCuentaLogeada(CuentaModel cuenta, Thread hiloDeSeguimientoDelCliente)
{
lock (ObjetoSincronizador)
{
foreach (CuentaModel cuentaLogeada in CuentasLogeadas.Keys)
{
if (cuentaLogeada.NombreUsuario == cuenta.NombreUsuario)
{
return(false);
}
}
CuentasLogeadas.Add(cuenta, hiloDeSeguimientoDelCliente);
}
UsuarioConectado?.Invoke(cuenta);
return(true);
}
/// <summary>
/// Coloca en la cuenta en sesion la cuenta completa
/// </summary>
private void PonerCuentaEnSesionCompleta()
{
CuentaModel MiCuentaCompleta = null;
foreach (CuentaModel Cuenta in CuentasEnLaSala)
{
if (Cuenta.NombreUsuario == CuentaEnSesion.NombreUsuario)
{
MiCuentaCompleta = Cuenta;
}
}
if (MiCuentaCompleta != null)
{
Cuenta.CuentaLogeada.CuentaM = MiCuentaCompleta;
CuentaEnSesion = MiCuentaCompleta;
}
}
/// <summary>
/// Recupera la cuenta la cual envio el EventoEnJuego
/// </summary>
/// <param name="eventoEnJuego">EventoEnJuego</param>
/// <returns>La cuenta que envio el evento </returns>
private CuentaModel RecuperarCuentaDelEvento(EventoEnJuego eventoEnJuego)
{
CuentaModel cuentaDelEvento = new CuentaModel();
switch (eventoEnJuego.TipoDeEvento)
{
case EnumTipoDeEventoEnJuego.MovimientoJugador:
cuentaDelEvento.NombreUsuario = eventoEnJuego.DatosDelMovimiento.Usuario;
break;
case EnumTipoDeEventoEnJuego.MuerteJugador:
cuentaDelEvento.NombreUsuario = eventoEnJuego.DatosMuerteDeUnJugador.Usuario;
break;
}
return(cuentaDelEvento);
}
public void RegistrarseTestUsuarioExistente()
{
CuentaModel cuenta = new CuentaModel()
{
NombreUsuario = "chino",
Contrasena = "joseMiguel",
Jugador = null,
Verificado = false,
CodigoVerificacion = "",
CorreoElectronico = "*****@*****.**"
};
EnumEstadoRegistro expectedResut = EnumEstadoRegistro.UsuarioExistente;
CuentaService service = new CuentaService();
Assert.AreEqual(expectedResut, service.Registrarse(null));
}
public async Task <ActionResult> GenerarNuevaClave(string idUsuario)
{
if (this.DataService == null)
{
this.DataService = new CuentaDataService(this.GetIdentityUser(this.User.Identity.Name).Result, this.UserManager, this.RoleManager);
}
try
{
CuentaModel model = await this.DataService.CrearNewCtrña(idUsuario);
return(Json(new { newValue = model.NuevaContraseña, msg = CuentaResource.MsgCntrñGenerada }));
}
catch (Exception ex)
{
throw ex;
}
}
public void UnirseASalaTest()
{
SessionService.Servicio.SessionService ServicioSesion = new SessionService.Servicio.SessionService();
CuentaModel cuenta = new CuentaModel()
{
NombreUsuario = "hachi",
Contrasena = "hola9011",
CorreoElectronico = "*****@*****.**"
};
ServicioSesion.IniciarSesion(cuenta);
bool expectedResut = true;
GameService service = new GameService();
Assert.AreEqual(expectedResut, service.UnirseASala(cuenta));
}
/// <summary>
/// Agrega una cuenta a la lista de Cuentas en la sala y notifica a las demas cuentas en la sala
/// </summary>
/// <param name="cuenta">CuentaModel</param>
/// <param name="serviceCallback">IGameServiceCallback</param>
/// <returns>Verdadero si me pude la cuenta se unio a la sala, falso si no</returns>
public Boolean UnirseASala(CuentaModel cuenta, IGameServiceCallback serviceCallback, String DireccionIpDelCliente)
{
bool SeConectoALaSala = false;
if (NumeroJugadoresEnSala >= 5)
{
SeConectoALaSala = false;
}
lock (ObjetoParaSincronizar)
{
try
{
AsignarTipoDeJugador(cuenta);
foreach (IGameServiceCallback callback in CuentasEnLaSala.Values)
{
callback.NuevoCuentaEnLaSala(cuenta);
}
CuentasEnLaSala.Add(cuenta, serviceCallback);
DireccionesIpDeCuentas.Add(cuenta, DireccionIpDelCliente);
SeConectoALaSala = true;
}
catch (ArgumentException)
{
SeConectoALaSala = false;
}
catch (ObjectDisposedException Dispose)
{
NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
logger.Warn(Dispose.Message);
}
catch (TimeoutException Time)
{
NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
logger.Warn(Time.Message);
}
catch (CommunicationException Communication)
{
NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
logger.Warn(Communication.Message);
}
}
return(SeConectoALaSala);
}
/// <summary>
/// Notifica a las cuentas que la partida a terminado y almacena los datos del corredor
/// </summary>
/// <param name="CuentaDelCorredor">CuentaModel</param>
public void TerminarPartida(CuentaModel CuentaDelCorredor)
{
ICuentaDAO PersistenciaDeCuenta = new CuentaDAO();
try
{
PersistenciaDeCuenta.GuardarDatosDeLaCuenta(CuentaDelCorredor);
}
catch (SqlException ex)
{
NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
logger.Warn(ex.Message);
}
foreach (IGameServiceCallback callback in CuentasEnLaSala.Values)
{
callback.NotificarTerminaPartida();
}
SalaVacia?.Invoke(this);
}