public async Task UpdateLogs(bool fullUpdate = false)
{
int selectedItem = messagesListView.SelectedItem;
int topItem = messagesListView.TopItem;
//var follow = selectedItem == messages.Count - 1;
bool follow = true;
if (selectedServer == 0) // Info logs are always 0
{
messages = (IList)Target.Logs;
}
else
{
LinkedServer server = LinkedServers[selectedServer];
if (server is LinkedIrcServer)
{
var ircServer = (LinkedIrcServer)server;
foreach (Configuration.ServerConfiguration serverConfiguration in Program.Config.servers.Values)
{
if (serverConfiguration.IrcClient.ServerInfo != ircServer.IrcServer)
{
continue;
}
messages = await serverConfiguration.IrcListener.GetMessages(LinkedChannels[selectedChannel]);
break;
}
}
else
{
if (server is LinkedDiscordServer)
{
LinkedChannel channel = LinkedChannels[selectedChannel];
messages = await Program.Config.DiscordListener.GetMessages(channel);
}
}
}
int followTop = messages.Count - messagesListView.Frame.Height;
messagesListView.SetSource(messages);
if (followTop < 0)
{
return;
}
if (follow || fullUpdate)
{
messagesListView.SelectedItem = messages.Count - 1;
messagesListView.TopItem = followTop;
}
else
{
messagesListView.SelectedItem = selectedItem;
messagesListView.TopItem = topItem;
}
Application.MainLoop.Driver.Wakeup();
}
private void OnMessage(string text)
{
if (selectedServer == 0)
{
return;
}
LinkedChannel channel = LinkedChannels[selectedChannel];
channel.respond(text);
LinkedServer server = LinkedServers[selectedServer];
if (server is LinkedIrcServer ircServer)
{
foreach (Configuration.ServerConfiguration serverConfiguration in Program.Config.servers.Values)
{
if (serverConfiguration.IrcClient.ServerInfo != ircServer.IrcServer)
{
continue;
}
serverConfiguration.IrcListener.LogMessage(channel, new LinkedIrcMessage((LinkedIrcUser)serverConfiguration.IrcSelf, channel, server, text, null));
return;
}
}
}
private string ScriptLinkedServers(string outputFilePath, string filePrefix)
{
string strRetVal = "";
if (!this.IncludeLinkedServers)
{
strRetVal = "Linked server scripts were not included.";
return(strRetVal);
}
try
{
Scripter scr = new Scripter(DBServer);
GetSystemObjectsProperty();
LinkedServer[] linkedServers = new LinkedServer[this.DBServer.LinkedServers.Count];
this.DBServer.LinkedServers.CopyTo(linkedServers, 0);
ScriptingOptions options = GetDBScriptingOptions(false);
options.FileName = GetFileName(this.DBServer.Name, outputFilePath, filePrefix);
scr.Options = options;
scr.Script(linkedServers);
strRetVal = "Susccessfully generated Linked server script for Server:" + this.DBServer.Name + " and saved to file:" + options.FileName;
}
catch (Exception ex)
{
strRetVal = "Error generating Linked server script for server:" + this.DBServer.Name + " Error: " + ex.Message;
if (ex.InnerException != null)
{
strRetVal = ex.InnerException.Message + System.Environment.NewLine + strRetVal;
}
}
return(strRetVal);
}
public override bool Equals(IDatabaseInfo other)
{
DatabaseInfo dbi = other as DatabaseInfo;
return(ReferenceEquals(this, other) ||
(dbi != null && Catalog.EqualsIgnoreCase(dbi.Catalog) && IsLinkedServer == dbi.IsLinkedServer &&
LinkedServer.EqualsIgnoreCase(dbi.LinkedServer)));
}
/// <summary>
/// Creates a linked server to a remote SQL Server instance with customizable credentials.
/// </summary>
/// <param name="serverInstance">The local SQL Server instance.</param>
/// <param name="remoteInstance">The remote SQL Server instance.</param>
/// <param name="name">Name of the linked server.</param>
/// <param name="userName">Username to use for authenticating the connection.</param>
/// <param name="password">Password to use for authenticating the connection.</param>
public void CreateLinkedServer(Jhu.Graywulf.Registry.ServerInstance remoteInstance, string name, string userName, string password)
{
if (this.Guid == remoteInstance.Guid)
{
throw new DeployException(ExceptionMessages.LinkedServerCannotPointToItself);
}
Server s = this.GetSmoServer();
LinkedServer ls = new LinkedServer(s, name);
// TODO
ls.Catalog = string.Empty;
ls.CollationCompatible = false; // ???
ls.CollationName = string.Empty;
ls.ConnectTimeout = 0; // ???
ls.DataAccess = true;
ls.DataSource = string.Empty;
ls.DistPublisher = false;
ls.Distributor = false;
ls.LazySchemaValidation = true;
//ls.LinkedServerLogins
ls.Location = string.Empty; //?
ls.ProductName = "SQL Server";
ls.ProviderName = string.Empty; // OLE DB only
ls.ProviderString = string.Empty; // OLE DB only
ls.Publisher = false;
ls.QueryTimeout = 0; // ???
ls.Rpc = true;
ls.RpcOut = true;
ls.Subscriber = false;
ls.UseRemoteCollation = true;
s.LinkedServers.Add(ls);
ls.Create();
if (userName != null && password != null)
{
// Drop default login (impersonate)
ls.LinkedServerLogins[0].Drop();
// Create login for sql authentication
LinkedServerLogin login = new LinkedServerLogin(ls, string.Empty);
login.Impersonate = false;
login.RemoteUser = userName;
login.SetRemotePassword(password);
ls.LinkedServerLogins.Add(login);
login.Create();
}
this.Context.LogEvent(new Event("Jhu.Graywulf.Registry.ServerInstance.CreateLinkedServer", this.Guid));
}
private LinkedServerDTO ToLinkedServer(LinkedServer linked)
{
LinkedServerDTO result = new LinkedServerDTO();
result.ID = linked.ID;
result.SourceDBServerID = linked.SourceDBServerID;
result.SourceDBServerName = linked.DBServer.Name;
result.TargetDBServerID = linked.TargetDBServerID;
result.TargetDBServerName = linked.DBServer1.Name;
result.Name = linked.Name;
return(result);
}
public int SaveLinkedServer(LinkedServerDTO message)
{
using (var projectContext = new DataAccess.MyProjectEntities())
{
var dbServer = projectContext.LinkedServer.FirstOrDefault(x => x.ID == message.ID);
if (dbServer == null)
{
dbServer = new LinkedServer();
}
dbServer.SourceDBServerID = message.SourceDBServerID;
dbServer.TargetDBServerID = message.TargetDBServerID;
dbServer.Name = message.Name;
if (dbServer.ID == 0)
{
projectContext.LinkedServer.Add(dbServer);
}
projectContext.SaveChanges();
return(dbServer.ID);
}
}
public static bool CheckIfOwner(LinkedMessage e)
{
LinkedServer server = e.server;
LinkedUser user = e.author;
if (user.isIrc)
{
LinkedIrcUser ircUser = (LinkedIrcUser)user;
if (ircUser.IrcUser.Match(Program.Config.servers[server.name].botOwnerHostmask))
{
return(true);
}
}
else if (user.isDiscord)
{
if (user.id.Equals(Program.Config.DiscordBotOwnerID.ToString()))
{
return(true);
}
}
return(false);
}
public static bool CheckPermission(string commandName, LinkedMessage e)
{
LinkedServer server = e.server;
LinkedChannel channel = e.channel;
LinkedUser user = e.author;
if (CheckIfOwner(e))
{
return(true); // If user is the Bot owner, bypass all permission checks
}
ICommand command = Program.CommandList[commandName]; // Get required permission level
PermissionLevel permission = (PermissionLevel)Attribute.GetCustomAttribute(command.GetType(), typeof(PermissionLevel));
if (permission == null)
{
Logger.Warn("Command \"{0}\" does not have a valid permission set on the class", commandName);
}
if (Program.Permissions.TryGetValue(server.name, out Dictionary <string, Dictionary <string, PermissionLevel> > channels))
{
string check = channel == null ? "PM" : channel.name;
if (channels.TryGetValue(check, out Dictionary <string, PermissionLevel> commands))
{
commands.TryGetValue(commandName, out permission);
}
}
// Check permissions
if (permission == null)
{
Logger.Warn("Disallowing use of command \"{0}\" because no permission is set", commandName);
return(false); // Prevent accidentally allowing dangerous commands to be ran by normal users
}
if (permission.minLevel == Modes.BotOwner)
{
return(false);
}
if (user.isIrc)
{
if (permission.minLevel == Modes.None)
{
return(true);
}
if (channel == null)
{
return(false);
}
LinkedIrcChannel ircChannel = (LinkedIrcChannel)channel;
LinkedIrcUser ircUser = (LinkedIrcUser)user;
return(ircChannel.channel.UsersByMode[IrcUtils.GetUserLevelChar(permission.minLevel)].Contains(ircUser));
}
if (user.isDiscord)
{
if (permission.requiredPermission == Permissions.None)
{
return(true);
}
LinkedDiscordUser discordUser = (LinkedDiscordUser)user;
if (channel == null)
{
return(false);
}
LinkedDiscordChannel discordChannel = (LinkedDiscordChannel)channel;
return(discordUser.DiscordMember.PermissionsIn(discordChannel).HasFlag(permission.requiredPermission));
}
return(false);
}
public void UpdateChannels()
{
if ((Program.Config.DiscordSocketClient == null) ||
(Program.Config.servers.Count == 0))
{
return;
}
//messages = new List<string>();
List <string> channelList = new List <string>();
List <LinkedChannel> linkedChannelList = new List <LinkedChannel>();
if (selectedServer == 0)
{
selectedChannel = 0;
channels = channelList;
LinkedChannels = linkedChannelList;
chanListView.SetSource(channels);
return;
}
LinkedServer linkedServer = LinkedServers[selectedServer];
if (linkedServer.isDiscord)
{
var server = (LinkedDiscordServer)linkedServer;
foreach (DiscordChannel channel in server.DiscordGuild.Channels)
{
if (channel.Type != ChannelType.Text)
{
continue;
}
channelList.Add("#" + channel.Name.StripEmojis());
linkedChannelList.Add((LinkedDiscordChannel)channel);
}
}
if (linkedServer.isIrc)
{
var server = (LinkedIrcServer)linkedServer;
foreach (Configuration.ServerConfiguration serverConfiguration in Program.Config.servers.Values)
{
if (serverConfiguration.IrcClient.ServerInfo != server.IrcServer)
{
continue;
}
foreach (IrcChannel channel in serverConfiguration.IrcClient.Channels)
{
channelList.Add(channel.Name);
linkedChannelList.Add((LinkedIrcChannel)channel);
}
}
}
if (channelList.Count == channels.Count)
{
return;
}
channels = channelList;
LinkedChannels = linkedChannelList;
chanListView.SetSource(channels);
UpdateLogs();
}
public override int GetHashCode()
{
return(Catalog.GetHashCode() ^ LinkedServer.GetHashCode());
}
