/// <summary>
/// Termina la sesion de una cuenta en el servicio de chat
/// </summary>
/// <param name="Cuenta">Cuenta</param>
public void Desconectar(CuentaModel Cuenta)
{
CuentaModel CuentaCompleta = ObtenerCuentaEnElDiccionario(Cuenta);
lock (SincronizarObjeto)
{
List <CuentaModel> CuentasDeLaSala = ManejadorDeSalas.RecuperarCuentasDeSalaDeJugador((Cuenta));
foreach (CuentaModel CuentaClave in CuentasConetadas.Keys)
{
foreach (CuentaModel CuentaEnSala in CuentasDeLaSala)
{
if (CuentaClave.NombreUsuario == CuentaEnSala.NombreUsuario)
{
IChatServiceCallback Callback = CuentasConetadas[CuentaClave];
Callback.Abandonar(Cuenta);
}
}
}
if (CuentaCompleta != null)
{
CuentasConetadas.Remove(CuentaCompleta);
Cuentas.Remove(CuentaCompleta);
}
}
}
public bool AddMeToServer(string userName)
{
if (userName.Length > 15)
{
userName = userName.Substring(0, 15);
}
IChatServiceCallback callback = OperationContext.Current.GetCallbackChannel <IChatServiceCallback>();
if (!loggedInUsers.ContainsKey(userName))
{
loggedInUsers.Add(userName, callback);
SendMessage("Admin", $"User {userName} logged in...");
Console.WriteLine($"User {userName} logged in...");
return(true);
} // end of if
else
{
DuplicateUserFault fault = new DuplicateUserFault()
{
Reason = "User '" + userName + "' already logged in!"
};
throw new FaultException <DuplicateUserFault>(fault);
} // end of else
} // end of method
/// <summary>
/// Login
/// Logins the user and registers the callback into a dictionary of
/// logged in users.
/// Sends a messgae that the user has logged on...
/// </summary>
/// <param name="userName">user name from the client (string)</param>
public void Login(string userName)
{
// Trim the Username to 15 Characters
if (userName.Length > 15)
{
userName = userName.Substring(0, 15);
}
// This is the caller and registers the callback for the service to
// communicate the new messages
IChatServiceCallback callback = OperationContext.Current.GetCallbackChannel <IChatServiceCallback>();
// Validates the User is Not Already Logged In
if (!loggedInUsers.ContainsKey(userName))
{
// Add to the List of Logged on Users
loggedInUsers.Add(userName, callback);
// Send a Message that the new user is Logged In
SendMessage("Admin", $"User {userName} logged in...");
// Write to Console
Console.WriteLine($"User {userName} logged in...");
} // end of if
// Duplicate User Fault - User Logged In Already
else
{
DuplicateUserFault fault = new DuplicateUserFault()
{
Reason = "User '" + userName + "' already logged in!"
};
throw new FaultException <DuplicateUserFault>(fault);
} // end of else
} // end of method
public ChatWCFClient(string ipAddress, IChatServiceCallback callback)
{
try
{
m_ipAddress = ipAddress;
NetTcpBinding tcpBinding = new NetTcpBinding();
tcpBinding.OpenTimeout = TimeSpan.FromSeconds(5);
tcpBinding.ReceiveTimeout = TimeSpan.FromSeconds(5);
tcpBinding.SendTimeout = TimeSpan.FromSeconds(5);
tcpBinding.CloseTimeout = TimeSpan.FromSeconds(5);
tcpBinding.MaxConnections = 2000;
tcpBinding.TransactionFlow = false;
//tcpBinding.Security.Transport.ProtectionLevel = System.Net.Security.ProtectionLevel.EncryptAndSign;
//tcpBinding.Security.Transport.ClientCredentialType = TcpClientCredentialType.None;
//tcpBinding.Security.Mode = SecurityMode.Transport;
pipeFactory =
new DuplexChannelFactory <IChatService>(
new InstanceContext(callback),
tcpBinding,
new EndpointAddress("net.tcp://" + ipAddress + ":8099/ChatService"));
m_client = pipeFactory.CreateChannel();
}
catch (Exception err)
{
pipeFactory.Close();
throw (new SystemException(err.Message));
}
}
/// <summary>
/// Recorre el diccionario de CuentasModel conectados, notificando que la cuenta se ha conectado
/// </summary>
/// <param name="Cuenta">CuentaModel</param>
/// <returns>Boolean</returns>
private Boolean NotificarClientesNuevoConectado(CuentaModel Cuenta)
{
SessionManager ManejadorDeSesiones = SessionManager.GetSessionManager();
List <CuentaModel> CuentasDeSalaDeJugador = ManejadorDeSalas.RecuperarCuentasDeSalaDeJugador(Cuenta);
foreach (CuentaModel cuentaDeSala in CuentasDeSalaDeJugador)
{
foreach (CuentaModel CuentaClave in CuentasConetadas.Keys)
{
if (CuentaClave.NombreUsuario == cuentaDeSala.NombreUsuario)
{
if (ManejadorDeSesiones.VerificarCuentaLogeada(CuentaClave))
{
IChatServiceCallback Callback = CuentasConetadas[CuentaClave];
try
{
Callback.Unirse(Cuenta);
}
catch (Exception)
{
CuentasConetadas.Remove(Cuenta);
return(false);
}
}
}
}
}
return(true);
}
virtual public bool Connect(User user)
{
if (user == null || _connectedUsers.Where(u => u.Id == user.Id).FirstOrDefault() != null)
{
return(false);
}
IChatServiceCallback currentCallback = OperationContextWrapper.GetCallbackChannel <IChatServiceCallback>();
if (currentCallback == null)
{
return(false);
}
lock (syncObj)
{
_userCallbackPairs.Add(user.Id, currentCallback);
_connectedUsers.Add(user);
foreach (IChatServiceCallback callback in _userCallbackPairs.Values)
{
callback.RefreshUsers(_connectedUsers);
callback.UserConnect(user);
}
}
return(true);
}
// ako postoji (prethodna metoda) onda cemo zapamtiti grupu, korisnika i kanal
public void AddUserToGroup(string groupName, string userName, IChatServiceCallback callBack)
{
if (_groupsWithUsers.ContainsKey(groupName))
{
_groupsWithUsers[groupName].Add(userName); //zapamtimo usera
_userCallbacks[userName] = callBack; //zapamtimo kanal
}
}
public IChatService Create(ConnectionConfiguration configuration, IChatServiceCallback callbackClient)
{
IChatService channel = DuplexChannelFactory <IChatService> .CreateChannel(
new InstanceContext(callbackClient),
new NetTcpBinding(SecurityMode.None),
new EndpointAddress($"net.tcp://{configuration.ServerName}/Service.svc"));
return(channel);
}
public Guid Connect(string login)
{
Guid clientId = Guid.NewGuid();
lock (_locker)
{
_connectedClients.Add(new ChatClient(clientId, login, OperationContext.Current));
IChatServiceCallback callback = OperationContext.Current.GetCallbackChannel <IChatServiceCallback>();
callback.PushMessage(new ChatMessage {
From = "Server", Message = "Bienvenue " + login
});
}
return(clientId);
}
Guid IChatService.Subscribe()
{
IChatServiceCallback callback =
OperationContext.Current.GetCallbackChannel <IChatServiceCallback>();
Guid clientId = Guid.NewGuid();
if (callback != null)
{
lock (clients)
{
clients.Add(clientId, callback);
}
}
return(clientId);
}
public OperationResult <Person[]> Join(Person person)
{
_eventHandler = EventHandler;
var opResult = new OperationResult <Person[]>();
lock (SyncObj)
{
if (!CheckIfPersonExists(person.Name))
{
_person = person;
Persons.Add(person, EventHandler);
}
else
{
opResult.Success = false;
var em = $"Пользователь с именен {person.Name} уже в чате";
opResult.Errors.Add(new OperationError {
ErrorMessage = em
});
Logger.Error(em);
return(opResult);
}
}
_callback = OperationContext.Current.GetCallbackChannel <IChatServiceCallback>();
var e = new ChatEventArgs
{
CallbackType = CallbackType.UserEnter,
Person = _person
};
_inactiveTimer = new Timer(InactiveTimerCallback, null, _inactiveTimeout, TimeSpan.FromMilliseconds(-1));
Logger.Info("{0} зашел в чат", _person.Name);
BroadcastMessage(e);
ChatEvent += _eventHandler;
opResult.Result = new Person[Persons.Count];
lock (SyncObj)
{
Persons.Keys.CopyTo(opResult.Result, 0);
}
opResult.Success = true;
return(opResult);
}
public int JoinTheConversation(string userName)
{
// Subscribe the user to the conversation
IChatServiceCallback registeredUser = OperationContext.Current.GetCallbackChannel <IChatServiceCallback>();
if (!_callbackList.Contains(registeredUser))
{
_callbackList.Add(registeredUser);
}
_callbackList.ForEach(
delegate(IChatServiceCallback callback)
{
callback.NotifyUserJoinedTheConversation(userName);
});
_registeredUsers++;
return(_registeredUsers);
}
public int LeaveTheConversation(string userName)
{
// Unsubscribe the user from the conversation.
IChatServiceCallback registeredUser = OperationContext.Current.GetCallbackChannel <IChatServiceCallback>();
if (_callbackList.Contains(registeredUser))
{
_callbackList.Remove(registeredUser);
_registeredUsers--;
}
// Notify everyone that user has arrived.
// Use an anonymous delegate and generics to do our dirty work.
_callbackList.ForEach(
delegate(IChatServiceCallback callback)
{ callback.NotifyUserLeftTheConversation(userName); });
return(_registeredUsers);
}
public void Join(Guid key)
{
//TODO:Need to send a callback to the client to let it know that it connected successfully or make this a one way call
try
{
//Make sure the client has been authenticated
if (!Utility.Global.IsClientAuthenticated(key))
{
return;
}
//Get the call back for the client
IChatServiceCallback callback = OperationContext.Current.GetCallbackChannel <IChatServiceCallback>();
//Create a CommunicationsStore to hold information about the connected client
ChatCommunicationsStore client = new ChatCommunicationsStore(OperationContext.Current.InstanceContext, callback);
//TODO:Need to handle the client not being authenticated
client.UserAccount = Authentication.AuthenticationService.GetUserAccount(key);
if (!OperationContext.Current.IncomingMessageProperties.ContainsKey(RemoteEndpointMessageProperty.Name))
{
//This is for dev connections.
client.IPAddress = "127.0.0.1";
}
else
{
client.IPAddress = ((RemoteEndpointMessageProperty)OperationContext.Current.IncomingMessageProperties[RemoteEndpointMessageProperty.Name]).Address;
}
//TODO:May need to lock the list here for thread safety
ConnectedClients.Add(key, client);
Console.WriteLine("{0} has joined the chat service.", client.UserAccount.Nickname);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
/// <summary>
/// Notifica a las demas cuentas del mensaje enviado
/// </summary>
/// <param name="Mensaje">Message</param>
public void EnviarMensaje(Message Mensaje)
{
List <CuentaModel> CuentasEnSala = ManejadorDeSalas.RecuperarCuentasDeSalaDeJugador(Mensaje.Remitente);
Debug.WriteLine(CuentasEnSala.Count);
lock (SincronizarObjeto)
{
foreach (CuentaModel CuentaEnSala in CuentasEnSala)
{
foreach (CuentaModel CuentaClave in CuentasConetadas.Keys)
{
if (CuentaEnSala.NombreUsuario == CuentaClave.NombreUsuario)
{
Debug.WriteLine("Se esta notificando a " + CuentaClave.NombreUsuario);
IChatServiceCallback callback = CuentasConetadas[CuentaClave];
callback.RecibirMensaje(Mensaje);
}
}
}
}
}
public void RegisterToChat(string userName)
{
if (userName != null && userName != "")
{
try
{
IChatServiceCallback callback =
OperationContext.Current.GetCallbackChannel <IChatServiceCallback>();
lock (locker)
{
//remove the old client
if (chatUsers.Keys.Contains(userName))
{
chatUsers.Remove(userName);
}
chatUsers.Add(userName, callback);
}
}
catch (Exception ex)
{
}
}
}
} // end of method
/// <summary>
/// SendMessageToUsers
/// Transmit to Registered Users & Callbacks
/// Logs off any disconnected clients
/// </summary>
/// <param name="message">The message to send to all clients (ChatMessage)</param>
private void SendMessageToUsers(ChatMessage message)
{
// Inform all of the clients of the new message
List <string> callbackKeys = loggedInUsers?.Keys.ToList();
// Loops through each logged in user
foreach (string key in callbackKeys)
{
try
{
IChatServiceCallback callback = loggedInUsers[key];
callback.SendClientMessage(message);
Console.WriteLine($"Sending user {key} message {message}");
}
// catches an issue with a user disconnect and loggs off that user
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message, System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Namespace + "." + System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name);
// Remove the disconnected client
Logoff(key);
}
} // end of foreach
} // end of method
/// <summary>
/// 用户登入
/// </summary>
/// <param name="username">用户名</param>
/// <param name="isOfficial">一个布尔值 标识用户是否以官方身份登入</param>
/// <param name="callback">客户端回调</param>
public void SetIn(string username, bool isOfficial, IChatServiceCallback callback)
{
UserTokenAndCallback t = GetUser(username);
t.Token.SetIn(isOfficial);
t.Callback = callback;
Tokens.Where(x => x.Token.UID.ToString() == t.Token.PID
|| x.Token.PID == t.Token.UID.ToString()
|| x.Token.IsOfficial)
.ToList()
.ForEach(x =>
{
CallStatusChanged(x, username, UserOnlineStatus.在线);
});
}
public ChatServiceClient(IChatServiceCallback callback) :
this(new System.ServiceModel.InstanceContext(callback), Const.ChatServiceName)
{
}
public ChatServiceClient(IChatServiceCallback callback) :
this(new System.ServiceModel.InstanceContext(callback), Const.ChatServiceName)
{
}
public ChatServiceProxy(IChatServiceCallback callbackInstance, Uri address)
: base(callbackInstance, address)
{
}
public ChatCommunicationsStore(InstanceContext instanceContext, IChatServiceCallback callback)
{
this.InstanceContext = instanceContext;
this.Callback = callback;
}
