private void UserAuthorization(Socket sender, ChatCommand command)
{
PackageArgs responsePackage = new PackageArgs()
{
PackageType = PackageType.Command,
Command = Command.CommandResponse,
Arguments = new Dictionary <Argument, object>()
{
{ Argument.Message, "Invalid login/password" }
}
};
User user;
if (UserInfoBySocket[sender].UserModel != null)
{
responsePackage.Arguments[Argument.Message] = "You already accessed.";
}
else if ((user = db.DB_Manager.Authorized(command.Args[0], command.Args[1])) != null)
{
UserInfoBySocket[sender].SetUserModel(user);
responsePackage.Arguments[Argument.Message] = "Welcome " + user.UserName + ".";
}
PackageManag.SendPackage(sender, responsePackage, null);
}
private void CloseUserSocket(Socket userSocket)
{
if (UserInfoBySocket.ContainsKey(userSocket))
{
string userName = UserInfoBySocket[userSocket].UserName;
PackageArgs sendPackage = new PackageArgs()
{
PackageType = PackageType.Event,
Event = Event.User_Left,
Arguments = new Dictionary <Argument, object>()
{
{ Argument.UserName, userName }
}
};
BroadcastMessage(sendPackage, userSocket);
AddingMessageQuery.Add(new SystemEvent(userName, false));
UserInfoBySocket.Remove(userSocket);
UserInfoByUserName.Remove(userName);
}
userSocket.Shutdown(SocketShutdown.Both);
userSocket.Close();
Console.WriteLine("User disconnected!");
}
private void UserSendPM(Socket sender, ChatCommand command)
{
string toNickname = command.Args[0];
Socket defaultSocket = sender;
PackageArgs defaultPackage = new PackageArgs()
{
PackageType = PackageType.Command,
Command = Command.CommandResponse,
Arguments = new Dictionary <Argument, object>()
{
{ Argument.Message, "No any users in chat with nickanme: " + toNickname }
}
};
if (UserInfoByUserName.ContainsKey(toNickname))
{
UserInfo toUser = UserInfoByUserName[toNickname];
defaultPackage = new PackageArgs()
{
PackageType = PackageType.Event,
Event = Event.New_PM,
Arguments = new Dictionary <Argument, object>()
{
{ Argument.Message, command.Args[1] },
{ Argument.UserName, UserInfoBySocket[sender].UserName },
{ Argument.IsPM, true }
}
};
defaultSocket = toUser.UserSocket;
}
PackageManag.SendPackage(defaultSocket, defaultPackage, null);
}
private void NewMessageEventHandler(PackageArgs package)
{
NewMessage?.Invoke(
package.Arguments[Argument.Message] as string,
package.Arguments[Argument.UserName] as string,
(bool)package.Arguments[Argument.IsPM]
);
}
public void CalculatePackage(bool useProjectReferences)
{
string logFile = QQnPath.Combine(LoggerPath, "QQn.TurtleMSBuild.tbLog");
if (!File.Exists(logFile))
{
BuildInternal();
}
TBLogCache logCollection = new TBLogCache(LoggerPath);
logCollection.LoadAll();
PackageArgs args = new PackageArgs();
args.LogCache = logCollection;
args.BuildRoot = Path.GetDirectoryName(Solution);
args.UseProjectDependencies = useProjectReferences;
args.ProjectsToPackage.AddRange(logCollection.KeysAsFullPaths);
PackageList newPackages;
Assert.That(Packager.TryCreatePackages(args, out newPackages), "Created packages");
Assert.That(newPackages.Count, Is.EqualTo(args.ProjectsToPackage.Count), "All projects packaged");
if (Directory.Exists("f:\\extractor"))
{
Directory.Delete("f:\\extractor", true);
}
if (Directory.Exists("f:\\extractor2"))
{
Directory.Delete("f:\\extractor2", true);
}
if (!Directory.Exists("f:\\extractor"))
{
Directory.CreateDirectory("f:\\extractor");
}
if (!Directory.Exists("f:\\extractor2"))
{
Directory.CreateDirectory("f:\\extractor2");
}
foreach (TPack p in newPackages)
{
p.ExtractTo("f:\\extractor");
}
foreach (TPack p in newPackages)
{
p.ExtractTo("f:\\extractor2", true);
}
}
private void ActionOnUser(Socket sender, ChatCommand command)
{
PackageArgs sendPackage = new PackageArgs()
{
PackageType = PackageType.Command,
Command = Command.CommandResponse,
Arguments = new Dictionary <Argument, object>()
{
{ Argument.Message, "Invalid username." }
}
};
if (UserInfoBySocket[sender].UserModel == null)
{
sendPackage.Arguments[Argument.Message] = "Access denied.";
PackageManag.SendPackage(sender, sendPackage, null);
}
else if (UserInfoByUserName.ContainsKey(command.Args[0]))
{
UserInfo user = UserInfoByUserName[command.Args[0]];
IPEndPoint localIP = user.UserSocket.LocalEndPoint as IPEndPoint;
if (command.ParsedCommand == Command.Ban)
{
db.DB_Manager.AddBlockIP(localIP.Address.ToString(), command.Args[1]);
}
sendPackage = new PackageArgs()
{
PackageType = PackageType.Event,
Event = (command.ParsedCommand == Command.Ban) ? Event.HasBanned : Event.HasKicked,
Arguments = new Dictionary <Argument, object>()
{
{ Argument.Message, command.Args[1] }
}
};
PackageManag.SendPackage(user.UserSocket, sendPackage, null);
//PackageArgs broadcastPackage = new PackageArgs()
//{
// PackageType = PackageType.Event,
// Event = Event.User_Left,
// Arguments = new Dictionary<Argument, object>()
// {
// { Argument.UserName, user.UserName }
// }
//};
//BroadcastMessage(broadcastPackage, user.UserSocket);
}
else
{
PackageManag.SendPackage(sender, sendPackage, null);
}
}
private void BroadcastMessage(PackageArgs sendPackage, Socket exeptUser)
{
foreach (Socket user in UserInfoBySocket.Keys)
{
if (user == exeptUser)
{
continue;
}
PackageManag.SendPackage(user, sendPackage, null);
}
}
public void GetLastMessages(Action <List <ChatMessage> > handler)
{
OutHandler = handler;
PackageArgs package = new PackageArgs()
{
PackageType = PackageType.Command,
Command = Command.Get_Last_Messages
};
PackageManag.SendPackage(Handler, package, null);
}
public void Disconnect()
{
PackageArgs package = new PackageArgs()
{
PackageType = PackageType.Command,
Command = Command.Exit,
Arguments = null
};
PackageManag.SendPackage(Handler, package, DisconnectHandler);
}
private void BanRequest(Socket sender, ChatCommand command)
{
PackageArgs sendPackage = new PackageArgs()
{
PackageType = PackageType.Command,
Command = Command.CommandResponse,
Arguments = new Dictionary <Argument, object>()
{
{ Argument.Message, "Invalid username." }
}
};
if (UserInfoBySocket[sender].UserModel == null)
{
sendPackage.Arguments[Argument.Message] = "Access denied.";
PackageManag.SendPackage(sender, sendPackage, null);
}
else if (UserInfoByUserName.ContainsKey(command.Args[0]))
{
UserInfo bannedUser = UserInfoByUserName[command.Args[0]];
IPEndPoint localIP = bannedUser.UserSocket.LocalEndPoint as IPEndPoint;
db.DB_Manager.AddBlockIP(localIP.Address.ToString(), command.Args[1]);
sendPackage = new PackageArgs()
{
PackageType = PackageType.Event,
Event = Event.HasBanned,
Arguments = new Dictionary <Argument, object>()
{
{ Argument.Message, command.Args[1] }
}
};
PackageManag.SendPackage(bannedUser.UserSocket, sendPackage, null);
PackageArgs broadcastPackage = new PackageArgs()
{
PackageType = PackageType.Event,
Event = Event.User_Left,
Arguments = new Dictionary <Argument, object>()
{
{ Argument.UserName, bannedUser.UserName }
}
};
BroadcastMessage(broadcastPackage, bannedUser.UserSocket);
}
else
{
PackageManag.SendPackage(sender, sendPackage, null);
}
}
private void GetLastMessages(Socket sender)
{
PackageArgs sendPackage = new PackageArgs()
{
PackageType = PackageType.Command,
Command = Command.Get_Last_Messages,
Arguments = new Dictionary <Argument, object>()
{
{ Argument.MessageList, ChatMessages }
}
};
PackageManag.SendPackage(sender, sendPackage, null);
}
//private void KickRequest(Socket sender, ChatCommand command)
//{
// PackageArgs sendPackage = new PackageArgs()
// {
// PackageType = PackageType.Command,
// Command = Command.CommandResponse,
// Arguments = new Dictionary<Argument, object>()
// { { Argument.Message, "Invalid username." } }
// };
// if (UserInfoBySocket[sender].UserModel == null)
// {
// sendPackage.Arguments[Argument.Message] = "Access denied.";
// PackageManag.SendPackage(sender, sendPackage, null);
// }
// else if (UserInfoByUserName.ContainsKey(command.Args[0]))
// {
// UserInfo kickedUser = UserInfoByUserName[command.Args[0]];
// IPEndPoint localIP = kickedUser.UserSocket.LocalEndPoint as IPEndPoint;
// sendPackage = new PackageArgs()
// {
// PackageType = PackageType.Event,
// Event = Event.HasKicked,
// Arguments = new Dictionary<Argument, object>()
// { { Argument.Message, command.Args[1] } }
// };
// PackageManag.SendPackage(kickedUser.UserSocket, sendPackage, null);
// PackageArgs broadcastPackage = new PackageArgs()
// {
// PackageType = PackageType.Event,
// Event = Event.User_Left,
// Arguments = new Dictionary<Argument, object>()
// {
// { Argument.UserName, kickedUser.UserName }
// }
// };
// BroadcastMessage(broadcastPackage, kickedUser.UserSocket);
// }
// else
// {
// PackageManag.SendPackage(sender, sendPackage, null);
// }
//}
private void InvalidCommand(Socket sender)
{
PackageArgs responsePackage = new PackageArgs()
{
PackageType = PackageType.Command,
Command = Command.CommandResponse,
Arguments = new Dictionary <Argument, object>()
{
{ Argument.Message, "Invalid command or parameters" }
}
};
PackageManag.SendPackage(sender, responsePackage, null);
}
public void SetNickAndContinue(string nickName)
{
PackageArgs package = new PackageArgs()
{
PackageType = PackageType.Command,
Command = Command.User_Setup,
Arguments = new Dictionary <Argument, object>
{
{ Argument.UserName, nickName }
}
};
PackageManag.SendPackage(Handler, package, null);
}
public void SendMessage(string message)
{
PackageArgs package = new PackageArgs()
{
PackageType = PackageType.Command,
Command = Command.Send_Message,
Arguments = new Dictionary <Argument, object>
{
{ Argument.MessageObj, new UserMessage(LocalID, LocalNickname, message) }
}
};
PackageManag.SendPackage(Handler, package, null);
}
private void CheckBlockIP(Socket sender, PackageArgs package)
{
PackageArgs sendPackage = new PackageArgs()
{
PackageType = PackageType.Command,
Command = Command.CheckBlockIP,
Arguments = new Dictionary <Argument, object>()
{
{ Argument.IsAdmitted, db.DB_Manager.IPInBlackList
(package.Arguments[Argument.IP] as string) }
}
};
PackageManag.SendPackage(sender, sendPackage, null);
}
public void CheckIP()
{
string ip = GetIP();
PackageArgs package = new PackageArgs()
{
PackageType = PackageType.Command,
Command = Command.CheckBlockIP,
Arguments = new Dictionary <Argument, object>
{
{ Argument.IP, ip }
}
};
PackageManag.SendPackage(Handler, package, null);
}
private void ReceiveCallback(Socket user, PackageArgs package)
{
if (package.PackageType == PackageType.Event)
{
switch (package.Event)
{
case (Event.New_Message): NewMessageEventHandler(package); break;
case (Event.User_Left): UserConnectionAction(
package.Arguments[Argument.UserName] as string, false); break; //TEMP
case (Event.New_User): UserConnectionAction(
package.Arguments[Argument.UserName] as string, true); break; //TEMP
case (Event.New_PM): NewMessageEventHandler(package); break;
case (Event.HasBanned): HasBanned?.Invoke(package.Arguments
[Argument.Message] as string); break;
case (Event.HasKicked): HasKicked?.Invoke(package.Arguments
[Argument.Message] as string); break;
}
}
else
{
switch (package.Command)
{
case (Command.User_Setup): SetupResponse(package); break;
case (Command.Get_Last_Messages): OutHandler?.Invoke
(package.Arguments[Argument.MessageList] as List <ChatMessage>); break;
case (Command.CommandResponse): AuthCommandHasResponsed?.Invoke
(package.Arguments[Argument.Message] as string);; break;
case (Command.CheckBlockIP): CheckBlockIPResponsed?.Invoke
((bool)(package.Arguments[Argument.IsAdmitted])); break;
default: break;
}
}
if (IsConnected)
{
PackageManag.ReceivePackage(Handler, ReceiveCallback);
}
}
private void SetupResponse(PackageArgs package)
{
bool result = (bool)package.Arguments[Argument.IsAdmitted];
string message = null;
if (result)
{
LocalID = (int)package.Arguments[Argument.UserID];
LocalNickname = package.Arguments[Argument.UserName] as string;
}
else
{
message = package.Arguments[Argument.Message] as string;
}
HasAdmitted?.Invoke(result, message);
}
private void UserSetupHandler(Socket sender, PackageArgs package)
{
PackageArgs responsePackage = new PackageArgs()
{
PackageType = PackageType.Command,
Command = Command.User_Setup,
Arguments = new Dictionary <Argument, object>()
{
{ Argument.IsAdmitted, false }
}
};
string userName = package.Arguments[Argument.UserName] as string;
if (UserInfoByUserName.ContainsKey(userName))
{
responsePackage.Arguments.Add(Argument.Message, "Sorry, but \"" + userName + "\" is already taken...");
}
else
{
UserInfo userInfo = new UserInfo(UserInfoBySocket.Count, userName, sender);
UserInfoBySocket.Add(sender, userInfo);
UserInfoByUserName.Add(userInfo.UserName, userInfo);
responsePackage.Arguments.Add(Argument.UserID, UserInfoBySocket.Count);
responsePackage.Arguments.Add(Argument.UserName, userName);
responsePackage.Arguments[Argument.IsAdmitted] = true;
PackageArgs sendPackage = new PackageArgs()
{
PackageType = PackageType.Event,
Event = Event.New_User,
Arguments = new Dictionary <Argument, object>()
{
{ Argument.UserName, userName }
}
};
BroadcastMessage(sendPackage, sender);
AddingMessageQuery.Add(new SystemEvent(userName, true));
}
PackageManag.SendPackage(sender, responsePackage, null);
}
private void UserSendMeesage(Socket sender, PackageArgs package)
{
UserMessage messageObj = (UserMessage)package.Arguments[Argument.MessageObj];
AddingMessageQuery.Add(messageObj);
PackageArgs sendPackage = new PackageArgs()
{
PackageType = PackageType.Event,
Event = Event.New_Message,
Arguments = new Dictionary <Argument, object>()
{
{ Argument.Message, messageObj.Content },
{ Argument.UserName, messageObj.UserName },
{ Argument.IsPM, false }
}
};
BroadcastMessage(sendPackage, sender);
}
public void ReceiveCallback(Socket user, PackageArgs package)
{
Console.WriteLine("New package: " + package.Command.ToString());
Command command = package.Command;
ChatCommand chatCommand = new ChatCommand();
if (package.Command == Command.Send_Message)
{
chatCommand = ChatCommand.ParseToCommand(
((UserMessage)package.Arguments[Argument.MessageObj]).Content, command);
command = chatCommand.ParsedCommand;
}
switch (command)
{
case (Command.User_Setup): UserSetupHandler(user, package); break;
case (Command.Send_Message): UserSendMeesage(user, package); break;
case (Command.Get_Last_Messages): GetLastMessages(user); break;
case (Command.Authorization): UserAuthorization(user, chatCommand); break;
case (Command.Send_PM): UserSendPM(user, chatCommand); break;
case (Command.Ban): ActionOnUser(user, chatCommand); break;
case (Command.Kick): ActionOnUser(user, chatCommand); break;
case (Command.IvalidCommand): InvalidCommand(user); break;
case (Command.CheckBlockIP): CheckBlockIP(user, package); break;
case (Command.Exit): CloseUserSocket(user); return;
default: Console.WriteLine("Ivalid Package!"); break;
}
PackageManag.ReceivePackage(user, ReceiveCallback);
}
