public ActionResult <ChatConnection> getMyConnectionId()
{
int?userId = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (userId == null)
{
return(Unauthorized(new ErrorMessageModel("Utilizador não tem autorização ou não existe!")));
}
try
{
ChatDAO chatDao = new ChatDAO(_connection);
ChatConnection connect = chatDao.GetChatConnectionFromUserId((int)userId);
if (connect != null)
{
return(Ok(connect));
}
return(BadRequest(new ErrorMessageModel("Não existe connection ID!")));
}
catch (Exception e)
{
return(BadRequest(new ErrorMessageModel(e.Message)));
}
}
public void RemoveConnection(ChatConnection chatConn)
{
if (ChatConnections.Contains(chatConn))
{
lock (_lock) ChatConnections.Remove(chatConn);
}
}
public void AddConnection(ChatConnection conn)
{
if (!ChatConnections.Contains(conn))
{
lock (_lock) ChatConnections.Add(conn);
}
}
public override async Task OnConnected()
{
var userName = Context.User.Identity.Name;
var connecionId = Context.ConnectionId;
var chatConnection = new ChatConnection
{
UserId = Context.User.Identity.GetUserId(),
UserName = userName,
ConnectionId = connecionId,
Connected = true,
ConnectedOn = DateTime.Now,
UserAgent = Context.Request.Headers["User-Agent"]
};
var dbContext = ApplicationDbContext.Create();
dbContext.ChatConnection.Add(chatConnection);
await dbContext.SaveChangesAsync();
Clients.AllExcept(connecionId).userConnected(userName, connecionId);
//Clients.All.userConnected(userName, connecionId);
await base.OnConnected();
}
/// <summary>
/// Método para obter os dados da conexão,
/// usando o id do utilizador como parametro
/// </summary>
/// <param name="userId">Id de utilizador</param>
/// <returns>Retorna um objeto ChatConnection</returns>
public ChatConnection GetChatConnectionFromUserId(int userId)
{
try
{
ChatConnection connect = null;
using (SqlCommand cmd = _connection.Fetch().CreateCommand())
{
cmd.CommandType = CommandType.Text;
cmd.CommandText = "SELECT * FROM dbo.[ChatConnections] " +
"WHERE UserId=@id";
cmd.Parameters.Add("@id", SqlDbType.Int).Value = userId;
using (SqlDataReader reader = cmd.ExecuteReader())
{
if (reader.HasRows)
{
connect = new ChatConnection();
reader.Read();
connect.UserId = reader.GetInt32(0);
connect.Connection = reader.GetString(1);
}
}
}
return(connect);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public IHttpActionResult InviteToChat(int chatId, int userId)
{
if (!HasValidCookie)
{
return(Unauthorized());
}
var chatConnections = DBContext.GetChatConnectionsByUserId(CurrentUserId);
var currentConnections = DBContext.GetChatConnectionsByUserId(userId);
if (!chatConnections.Any(i => i.ChatId == chatId))
{
return(BadRequest());
}
if (currentConnections.Any(i => i.ChatId == chatId))
{
return(BadRequest());
}
ChatConnection chatConnection = new ChatConnection {
ChatId = chatId, Status = ConnectionStatus.Invited, UserId = userId
};
chatConnection.UpdatedAt = System.DateTime.UtcNow;
chatConnection.UpdatedBy = CurrentUserId;
chatConnection.CreatedAt = System.DateTime.UtcNow;
chatConnection.CreatedBy = CurrentUserId;
return(Ok(ToJsonString(DBContext.CreateChatRequest(chatConnection))));
}
public async Task AddToGroup(string groupName)
{
var user = _dbcontext.UserProfile.FirstOrDefault(u => u.Email == groupName);
var conn = _dbcontext.ChatConnection.FirstOrDefault(c => c.ConnectionOwnerId == user.Id);
if (conn == null)
{
var nConn = new ChatConnection()
{
ConnectionOwnerId = user.Id,
IsConnected = true,
LastEnter = DateTime.Now,
LastLeave = null,
GroupId = user.GroupId
};
_dbcontext.ChatConnection.Add(nConn);
}
else
{
conn.IsConnected = true;
conn.LastEnter = DateTime.Now;
_dbcontext.ChatConnection.Update(conn);
}
_dbcontext.SaveChanges();
await Groups.AddToGroupAsync(Context.ConnectionId, groupName);
}
private void PrivateMessageCommand(IDictionary <string, object> command)
{
var sender = command.Get(Constants.Arguments.Character);
if (!CharacterManager.IsOnList(sender, ListKind.Ignored))
{
if (ChatModel.CurrentPms.FirstByIdOrNull(sender) == null)
{
channels.AddChannel(ChannelType.PrivateMessage, sender);
}
channels.AddMessage(command.Get(Constants.Arguments.Message), sender, sender);
var temp = ChatModel.CurrentPms.FirstByIdOrNull(sender);
if (temp == null)
{
return;
}
temp.TypingStatus = TypingStatus.Clear; // webclient assumption
}
else
{
ChatConnection.SendMessage(
new Dictionary <string, object>
{
{ Constants.Arguments.Action, Constants.Arguments.ActionNotify },
{ Constants.Arguments.Character, sender },
{ Constants.Arguments.Type, Constants.ClientCommands.UserIgnore }
});
}
}
public override IChatClient CreateConnection()
{
ChatConnection connection = ChatConnection.InstanceContext;
connection.SetConnection(this);
return((IChatClient) new ChatClientManager(connection));
}
/// <summary>
/// Método que adciona uma mensagem a um chat com um ID específico
/// </summary>
/// <param name="targetConnectionId">Connection Id do utilizador destinatario do chat</param>
/// <param name="senderConnectionId">Connection Id do utilizador remetente do chat</param>
/// <param name="messageText">Mensagem</param>
/// <param name="time">Data e hora da mensagem</param>
/// <param name="targetId">Id do destinatário do chat</param>
/// <returns> true caso seja adicionada a mensagem a DB falso caso contrario</returns>
public bool AddMessage(string targetConnectionId, string senderConnectionId,
string messageText, DateTime time, int targetId)
{
try
{
ChatConnection senderConnection = GetChatConnectionFromConnectionId(senderConnectionId);
ChatConnection targetConnection;
int? chatId;
if (targetConnectionId == null)
{
chatId = getChatIdWithTargetUser(senderConnection.UserId, targetId);
}
else
{
targetConnection = GetChatConnectionFromConnectionId(targetConnectionId);
chatId = getChatIdWithTargetUser(senderConnection.UserId, targetConnection.UserId);
}
if (chatId == null)
{
throw new Exception("Nao existe chat para as duas connections dadas!");
}
Message message = new Message();
message.ChatId = (int)chatId;
message.MessageSend = messageText;
message.SenderId = senderConnection.UserId;
message.Time = time;
bool returnValue = false;
if (message.MessageSend != null)
{
using (SqlCommand cmd = _connection.Fetch().CreateCommand())
{
cmd.CommandType = CommandType.Text;
{
cmd.CommandText = "INSERT INTO dbo.Message(ChatId, Message, SenderId, Time) " +
"VALUES(@chatId, @msg, @senderId, @time); SELECT @@Identity";
cmd.Parameters.Add("@chatId", SqlDbType.Int).Value = message.ChatId;
cmd.Parameters.Add("@msg", SqlDbType.NVarChar).Value = message.MessageSend;
cmd.Parameters.Add("@senderId", SqlDbType.Int).Value = message.SenderId;
cmd.Parameters.Add("@time", SqlDbType.DateTime).Value = message.Time;
cmd.ExecuteScalar();
returnValue = true;
}
}
}
return(returnValue);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
private void LoginCommand(IDictionary <string, object> command)
{
ChatModel.ClientUptime = DateTimeOffset.Now;
ChatConnection.SendMessage(Constants.ClientCommands.SystemUptime);
Dispatcher.Invoke(() => ChatModel.IsAuthenticated = true);
const string nojoinName = "nojoin";
if ((!File.Exists(nojoinName) || ApplicationSettings.SavedChannels.Count == 0) &&
ApplicationSettings.SlimCatChannelId != null)
{
ApplicationSettings.SavedChannels.Add(ApplicationSettings.SlimCatChannelId);
SettingsService.SaveApplicationSettingsToXml(ChatModel.CurrentCharacter.Name);
File.Create(nojoinName);
}
// auto join
var waitTimer = new Timer(200);
var channelsId =
rejoinChannelList.Count == 0 ? ApplicationSettings.SavedChannels : rejoinChannelList;
var channels = channelsId
.Where(x => !string.IsNullOrWhiteSpace(x))
.Distinct()
.Select(x => new { channel = x });
var walk = channels.GetEnumerator();
if (walk.MoveNext())
{
waitTimer.Elapsed += (s, e) =>
{
Log("Auto joining " + walk.Current);
autoJoinedChannels.Add(walk.Current.channel);
ChatConnection.SendMessage(walk.Current, Constants.ClientCommands.ChannelJoin);
if (walk.MoveNext())
{
return;
}
waitTimer.Stop();
waitTimer.Dispose();
};
}
var currentCharacter = ChatModel.CurrentCharacter;
if (currentCharacter.Status != StatusType.Online ||
!string.IsNullOrWhiteSpace(currentCharacter.StatusMessage))
{
Events.SendUserCommand("status",
new[] { currentCharacter.Status.ToString(), currentCharacter.StatusMessage });
}
waitTimer.Start();
}
public ChatConnectionResponse CreateChatRequest(ChatConnection chatConnection)
{
using (var db = new DatabaseContext())
{
db.ChatConnections.Add(chatConnection);
db.SaveChanges();
}
return(GetChatConnectionsResponse(chatConnection));
}
public MeChat()
{
Filer = new Filer();
MediaCenter = new MediaCenter();
Connection = new ChatConnection();
this.Config = new Config();
FriendProfileHost = new FriendProfileHost(this);
UserProfileHost = new UserProfileHost(this, FriendProfileHost.FriendProfiles);
TalkDataHost = new TalkDataHost(this);
}
private void UpdateConnection(ChatConnection conn)
{
if (this.Dispatcher.CheckAccess())
{
_conn = conn;
}
else
{
this.Dispatcher.Invoke(new Action <ChatConnection>(UpdateConnection), conn);
}
}
public void BroadcastMessage(ChatConnection cc, Message msg)
{
if (msg != null && String.IsNullOrEmpty(msg.Content))
{
foreach (ChatConnection chatConn in chatConnectionManager.ChatConnections)
{
if (chatConn.MemberInfo != null && chatConn != cc)
{
SendMessage(msg, chatConn.Socket.Client);
}
}
}
}
public ChatHub(
IUserService userService,
IViewRenderService renderService,
ChatConnection chatConnection,
IChatService chatService,
IUnitOfWork unitOfWork
)
{
_userService = userService;
_renderService = renderService;
_chatConnection = chatConnection;
_chatService = chatService;
_unitOfWork = unitOfWork;
}
private static ChatConnectionResponse GetChatConnectionsResponse(ChatConnection chatConnection)
{
return(new ChatConnectionResponse
{
ChatId = chatConnection.ChatId,
Id = chatConnection.Id,
UserId = chatConnection.UserId,
Status = chatConnection.Status,
CreatedBy = chatConnection.CreatedBy,
CreatedAt = chatConnection.CreatedAt,
UpdatedAt = chatConnection.UpdatedAt,
UpdatedBy = chatConnection.UpdatedBy
});
}
public void CanUpdateChatHubConnectionTest()
{
IEmployerDAO <Employer> EmployerDAO = new EmployerDAO(_connection);
Employer testEmployer = new Employer();
testEmployer.FirstName = "Marcelo";
testEmployer.LastName = "Carvalho";
testEmployer.UserName = "******";
testEmployer.Password = "******";
testEmployer.Email = "*****@*****.**";
testEmployer.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testEmployer.Address = "Lixa";
Employer returned = EmployerDAO.Create(testEmployer);
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
Mate testMate = new Mate();
testMate.FirstName = "Miguel";
testMate.LastName = "Dev";
testMate.UserName = "******";
testMate.Password = "******";
testMate.Email = "*****@*****.**";
testMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testMate.Address = "Figueiró";
testMate.Categories = new[] { Categories.CLEANING, Categories.PLUMBING };
testMate.Rank = Ranks.SUPER_MATE;
testMate.Range = 20;
Mate returnedMate = MateDAO.Create(testMate);
ChatDAO chatDao = new ChatDAO(_connection);
chatDao.AddChatHubConnection(returned.Id, "connection1");
chatDao.AddChatHubConnection(returnedMate.Id, "connection2");
chatDao.UpdateChatHubConnection(returned.Id, "connection1Replaced");
chatDao.UpdateChatHubConnection(returnedMate.Id, "connection2Replaced");
ChatConnection connection1 = chatDao.GetChatConnectionFromUserId(returned.Id);
ChatConnection connection2 = chatDao.GetChatConnectionFromUserId(returnedMate.Id);
Assert.Equal("connection1Replaced", connection1.Connection);
Assert.Equal(returned.Id, connection1.UserId);
Assert.Equal("connection2Replaced", connection2.Connection);
Assert.Equal(returnedMate.Id, connection2.UserId);
_fixture.Dispose();
}
public async void Load()
{
ChatConnection connection = ChatConnection.Instance;
if (!connection.IsConnected())
{
await connection.Bind(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1402));
}
Ping4Send ping = new Ping4Send();
ping.Version = "1.0.0";
if (connection.Session != null)
{
connection.Session.Send(ping);
}
}
static void Main(string[] args)
{
var user = new User(1, "Player 1");
var chat = new Chat(user);
Console.WriteLine(" Type quit to quit chat.");
Console.WriteLine(" Enter text to send.");
chat.SetMessage(Console.ReadLine());
while (!chat.Exit)
{
ChatConnection.Publish(chat);
chat.SetMessage(Console.ReadLine());
}
}
static void Main(string[] args)
{
Console.WriteLine("SuperFunkChat (c) 2014 James Forshaw");
Console.WriteLine("WARNING: Don't use this for a real chat system!!!");
if (ParseArgs(args))
{
try
{
ProtocolPacket packet;
_conn = new ChatConnection();
if (_socksproxy == null)
{
packet = _conn.Connect(_endpoint.Host, _endpoint.Port, _ssl, _username, _xor);
}
else
{
packet = _conn.Connect(_endpoint.Host, _endpoint.Port, _ssl,
_socksproxy.Host, _socksproxy.Port, _username, _xor);
}
try
{
HandlePacket(packet);
Thread thread = new Thread(CommandLineThread);
thread.IsBackground = true;
thread.Start(_conn);
while ((packet = _conn.ReadPacket()) != null)
{
HandlePacket(packet);
}
}
catch
{
HandlePacket(new GoodbyeProtocolPacket("Connection Close :("));
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
public ChatConnection CreateChatConnection(string remote, string port)
{
ChatConnection conn = new ChatConnection();
try
{
conn.Connect(remote, port);
this.chatConnections.Add(conn);
}
catch (SocketException ex)
{
Log.WriteLog(LogFile.Error, ex.ToString());
conn = null;
}
return(conn);
}
static private void ProcessCommand(ChatConnection conn, string line)
{
string[] cmdargs = line.Split(' ');
if (cmdargs.Length > 0)
{
switch (cmdargs[0].ToLower())
{
case "/quit":
Environment.Exit(0);
break;
case "/list":
conn.WritePacket(new GetUserListProtocolPacket());
break;
}
}
}
/// <summary>
/// Process an incoming <see cref="DataPacket"/>
/// </summary>
/// <param name="dp">A <see cref="DataPacket"/> received by the server</param>
public void ProcessIncomingPacket(DataPacket dp)
{
if (dp.SNAC.FamilyServiceID == SNAC_CHATNAV_FAMILY)
{
switch (dp.SNAC.FamilySubtypeID)
{
case ERROR:
ProcessChatRoomCreationError(dp);
break;
case CHATNAV_PARAMETER_REPLY:
ProcessChatRoomInformation(dp);
break;
}
}
else if (dp.SNAC.FamilyServiceID == SNAC_CHATROOM_FAMILY)
{
ChatConnection conn = dp.ParentConnection as ChatConnection;
if (conn != null)
{
switch (dp.SNAC.FamilySubtypeID)
{
case CHATROOM_INFO_UPDATE:
conn.ChatRoom.ProcessRoomUpdate(dp);
break;
case CHATROOM_USER_JOINED:
conn.ChatRoom.ProcessUsersJoined(dp);
break;
case CHATROOM_USER_LEFT:
conn.ChatRoom.ProcessUsersLeft(dp);
break;
case CHATROOM_MESSAGE_RECEIVED:
conn.ChatRoom.ProcessIncomingMessage(dp);
break;
}
}
}
}
static private void CommandLineThread(object o)
{
ChatConnection conn = (ChatConnection)o;
string line;
while ((line = Console.ReadLine()) != null)
{
line = line.Trim();
if (line.Length > 0)
{
if (line[0] == '/')
{
ProcessCommand(conn, line);
}
else
{
conn.SendMessage(_username, line);
}
}
}
}
private void ReadThread(object o)
{
ChatConnection conn = (ChatConnection)o;
while (true)
{
if (conn != null)
{
try
{
while (true)
{
HandlePacket(conn.ReadPacket());
}
}
catch
{
conn = null;
UpdateConnection(null);
HandlePacket(new GoodbyeProtocolPacket("Connection Closed :("));
}
}
Thread.Sleep(1000);
try
{
conn = DoConnect(_config);
UpdateConnection(conn);
}
catch (ThreadAbortException)
{
throw;
}
catch
{
}
}
}
/// <summary>
/// Add connection result to session
/// </summary>
/// <param name="session">Session</param>
/// <param name="chatConnectionResultEnum">Result</param>
/// <param name="externalId">ChatRoulette id</param>
/// <returns>Chat connection object</returns>
/// <exception cref="EntityFrameworkException"></exception>
public async Task <ChatConnection> AddResultAsync(ChatSession session,
ChatConnectionResultEnum chatConnectionResultEnum, string externalId)
{
try
{
var result = new ChatConnection
{
DateCreated = DateTime.Now,
Result = chatConnectionResultEnum,
Session = session,
ExternalId = externalId
};
session.ChatConnections.Add(result);
await this.SaveChangesAsync();
return(result);
}
catch (Exception ex)
{
throw new EntityFrameworkException(ex);
}
}
private void SendSearchEvent(object obj)
{
var toSend = new Dictionary <string, IList <string> > {
["kinks"] = new List <string>()
};
selectedSearchTerms.Each(term =>
{
if (!toSend.ContainsKey(term.Category))
{
toSend[term.Category] = new List <string>();
}
toSend[term.Category].Add(term.UnderlyingValue ?? term.DisplayName);
});
ChatConnection.SendMessage(toSend, "FKS");
isInSearchCoolDown = true;
chatSearchCooldownTimer.Start();
OnPropertyChanged("CanStartSearch");
}
private ChatConnection DoConnect(ClientConfiguration config)
{
ChatConnection conn = null;
_userName = config.Username;
try
{
ProtocolPacket firstPacket;
conn = new ChatConnection();
if (config.SocksEnabled)
{
firstPacket = conn.Connect(config.Host, config.Port,
config.EnableSsl, config.SocksHost,
config.SocksPort, _userName, config.SupportsSecurityUpgrade);
}
else
{
firstPacket = conn.Connect(config.Host, config.Port,
config.EnableSsl, _userName, config.SupportsSecurityUpgrade);
}
HandlePacket(firstPacket);
}
catch (Exception ex)
{
MessageBox.Show(this, ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
if (conn != null)
{
conn.Dispose();
conn = null;
}
}
return(conn);
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
string[] args = Environment.GetCommandLineArgs();
if (args.Length > 1)
{
_config = LoadConfigurationFromFile(args[1]);
if (_config != null)
{
_conn = DoConnect(_config);
}
}
else
{
while (_conn == null)
{
_config = LoadConfigurationFromSettings();
if (_config == null)
{
break;
}
_conn = DoConnect(_config);
}
}
if (_conn != null)
{
Thread th = new Thread(ReadThread);
th.IsBackground = true;
th.Start(_conn);
}
else
{
Close();
}
}
