/// <summary>
/// Mod command. Resets the blocked words set on a privileges group.
/// </summary>
/// <param name="command">The command.</param>
/// <param name="core">The core.</param>
public static void ResetBlockedWords(Command command, Core core = null)
{
if (Tools.IsNotModThenSendWarning(command))
{
return;
}
if (string.IsNullOrEmpty(command.Arguement))
{
Entites.Message.SendMessage(Message.Answer(command.Message,
"You must specify the privileges group which's blocked words shall be reseted."));
return;
}
Entites.Privileges privileges = Privileges.GetPrivileges(command.Message.UserToChannel.Channel, command.Arguement);
if (privileges == null)
{
Entites.Message.SendMessage(Message.Answer(command.Message,
$"No privileges group nammed {command.Arguement} was found."));
return;
}
DAL.Privileges.LoadRules(privileges).Rules.BlockedWords = BlockedWord.GetDefaultBlockedWords();
DAL.Rules.UpdateBlockedWords(privileges.Rules);
Entites.Message.SendMessage(Message.Answer(command.Message, $"Blocked words of {command.Arguement} were successfully reinitialized."));
}
/// <summary>
/// Clears the references of the privileges.
/// </summary>
/// <param name="privileges">The privileges.</param>
/// <returns>A copy of the privileges given in entry with only the references.</returns>
private static Entites.Privileges ClearReferences(Entites.Privileges privileges)
{
Entites.Privileges references = new Entites.Privileges(null, false, privileges.Channel, privileges.Rules);
privileges.Channel = null;
privileges.Rules = null;
return(references);
}
/// <summary>
/// Creates the specified privileges.
/// </summary>
/// <param name="privileges">The privileges.</param>
/// <returns>The same privileges with an updated id.</returns>
public static Entites.Privileges Create(Entites.Privileges privileges)
{
Entites.Privileges reference = ClearReferences(privileges);
using (TerministratorContext context = new TerministratorContext(true))
{
privileges.PrivilegesId = context.Privileges.Add(privileges).PrivilegesId;
context.SaveChanges();
}
return(AddReferences(privileges, reference));
}
/// <summary>
/// Mod command. Sets the rules applying to a privileges group.
/// </summary>
/// <param name="command">The command.</param>
/// <param name="core">The core.</param>
public static void SetRules(Command command, Core core = null)
{
if (Tools.IsNotModThenSendWarning(command))
{
return;
}
string[] arguements = command.SplitArguements(count: 7);
if (arguements.Length < 7)
{
Entites.Message.SendMessage(Message.Answer(command.Message,
"Incorect syntax. Please use the following one: /setrules privileges messageDelayInSeconds extensionBlocked? domainBlocked? messageTypeBlocked? blockedWordsEnabled? r9kEnabled?. Note that the fields ending by ? must be either 'y' or 'n'."));
return;
}
for (int i = 2; i < arguements.Length; ++i)
{
if (!arguements[i].Equals("y", StringComparison.InvariantCultureIgnoreCase) && !arguements[i].Equals("n", StringComparison.InvariantCultureIgnoreCase))
{
Entites.Message.SendMessage(Message.Answer(command.Message,
"Incorect syntax. Please use the following one: /setrules privileges messageDelayInSeconds extensionBlocked? domainBlocked? messageTypeBlocked? blockedWordsEnabled? r9kEnabled?. Note that the fields ending by ? must be either 'y' or 'n'."));
return;
}
}
if (!int.TryParse(arguements[1], out int messageDelay))
{
Entites.Message.SendMessage(Message.Answer(command.Message,
$"Please write a time in seconds rather than {arguements[1]}"));
return;
}
Entites.Privileges privileges = Privileges.GetPrivileges(command.Message.UserToChannel.Channel, arguements[0]);
if (privileges == null)
{
Entites.Message.SendMessage(Message.Answer(command.Message,
$"No privileges group nammed {arguements[0]} was found."));
return;
}
DAL.Privileges.LoadRules(privileges);
privileges.Rules.SpamDelay = messageDelay <= 0 ? null : (TimeSpan?)TimeSpan.FromSeconds(messageDelay);
privileges.Rules.ExtensionBlocked = "y".Equals(arguements[2], StringComparison.InvariantCultureIgnoreCase);
privileges.Rules.DomainBlocked = "y".Equals(arguements[3], StringComparison.InvariantCultureIgnoreCase);
privileges.Rules.MessageTypeBlocked = "y".Equals(arguements[4], StringComparison.InvariantCultureIgnoreCase);
privileges.Rules.BlockedWordsEnabled = "y".Equals(arguements[5], StringComparison.InvariantCultureIgnoreCase);
privileges.Rules.R9KEnabled = "y".Equals(arguements[6], StringComparison.InvariantCultureIgnoreCase);
DAL.Rules.Update(privileges.Rules);
Entites.Message.SendMessage(Message.Answer(command.Message, $"The rules of {arguements[0]} were successfully updated."));
}
/// <summary>
/// Updates the specified privileges.
/// </summary>
/// <param name="privileges">The privileges.</param>
/// <returns>The same privileges.</returns>
public static Entites.Privileges Update(Entites.Privileges privileges)
{
using (TerministratorContext context = new TerministratorContext(true))
{
Entites.Privileges old = context.Privileges.Find(privileges.PrivilegesId);
if (old != null)
{
old.Name = privileges.Name;
old.RulesId = privileges.RulesId;
old.Default = privileges.Default;
context.SaveChanges();
}
}
return(privileges);
}
/// <summary>
/// Loads the rules reference.
/// </summary>
/// <param name="privileges">The privileges.</param>
/// <returns>The same privileges with the initialized privileges reference.</returns>
public static Entites.Privileges LoadRules(Entites.Privileges privileges)
{
using (TerministratorContext context = new TerministratorContext(true))
{
if (privileges.Rules != null)
{
privileges.Rules = null;
}
if (context.Entry(privileges).State == EntityState.Detached)
{
context.Privileges.Attach(privileges);
}
context.Entry(privileges).Reference(p => p.Rules).Load();
}
return(privileges);
}
private static string SetPrivilegesAnalyzes(Command command)
{
if (!Tools.IsMod(command.Message.UserToChannel))
{
return("This command is reserved for moderators.");
}
string[] arguements = command.Arguement.Split(new[] { ' ' }, 2);
string user;
string privilegesName;
if (arguements.Length > 1)
{
user = arguements[0].Substring(1);
privilegesName = arguements[1];
}
else
{
user = command.Message.UserToChannel.User.CurrentUserName.Username;
privilegesName = arguements[0];
}
Entites.UserToChannel userToChannel =
Get(DAL.UserName.LoadOwnedBy(DAL.UserName.GetFromUsername(user, command.Message.ApplicationName))
.OwnedBy as Entites.User, command.Message.UserToChannel.Channel);
if (userToChannel == null)
{
return($"No one nammed @{user} was found.");
}
Entites.Privileges privileges = Privileges.GetPrivileges(command.Message.UserToChannel.Channel, privilegesName);
if (privileges == null)
{
return($"No privileges group nammed {privilegesName} was found.");
}
userToChannel.PrivilegesId = privileges.PrivilegesId;
Update(userToChannel);
return($"Your privileges group is now set to {privilegesName}.");
}
/// <summary>
/// Mod command. Renames the privileges group to an unused name.
/// </summary>
/// <param name="command">The command.</param>
/// <param name="core">The core.</param>
public static void RenamePrivileges(Command command, Core core = null)
{
if (Tools.IsNotModThenSendWarning(command))
{
return;
}
string[] args = command.Arguement.Split(new[] { ' ' }, 2);
if (args.Length != 2)
{
Entites.Message.SendMessage(Message.Answer(command.Message,
"The command is [/renameprivileges oldname newname]."));
return;
}
if (args[1].Contains(' '))
{
Entites.Message.SendMessage(Message.Answer(command.Message,
"The privileges group name cannot contain spaces."));
return;
}
Entites.Privileges privileges = GetPrivileges(command.Message.UserToChannel.Channel, args[0]);
if (privileges == null)
{
Entites.Message.SendMessage(Message.Answer(command.Message,
$"No privileges group nammed {args[0]} was found."));
return;
}
if (GetPrivileges(command.Message.UserToChannel.Channel, args[1]) != null)
{
Entites.Message.SendMessage(Message.Answer(command.Message,
$"A privileges group nammed {args[1]} already exists."));
return;
}
privileges.Name = args[1];
DAL.Privileges.Update(privileges);
Entites.Message.SendMessage(Message.Answer(command.Message,
$"The privileges group {args[0]} was successfully renammed to {args[1]}."));
}
/// <summary>
/// Mod command. Adds a new privileges group.
/// </summary>
/// <param name="command">The command.</param>
/// <param name="core">The core.</param>
public static void AddPrivileges(Command command, Core core = null)
{
if (Tools.IsNotModThenSendWarning(command))
{
return;
}
string[] args = command.Arguement.Split(new[] { ' ' }, 2);
if (args.Length == 0)
{
Entites.Message.SendMessage(Message.Answer(command.Message,
"The command is \"/addprivileges name [copiedprivileges]\"."));
return;
}
if (GetPrivileges(command.Message.UserToChannel.Channel, args[0]) != null)
{
Entites.Message.SendMessage(Message.Answer(command.Message,
$"A privileges group named {args[0]} already exists."));
return;
}
Entites.Privileges copying = args.Length == 1
? GetDefaultUser(command.Message.UserToChannel.Channel)
: GetPrivileges(command.Message.UserToChannel.Channel, args[1]);
if (copying == null)
{
Entites.Message.SendMessage(Message.Answer(command.Message,
$"No privileges group nammed {args[1]} was found."));
return;
}
DAL.Privileges.Create(new Entites.Privileges(args[0], false, command.Message.UserToChannel.Channel,
Rules.Create(Entites.Rules.Copy(DAL.Privileges.LoadRules(copying).Rules))));
Entites.Message.SendMessage(Message.Answer(command.Message,
$"The privileges group named {args[0]} {(args.Length == 2 ? $"inheriting {args[1]} " : "")}was successfully created!"));
}
/// <summary>
/// Adds the references of the second arguement in the first one.
/// </summary>
/// <param name="privileges">The privileges to add the references in.</param>
/// <param name="reference">The references.</param>
/// <returns>The first arguement.</returns>
private static Entites.Privileges AddReferences(Entites.Privileges privileges, Entites.Privileges reference)
{
privileges.Channel = reference.Channel;
privileges.Rules = reference.Rules;
return(privileges);
}
/// <summary>
/// Gets the default privileges group from that channel.
/// </summary>
/// <param name="channel">The channel.</param>
/// <returns>The requested privileges group.</returns>
public static Entites.Privileges GetDefaultUser(Entites.Channel channel)
{
Entites.Privileges privileges = DAL.Privileges.GetDefaultUser(channel.NamableId);
return(privileges == null ? null : DAL.Privileges.LoadRules(privileges));
}
