/// <summary>
/// Removes the connection between the two user of frienship and updates the friend list of the both users.
/// </summary>
/// <param name="sender"></param>
/// <param name="receiver"></param>
public void RemoveFriend(string sender, string receiver)
{
UserInformation _Sender = Subscriber.getUser(sender);
UserInformation _Receiver = Subscriber.getUser(receiver);
using (DataBaseContainer context = new DataBaseContainer())
{
User Sender = context.Users.ToList().Find(x => x.Username == sender);
User Receiver = context.Users.ToList().Find(x => x.Username == receiver);
History history = context.Histories.ToList().Find(x => x.User == Sender && x.User1 == Receiver || x.User == Receiver && x.User1 == Sender);
Sender.Histories.Remove(history);
Sender.Histories1.Remove(history);
Receiver.Histories.Remove(history);
Receiver.Histories1.Remove(history);
context.Histories.Remove(history);
context.SaveChanges();
}
if (_Sender != null)
{
_Sender.CommunicationCallback.FriendRemoved(receiver);
}
if (_Receiver != null)
{
_Receiver.CommunicationCallback.FriendRemoved(sender);
}
}
/// <summary>
/// Creates a friend request.
/// </summary>
/// <param name="username">The username of the friend</param>
public void AddFriend(string username)
{
IClientCallback clientCallback = OperationContext.Current.GetCallbackChannel <IClientCallback>();
using (DataBaseContainer context = new DataBaseContainer())
{
User user = context.Users.ToList().Find(x => x.Username == username);
UserInformation clientRequest = Subscriber.subscribers.ToList().Find(x => x.CommunicationCallback == clientCallback);
User sender = context.Users.ToList().Find(x => x.Username == clientRequest.Username);
Request request = new Request();
request.FromUserId = sender.IdUser;
request.FromUsername = sender.Username;
request.User = user;
user.Requests.Add(request);
context.SaveChanges();
UserInformation _user = Subscriber.subscribers.Find(x => x.Username == user.Username);
if (_user != null)
{
_user.ScreenShareCallback.SendFriendNotification(sender.Username, sender.UserAvatar.Image);
}
}
}
/// <summary>
/// Login
/// </summary>
/// <param name="username"></param>
/// <param name="password"></param>
/// <returns></returns>
public bool Login(string username, string password)
{
if (Subscriber.subscribers.Exists(x => x.Username == username))
{
return(false);
}
using (DataBaseContainer context = new DataBaseContainer())
{
User user = context.Users.ToList().Find(x => x.Username == username && x.Password == password);
if (user != null)
{
user.Status = 1;
foreach (var client in Subscriber.subscribers)
{
if (client.IsFriendWith(username))
{
client.CommunicationCallback.SendNotification(username);
}
}
context.SaveChanges();
return(true);
}
}
return(false);
}
/// <summary>
/// Removes the user from the active users in the server and updates the friend list with users who are friends with him.
/// </summary>
/// <returns></returns>
public bool Logout()
{
try
{
IClientCallback callback = OperationContext.Current.GetCallbackChannel <IClientCallback>();
UserInformation user = Subscriber.subscribers.Find(x => x.CommunicationCallback == callback);
Subscriber.Unsubscribe(callback);
foreach (UserInformation client in Subscriber.subscribers)
{
if (client.IsFriendWith(user.Username) && user.CommunicationCallback != client.CommunicationCallback)
{
client.CommunicationCallback.UpdateListOfContacts(user.Username);
}
}
using (DataBaseContainer context = new DataBaseContainer())
{
User client = context.Users.ToList().Find(x => x.Username == user.Username);
client.Status = 0;
context.SaveChanges();
}
return(true);
}
catch
{
return(false);
}
}
/// <summary>
/// Creates an account.
/// </summary>
/// <param name="username"></param>
/// <param name="password"></param>
/// <param name="email"></param>
/// <returns></returns>
public int SignUp(string username, string password, string email)
{
using (DataBaseContainer context = new DataBaseContainer())
{
if (context.Users.ToList().Exists(x => x.Username == username))
{
return(1);
}
if (context.Users.ToList().Exists(x => x.Email == email))
{
return(2);
}
User user = new User();
user.Username = username;
user.Password = password;
user.Email = email;
user.Status = 0;
try
{
context.Users.Add(user);
context.SaveChanges();
return(0);
}
catch
{
return(3);
}
}
}
/// <summary>
/// Obtiene los 100 jugadores con más victorias de la base de datos.
/// </summary>
/// <returns>
/// Lista con los 100 jugadores con más victorias.
/// Si hay una excepción con la base de datos regresa una lista vacía.
/// </returns>
public List <Jugador> ObtenerJugadoresVictorias()
{
List <Jugador> listaJugadores = new List <Jugador>();
try {
using (var baseDatos = new DataBaseContainer()) {
var jugadoresVictorias = (from jugadorBaseDatos in baseDatos.JugadorSet orderby jugadorBaseDatos.Estadisticas.victorias descending select jugadorBaseDatos).Take(100).ToList();
foreach (var jugador in jugadoresVictorias)
{
listaJugadores.Add(new Jugador {
NombreUsuario = jugador.nombreUsuario,
Contrasenia = jugador.contrasenia,
CorreoElectronico = jugador.correoElectronico,
Codigo = jugador.codigo,
Estadisticas = new Estadisticas {
Puntos = jugador.Estadisticas.puntos,
Victorias = jugador.Estadisticas.victorias,
}
});
}
}
} catch (EntityException) {
listaJugadores = new List <Jugador>();
}
return(listaJugadores);
}
/// <summary>
/// Decline friend request.
/// </summary>
/// <param name="username"></param>
public void DeclineFriendRequest(string username)
{
using (DataBaseContainer context = new DataBaseContainer())
{
Request request = context.Requests.ToList().Find(x => x.FromUsername == username);
context.Requests.Remove(request);
context.SaveChanges();
}
}
/// <summary>
/// Checks if the user exists.
/// </summary>
/// <param name="username"></param>
/// <returns></returns>
public bool CheckUserExistance(string username)
{
using (DataBaseContainer context = new DataBaseContainer())
{
if (context.Users.ToList().Exists(x => x.Username == username))
{
return(true);
}
return(false);
}
}
/// <summary>
/// Check if the two user are friends.
/// </summary>
/// <param name="sender"></param>
/// <param name="friend"></param>
/// <returns></returns>
public bool IsFriendWith(string sender, string friend)
{
using (DataBaseContainer context = new DataBaseContainer())
{
User Sender = context.Users.ToList().Find(x => x.Username == sender);
User Friend = context.Users.ToList().Find(x => x.Username == friend);
bool exist = context.Histories.ToList().Exists(x => (x.User == Sender && x.User1 == Friend) || (x.User == Friend && x.User1 == Sender));
return(exist);
}
}
/// <summary>
/// Updates the profile information in the data base.
/// </summary>
/// <param name="username"></param>
/// <param name="email"></param>
/// <param name="password"></param>
/// <param name="image"></param>
public void UpdateProfile(string username, string email, string password, byte[] image)
{
using (DataBaseContainer context = new DataBaseContainer())
{
User user = context.Users.ToList().Find(x => x.Username == username);
user.Email = email;
user.Password = password;
UserAvatar avatar = new UserAvatar();
avatar.Image = image;
user.UserAvatar = avatar;
context.SaveChanges();
}
}
/// <summary>
/// Returs an array of bytes[] of the image of the "username".
/// </summary>
/// <param name="username"></param>
/// <returns></returns>
public byte[] GetAvatarImage(string username)
{
byte[] image;
using (DataBaseContainer context = new DataBaseContainer())
{
User user = context.Users.ToList().Find(x => x.Username == username);
if (user != null && user.UserAvatar != null)
{
image = user.UserAvatar.Image;
return(image);
}
return(null);
}
}
public void AddPlayer(Player player)
{
DataBaseContainer dataBase = new DataBaseContainer();
dataBase.PlayerSet.Add(new DataAccess.Player {
userName = player.UserName,
password = player.Password,
email = player.Email,
score = "0",
});
dataBase.SaveChanges();
dataBase.Dispose();
Console.WriteLine(player.UserName);
}
private static void test()
{
using (DataBaseContainer context = new DataBaseContainer())
{
foreach (Request user in context.Requests)
{
Console.WriteLine(user.FromUsername + " to " + user.User.Username);
if (user.User.Username == "Andrei")
{
context.Requests.Remove(user);
}
}
context.SaveChanges();
}
}
/// <summary>
/// Modifica el código de verificación de un jugador en la base de datos.
/// </summary>
/// <param name="codigoVerificacion">
/// Código de verificación del jugador.
/// </param>
/// <param name="nuevoCodigoVerificacion">
/// Nuevo código de verificación.
/// </param>
/// <returns>
/// Valor boolean que es True si modificó el código del jugador y es False si ocurrió una excepción con la base de datos.
/// </returns>
public Boolean ModificarCodigo(String codigoVerificacion, String nuevoCodigoVerificacion)
{
Boolean exito = true;
try {
using (var baseDatos = new DataBaseContainer()) {
var jugador = (from jugadorBaseDatos in baseDatos.JugadorSet where jugadorBaseDatos.codigo == codigoVerificacion select jugadorBaseDatos).ToList();
jugador.ElementAt(0).codigo = nuevoCodigoVerificacion;
baseDatos.SaveChanges();
}
} catch (EntityException) {
exito = false;
}
return(exito);
}
public bool FindPlayer(String userName, String email)
{
using (DataBaseContainer dataBase = new DataBaseContainer()) {
var playerFinded = dataBase.PlayerSet.Where(player => player.userName == userName ||
player.email == email).Count();
if (playerFinded > 0)
{
return(false);
}
else
{
return(true);
}
}
}
public bool LogIn(String userName, String password)
{
using (DataBaseContainer dataBase = new DataBaseContainer()) {
var playerFinded = dataBase.PlayerSet.Where(player => player.userName == userName &&
player.password == password).Count();
if (playerFinded > 0)
{
return(true);
}
else
{
return(false);
}
}
}
/// <summary>
/// Modifica las estadísticas de un jugador en la base de datos.
/// </summary>
/// <param name="nombreUsuario">
/// Nombre de usuario del jugador al que se le modificaran sus estadísticas.
/// </param>
/// <param name="puntos">
/// Nuevos puntos del jugador.
/// </param>
/// <param name="victorias">
/// Nuevas victorias del jugador.
/// </param>
/// <returns>
/// Valor boolean que es True si modificó las estadísticas del jugador y es False si ocurrió una excepción con la base de datos.
/// </returns>
public Boolean ModificarEstadisticas(String nombreUsuario, Int16 puntos, Int16 victorias)
{
Boolean exito = true;
try {
using (var baseDatos = new DataBaseContainer()) {
var jugador = (from jugadorBaseDatos in baseDatos.JugadorSet where jugadorBaseDatos.nombreUsuario == nombreUsuario select jugadorBaseDatos).ToList();
jugador.ElementAt(0).Estadisticas.puntos = puntos;
jugador.ElementAt(0).Estadisticas.victorias = victorias;
baseDatos.SaveChanges();
}
} catch (EntityException) {
exito = false;
}
return(exito);
}
/// <summary>
/// Busca un jugador en la base de datos por el correo electrónico.
/// </summary>
/// <param name="correoElectronico">
/// Correo electrónico con el que se buscará al jugador en la base de datos.
/// </param>
/// <returns>
/// Objeto jugador con los datos del jugador que se encontró en la base de datos.
/// Si no se encuentra un jugador con ese correo regresa un jugador con datos vacios.
/// Si hay una excepción con la base de datos regresa al jugador con un * en su nombre de usuario.
/// </returns>
public Jugador ObtenerJugadorPorCorreo(String correoElectronico)
{
Jugador jugadorEncontrado;
try {
using (var baseDatos = new DataBaseContainer()) {
var jugador = (from jugadorBaseDatos in baseDatos.JugadorSet where jugadorBaseDatos.correoElectronico == correoElectronico select jugadorBaseDatos).ToList();
jugadorEncontrado = CrearJugador(jugador);
}
} catch (EntityException) {
jugadorEncontrado = new Jugador {
NombreUsuario = "*",
};
}
return(jugadorEncontrado);
}
/// <summary>
/// Valida si un código de verificación no existe en la base de datos con algún jugador ya registrado.
/// </summary>
/// <param name="codigoVerificacion">
/// Código de verificación a validar.
/// </param>
/// <returns>
/// Valor entero que es 0 si el código está disponible, es 1 si el código ya está ocupado y es 3 si ocurrió una excepción con la base de datos.
/// </returns>
public int ValidarCodigo(String codigoVerificacion)
{
int validar = 0;
try {
using (var baseDatos = new DataBaseContainer()) {
var jugador = (from jugadorBaseDatos in baseDatos.JugadorSet where jugadorBaseDatos.codigo == codigoVerificacion select jugadorBaseDatos).ToList();
if (jugador.Count == 1)
{
validar = 1;
}
}
} catch (EntityException) {
validar = 2;
}
return(validar);
}
public bool IsFriendWith(string friendUsername)
{
using (DataBaseContainer context = new DataBaseContainer())
{
User user = context.Users.ToList().Find(x => x.Username == Username);
User friend = context.Users.ToList().Find(x => x.Username == friendUsername);
History history = user.Histories.ToList().Find(x => x.User == friend || x.User1 == friend);
History history1 = user.Histories1.ToList().Find(x => x.User == friend || x.User1 == friend);
if (history != null || history1 != null)
{
return(true);
}
return(false);
}
}
/// <summary>
/// Verifica los datos de un jugador para iniciar sesión corresponde a un jugador en la base de datos.
/// </summary>
/// <param name="nombreUsuario">
/// Nombre de usuario con el que se quiere iniciar sesión.
/// </param>
/// <param name="contrasenia">
/// Contraseña con la que se quiere iniciar sesión.
/// </param>
/// <returns>
/// Objeto jugador con los datos del jugador cuando los datos son correctos.
/// Si los datos no corresponden regresa al jugador con datos vacios.
/// Si hay una excepción con la base de datos regresa al jugador con un * en su nombre de usuario.
/// </returns>
public Jugador IniciarSesion(String nombreUsuario, String contrasenia)
{
Jugador jugadorEncontrado;
try {
using (var baseDatos = new DataBaseContainer()) {
var jugador = (from jugadorBaseDatos in baseDatos.JugadorSet where jugadorBaseDatos.nombreUsuario == nombreUsuario
where jugadorBaseDatos.contrasenia == contrasenia select jugadorBaseDatos).ToList();
jugadorEncontrado = CrearJugador(jugador);
}
} catch (EntityException) {
jugadorEncontrado = new Jugador {
NombreUsuario = "*",
};
}
return(jugadorEncontrado);
}
/// <summary>
/// Gets friend notification from the server.
/// </summary>
public void GetNotifications()
{
IClientCallback callback = OperationContext.Current.GetCallbackChannel <IClientCallback>();
UserInformation user = Subscriber.subscribers.Find(x => x.CommunicationCallback == callback);
using (DataBaseContainer context = new DataBaseContainer())
{
foreach (Request request in context.Requests)
{
if (request.User.Username == user.Username)
{
User friend = context.Users.ToList().Find(x => x.Username == request.FromUsername);
user.ScreenShareCallback.SendFriendNotification(request.FromUsername, friend.UserAvatar.Image);
}
}
}
}
public int IniciarSesion(string usuario, string contrasenia)
{
using (DataBaseContainer database = new DataBaseContainer()) {
int usuarioEncontrado = database.CuentaSet.Where(u => u.Usuario == matriculaIngresada && u.Contrasenia == contraseniaIngresada).Count();
if (usuarioEncontrado > 0)
{
Window1 ventanaEE = new Window1();
ventanaEE.Show();
this.Close();
}
else
{
MessageBox.Show("Usuario y/o contraseña incorrectos");
}
}
return(1);
}
/// <summary>
/// Returns a dictionary with the name as key and 1 or 0 as status. 1 = online 0 = offline
/// </summary>
/// <returns></returns>
public Dictionary <string, int> GetFriendList()
{
Dictionary <string, int> contacts = new Dictionary <string, int>();
IClientCallback clientCallback = OperationContext.Current.GetCallbackChannel <IClientCallback>();
UserInformation client = Subscriber.subscribers.Find(x => x.CommunicationCallback == clientCallback);
using (DataBaseContainer context = new DataBaseContainer())
{
foreach (User u in context.Users)
{
if (client.IsFriendWith(u.Username) && u.Username != client.Username)
{
contacts.Add(u.Username, (int)u.Status);
}
}
}
return(contacts);
}
/// <summary>
/// Accepts friend request and updates the friend list.
/// </summary>
/// <param name="username"></param>
public void AcceptFriendRequest(string username)
{
using (DataBaseContainer context = new DataBaseContainer())
{
Request request = context.Requests.ToList().Find(x => x.FromUsername == username);
User sender = context.Users.ToList().Find(x => x.IdUser == request.FromUserId);
User receiver = context.Users.ToList().Find(x => x.IdUser == request.User.IdUser);
History history = new History();
history.User = sender;
history.User1 = receiver;
history.Conversation = "";
sender.Histories.Add(history);
receiver.Histories1.Add(history);
context.Requests.Remove(request);
context.SaveChanges();
UserInformation _sender = Subscriber.subscribers.Find(x => x.Username == sender.Username);
UserInformation _receiver = Subscriber.subscribers.Find(x => x.Username == receiver.Username);
bool statusSender = false, statusReceiver = false;
if (receiver.Status == 1)
{
statusReceiver = true;
}
if (sender.Status == 1)
{
statusSender = true;
}
if (_sender != null)
{
_sender.CommunicationCallback.AddFriendInFriendList(receiver.Username, receiver.UserAvatar.Image, statusReceiver);
}
if (_receiver != null)
{
_receiver.CommunicationCallback.AddFriendInFriendList(sender.Username, sender.UserAvatar.Image, statusSender);
}
}
}
private async Task getDataAsync()
{
if (_dbContainer.Categories != null || _dbContainer.Costs != null)
{
OnDataLoaded(null);
return;
}
StorageFile fileDataBase = null;
var jsonSerializer = new DataContractJsonSerializer(typeof(DataBaseContainer));
try
{
fileDataBase = await ApplicationData.Current.LocalFolder.GetFileAsync(fileName);
}
catch (FileNotFoundException)
{
fileExists = false;
}
if (!fileExists)
{
Uri dataUri = new Uri(uriName);
fileDataBase = await StorageFile.GetFileFromApplicationUriAsync(dataUri);
}
try
{
using (var stream = await fileDataBase.OpenStreamForReadAsync())
{
_dbContainer = (DataBaseContainer)jsonSerializer.ReadObject(stream);
IsDataLoaded = true;
}
}
catch
{
_dbContainer = new DataBaseContainer();
}
OnDataLoaded(null);
}
/// <summary>
/// Returns profile information.
/// </summary>
/// <param name="username"></param>
public void GetInformation(string username)
{
IClientCallback callback = OperationContext.Current.GetCallbackChannel <IClientCallback>();
UserInformation client = Subscriber.subscribers.Find(x => x.CommunicationCallback == callback);
using (DataBaseContainer context = new DataBaseContainer())
{
User user = context.Users.ToList().Find(x => x.Username == username);
if (user != null)
{
if (user.UserAvatar != null)
{
client.ScreenShareCallback.SendProfileInformation(user.Password, user.Email, user.UserAvatar.Image);
}
else
{
client.ScreenShareCallback.SendProfileInformation(user.Password, user.Email, null);
}
}
}
}
/// <summary>
/// Registra a un jugador en la base de datos.
/// </summary>
/// <param name="jugador">
/// Objeto jugador que se quiere registrar en la base de datos.
/// </param>
/// <returns>
/// Valor boolean regresa True si registra al jugador, si ocurre una excepción con la base de datos regresa False.
/// </returns>
public Boolean RegistrarJugador(Jugador jugador)
{
Boolean exito = true;
DataBaseContainer baseDatos = new DataBaseContainer();
baseDatos.JugadorSet.Add(new DataAccess.Jugador {
nombreUsuario = jugador.NombreUsuario,
contrasenia = jugador.Contrasenia,
correoElectronico = jugador.CorreoElectronico,
codigo = jugador.Codigo,
Estadisticas = new DataAccess.Estadisticas {
puntos = jugador.Estadisticas.Puntos,
victorias = jugador.Estadisticas.Victorias,
},
});
try {
baseDatos.SaveChanges();
} catch (EntityException) {
exito = false;
}
return(exito);
}
