Esempio n. 1
0
        /// <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."));
        }
Esempio n. 2
0
 /// <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);
 }
Esempio n. 3
0
 /// <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));
 }
Esempio n. 4
0
        /// <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."));
        }
Esempio n. 5
0
 /// <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);
 }
Esempio n. 6
0
 /// <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}.");
        }
Esempio n. 8
0
        /// <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]}."));
        }
Esempio n. 9
0
        /// <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!"));
        }
Esempio n. 10
0
 /// <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);
 }
Esempio n. 11
0
 /// <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));
 }