mod_spox 0.2.0 → 0.3.0

data/data/mod_spox/extras/Weather.rb

@@ -4,8 +4,7 @@ class Weather < ModSpox::Plugin
 
     def initialize(pipeline)
         super
-        Signature.find_or_create(:signature => 'weather (\d+)', :plugin => name, :method => 'weather',
-            :description => 'Show weather for given zipcode').params = [:zipcode]
+        add_sig(:sig => 'weather (\d+)', :method => :weather, :desc => 'Show weather for given zipcode', :params => [:zipcode])
     end
     
     def weather(message, params)

data/data/mod_spox/plugins/Authenticator.rb

@@ -2,44 +2,29 @@ class Authenticator < ModSpox::Plugin
     def initialize(pipeline)
         super(pipeline)
         group = Models::Group.filter(:name => 'admin').first
-        Models::Signature.find_or_create(:signature => 'auth (\S+)', :plugin => name, :method => 'authenticate',
-            :description => 'Authenticate with bot using a password').params = [:password]
-        Models::Signature.find_or_create(:signature => 'ident', :plugin => name, :method => 'send_whois',
-            :description => 'Instructs the bot to check your NickServ status')
-        Models::Signature.find_or_create(:signature => 'auth mask add (\S+) (\S+)', :plugin => name, :method => 'add_mask',
-            :group_id => group.pk, :description => 'Add authentication mask and set initial group').params = [:mask, :group]
-        Models::Signature.find_or_create(:signature => 'auth mask set (\d+) (.+)', :plugin => name, :method => 'set_mask_groups',
-            :group_id => group.pk, :description => 'Set groups for the given mask').params = [:id, :groups]
-        Models::Signature.find_or_create(:signature => 'auth mask unset (\d+) (.+)', :plugin => name, :method => 'del_mask_groups',
-            :group_id => group.pk, :description => 'Remove groups for the given mask').params = [:id, :groups]
-        Models::Signature.find_or_create(:signature => 'auth mask remove (\d+)', :plugin => name, :method => 'remove_mask',
-            :group_id => group.pk, :description => 'Remove authentication mask').params = [:id]
-        Models::Signature.find_or_create(:signature => 'auth mask list', :plugin => name, :method => 'list_mask',
-            :group_id => group.pk, :description => 'List all available authentication masks')
-        Models::Signature.find_or_create(:signature => 'auth nick ident (\S+) (true|false)', :plugin => name, :method => 'nick_ident',
-            :group_id => group.pk, :description => 'Allow authentication to nicks identified to NickServ').params = [:nick, :ident]
-        Models::Signature.find_or_create(:signature => 'auth nick password (\S+) (\S+)', :plugin => name, :method => 'nick_pass',
-            :group_id => group.pk, :description => 'Set authentication password for nick').params = [:nick, :password]
-        Models::Signature.find_or_create(:signature => 'auth nick clear password (\S+)', :plugin => name, :method => 'clear_pass',
-            :group_id => group.pk, :description => 'Clear nicks authentication password').params = [:nick]
-        Models::Signature.find_or_create(:signature => 'auth nick info (\S+)', :plugin => name, :method => 'nick_info',
-            :group_id => group.pk, :description => 'Return authentication information about given nick').params = [:nick]
-        Models::Signature.find_or_create(:signature => 'auth nick set (\S+) (\S+)', :plugin => name, :method => 'set_nick',
-            :group_id => group.pk, :description => 'Set the group for a given nick').params = [:nick, :group]
-        Models::Signature.find_or_create(:signature => 'auth nick unset (\S+) (\S+)', :plugin => name, :method => 'unset_nick',
-            :group_id => group.pk, :description => 'Unset the group for a given nick').params = [:nick, :group]
-        Models::Signature.find_or_create(:signature => 'auth group list', :plugin => name, :method => 'list_groups',
-            :group_id => group.pk, :description => 'List available authentication groups')
-        Models::Signature.find_or_create(:signature => 'auth group info (\S+)', :plugin => name, :method => 'group_info',
-            :group_id => group.pk, :description => 'List members of given group').params = [:group]
-        Models::Signature.find_or_create(:signature => 'groups', :plugin => name, :method => 'show_groups',
-            :description => 'Show user groups they are currently a member of')
-        @whois_cache = []
+        add_sig(:sig => 'auth (\S+)', :method => :authenticate, :desc => 'Authenticate with bot using a password', :params => [:password])
+        add_sig(:sig => 'ident', :method => :do_ident, :desc => 'Instructs the bot to check your NickServ status')
+        add_sig(:sig => 'auth mask add (\S+) (\S+)', :method => :add_mask, :group => group, :desc => 'Add authentication mask and set initial group', :params => [:mask, :group])
+        add_sig(:sig => 'auth mask set (\d+) (.+)', :method => :set_mask_groups, :group => group, :desc => 'Set groups for the given mask', :params => [:id, :groups])
+        add_sig(:sig => 'auth mask unset (\d+) (.+)', :method => :del_mask_groups, :group => group, :desc => 'Remove groups for the given mask', :params => [:id, :groups])
+        add_sig(:sig => 'auth mask remove (\d+)', :method => :remove_mask, :group => group, :desc => 'Remove authentication mask', :params => [:id])
+        add_sig(:sig => 'auth mask list', :method => :list_mask, :group => group, :desc => 'List all available authentication masks')
+        add_sig(:sig => 'auth nick ident (\S+) (true|false)', :method => :nick_ident, :group => group, :desc => 'Allow authentication to nicks identified to NickServ', :params => [:nick, :ident])
+        add_sig(:sig => 'auth nick password (\S+) (\S+)', :method => :nick_pass, :group => group, :desc => 'Set authentication password for nick', :params => [:nick, :password])
+        add_sig(:sig => 'auth nick clear password (\S+)', :method => :clear_pass, :group => group, :desc => 'Clear nicks authentication password', :params => [:nick])
+        add_sig(:sig => 'auth nick info (\S+)', :method => :nick_info, :group => group, :desc => 'Return authentication information about given nick', :params => [:nick])
+        add_sig(:sig => 'auth nick set (\S+) (\S+)', :method => :set_nick, :group => group, :desc => 'Set the group for a given nick', :params => [:nick, :group])
+        add_sig(:sig => 'auth nick unset (\S+) (\S+)', :method => :unset_nick, :group => group, :desc => 'Unset the group for a given nick', :params => [:nick, :group])
+        add_sig(:sig => 'auth group list', :method => :list_groups, :group => group, :desc => 'List available authentication groups')
+        add_sig(:sig => 'auth group info (\S+)', :method => :group_info, :group => group, :desc => 'List members of given group', :params => [:group])
+        add_sig(:sig => 'groups', :method => :show_groups, :desc => 'Show user groups they are currently a member of')
         @nickserv_nicks = []
+        @nickserv_cache = []
         populate_nickserv
         @pipeline.hook(self, :check_join, :Incoming_Join)
         @pipeline.hook(self, :check_nicks, :Incoming_Who)
         @pipeline.hook(self, :check_nicks, :Incoming_Names)
+        @pipeline.hook(self, :check_notice, :Incoming_Notice)
     end
 
     # message:: ModSpox::Messages::Incoming::Privmsg
@@ -48,9 +33,9 @@ class Authenticator < ModSpox::Plugin
     def authenticate(message, params)
         return unless message.is_private?
         if(message.is_private? && message.source.auth.check_password(params[:password]))
-            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, 'Authentication was successful')
+            information message.replyto, 'Authentication was successful'
         else
-            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, 'Authentication failed')
+            error message.replyto, 'Authentication failed'
         end
     end
 
@@ -61,12 +46,12 @@ class Authenticator < ModSpox::Plugin
         begin
             group = Models::Group.filter(:name => params[:group]).first
             raise Exception.new("Failed to find group") unless group
-            a = Models::Auth.find_or_create(:mask => Regexp.new(params[:mask]).source)
-            a.group = group
+            a = Models::AuthMask.find_or_create(:mask => Regexp.new(params[:mask]).source)
+            a.add_group(group)
             a.save
-            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, 'Mask has been successfully added to authentication table')
+            information message.replyto, 'Mask has been successfully added to authentication table'
         rescue Object => boom
-            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "Authentication failed to add mask. Reason: #{boom}")
+            error message.replyto, "Authentication failed to add mask. Reason: #{boom}"
         end
     end
 
@@ -74,15 +59,15 @@ class Authenticator < ModSpox::Plugin
     # params:: Signature parameters
     # Add an authentication group to a given mask
     def set_mask_groups(message, params)
-        auth = Models::Auth[params[:id]]
+        auth = Models::AuthMask[params[:id].to_i]
         if(auth)
             params[:groups].split(/\s/).each do |g|
                 group = Models::Group.filter(:name => g).first
-                auth.group = group if group
+                auth.add_group(group) if group
             end
-            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "Mask groups have been updated")
+            information message.replyto, "Mask groups have been updated"
         else
-            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "Failed to find mask with ID: #{params[:id]}")
+            error message.replyto, "Failed to find mask with ID: #{params[:id]}"
         end
     end
 
@@ -90,15 +75,15 @@ class Authenticator < ModSpox::Plugin
     # params:: Signature parameters
     # Remove an authentication group from a given mask
     def del_mask_groups(message, params)
-        auth = Models::Auth[params[:id]]
+        auth = Models::AuthMask[params[:id].to_i]
         if(auth)
             params[:groups].split(/\s/).each do |g|
                 group = Models::Group.filter(:name => g).first
                 auth.remove_group(group) if group
             end
-            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "Mask groups have been updated")
+            information message.replyto, "Mask groups have been updated"
         else
-            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "Failed to find mask with ID: #{params[:id]}")
+            error message.replyto, "Failed to find mask with ID: #{params[:id]}"
         end
     end
 
@@ -106,26 +91,25 @@ class Authenticator < ModSpox::Plugin
     # params:: Signature parameters
     # List all authentication masks
     def list_mask(message, params)
-        @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, 'Authentication Mask Listing:')
-        auths = []
-        Models::Auth.where('mask is not null').each{|a| auths << a}
-        auths.each do |a|
+        output = ["\2Authentication Mask Listing:\2"]
+        Models::AuthMask.all.each do |a|
             groups = []
             a.groups.each{|g| groups << g.name}
-            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "\2ID:\2 #{a.pk}: \2mask:\2 #{a.mask} \2groups:\2 #{groups.join(', ')}")
+            output << "\2ID:\2 #{a.pk}: \2mask:\2 #{a.mask} \2groups:\2 #{groups.join(', ')}"
         end
+        reply message.replyto, output
     end
 
     # message:: ModSpox::Messages::Incoming::Privmsg
     # params:: Signature parameters
     # Remove given authentication mask
     def remove_mask(message, params)
-        auth = Models::Auth[params[:id].to_i]
+        auth = Models::AuthMask[params[:id].to_i]
         if(auth)
             auth.destroy
-            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "Authentication mask with ID #{params[:id]} was deleted")
+            information message.replyto, "Authentication mask with ID #{params[:id]} was deleted"
         else
-            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "\2Failed\2: Could not find an authentication mask with ID: #{params[:id]}")
+            error message.replyto, "\2Failed\2: Could not find an authentication mask with ID: #{params[:id]}"
         end
     end
 
@@ -135,11 +119,12 @@ class Authenticator < ModSpox::Plugin
     def nick_ident(message, params)
         nick = Models::Nick.locate(params[:nick])
         if(params[:ident] == 'true')
-            nick.auth.update_with_params(:services => true)
+            nick.auth.update(:services => true)
         else
-            nick.auth.update_with_params(:services => false)
+            nick.auth.update(:services => false)
         end
-        @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "Nick #{params[:nick]} has been updated. Services for authentication has been set to #{params[:ident]}")
+        populate_nickserv
+        information message.replyto, "Nick #{params[:nick]} has been updated. Services for authentication has been set to #{params[:ident]}"
     end
 
 
@@ -149,7 +134,7 @@ class Authenticator < ModSpox::Plugin
     def nick_pass(message, params)
         nick = Models::Nick.locate(params[:nick])
         nick.auth.password = params[:password]
-        @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "Nick #{params[:nick]} has been updated. Password has been set.")
+        information message.replyto, "Nick #{params[:nick]} has been updated. Password has been set."
     end
 
     # message:: ModSpox::Messages::Incoming::Privmsg
@@ -158,7 +143,8 @@ class Authenticator < ModSpox::Plugin
     def clear_pass(message, params)
         nick = Models::Nick.locate(params[:nick])
         nick.auth.password = nil
-        @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "Nick #{params[:nick]} has been updated. Password has been unset.")
+        nick.auth.save
+        information message.replyto, "Nick #{params[:nick]} has been updated. Password has been unset."
     end
 
     # message:: ModSpox::Messages::Incoming::Privmsg
@@ -170,25 +156,24 @@ class Authenticator < ModSpox::Plugin
             info = []
             info << "\2INFO [#{nick.nick}]:\2"
             groups = []
-            Models::AuthGroup.filter(:auth_id => nick.auth.pk).each do |ag|
-                groups << ag.group.name
+            nick.auth.groups.each do |ag|
+                groups << ag.name
             end
             info << "Groups: #{groups.uniq.sort.join(', ')}."
-            nick.auth.password.nil? ? info << 'Password has not been set.' : info << 'Password has been set.'
+            nick.auth.password.nil? || nick.auth.password.empty? ? info << 'Password has not been set.' : info << 'Password has been set.'
             nick.auth.services ? info << 'Nickserv ident is enabled.' : info << 'Nickserv ident is disabled.'
-            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "#{info.join(' ')}")
+            information message.replyto, "#{info.join(' ')}"
         else
-            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "I have no record of nick: #{params[:nick]}")
+            error message.replyto, "I have no record of nick: #{params[:nick]}"
         end
     end
 
     def show_groups(message, params)
-        groups = []
-        message.source.auth_groups.each{|g| groups << g.name}
-        if(groups.empty?)
+        groups = message.source.auth_groups.map{|g| g.name}
+        if(groups.nil? || groups.empty?)
             reply message.replyto, "You are not currently a member of any groups"
         else
-            reply message.replyto, "\2Groups (#{message.source.nick}):\2 #{groups.join(', ')}"
+            reply message.replyto, "\2Groups (#{message.source.nick}):\2 #{groups.sort.join(', ')}"
         end
     end
 
@@ -199,11 +184,10 @@ class Authenticator < ModSpox::Plugin
         group = Models::Group.filter(:name => params[:group]).first
         nick = Models::Nick.locate(params[:nick])
         if(group)
-            nick.auth.group = group
-            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "Nick #{params[:nick]} has been added to the group: #{params[:group]}")
+            nick.auth.add_group(group)
+            information message.replyto, "Nick #{params[:nick]} has been added to the group: #{params[:group]}"
         else
-            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "Failed to find authentication group: #{params[:group]}")
-
+            error message.replyto, "Failed to find authentication group: #{params[:group]}"
         end
     end
 
@@ -214,29 +198,29 @@ class Authenticator < ModSpox::Plugin
         group = Models::Group.filter(:name => params[:group]).first
         nick = Helpers.find_model(params[:nick], false)
         if(group && nick)
-            nick.remove_group(group)
-            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "Removed #{params[:nick]} from the #{params[:group]} authentication group.")
+            nick.auth.remove_group(group)
+            information message.replyto, "Removed #{params[:nick]} from the #{params[:group]} authentication group."
         else
-            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "Failed to find nick: #{params[:nick]}") unless nick
-            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "Failed to find group: #{params[:group]}") unless group
+            error message.replyto, "Failed to find nick: #{params[:nick]}" unless nick
+            error message.replyto, "Failed to find group: #{params[:group]}" unless group
         end
     end
 
     # message:: ModSpox::Messages::Incoming::Privmsg
     # params:: Signature parameters
     # Send WHOIS for nick
-    def send_whois(message, params)
-        message.source.clear_auth
-        @pipeline << Messages::Outgoing::Whois.new(message.source.nick)
+    def do_ident(message, params)
+        message.source.check_masks
+        check_nickserv(message.source, true)
+        #@pipeline << Messages::Outgoing::Whois.new(message.source.nick)
     end
 
     # message:: ModSpox::Messages::Incoming::Privmsg
     # params:: Signature parameters
     # Display all available authentication groups
     def list_groups(message, params)
-        groups = []
-        Models::Group.all.each{|g| groups << g.name}
-        @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "\2Groups:\2 #{groups.join(', ')}")
+        groups = Models::Group.all.map{|g| g.name}
+        information message.replyto, "\2Groups:\2 #{groups.sort.join(', ')}"
     end
 
     # message:: ModSpox::Messages::Incoming::Privmsg
@@ -246,46 +230,57 @@ class Authenticator < ModSpox::Plugin
         group = Models::Group.filter(:name => params[:group]).first
         if(group)
             nicks = []
+            group.auths.each{|a| nicks << a.nick.nick}
             masks = []
-            Models::AuthGroup.filter(:group_id => group.pk).each do |ag|
-                if(ag.auth.nick)
-                    nicks << ag.auth.nick.nick
-                end
-                if(ag.auth.mask)
-                    masks << ag.auth.mask
-                end
-            end
+            group.auth_masks.each{|a| masks << a.map}
             output = []
             output << "\2Nicks:\2 #{nicks.join(', ')}" if nicks.size > 0
             output << "\2Masks:\2 #{masks.join(' | ')}" if masks.size > 0
-            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "\2Group #{params[:group]}:\2 #{output.join('. ')}")
+            information message.replyto, "\2Group #{params[:group]}:\2 #{output.join('. ')}"
         else
-            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "Failed to find group named: #{params[:group]}")
+            error message.replyto, "Failed to find group named: #{params[:group]}"
+        end
+    end
+
+    def check_notice(m)
+        if(m.source.is_a?(Models::Nick) && m.source.nick.downcase == 'nickserv' && m.source.host == 'dal.net')
+            message = m.message.dup
+            nick = message.slice!(0..message.index(' ')-1)
+            message.slice!(0)
+            message.slice!(0..message.index(' '))
+            setting = message.to_i
+            if(setting == 3)
+                user = Helpers.find_model(nick)
+                user.auth.services_identified = true
+                Logger.info("User has been authenticated through NickServ services. (#{user.nick})")
+            end
         end
     end
 
     # Populates array with nicks that authenticate by nickserv
     def populate_nickserv
+        @nickserv_nicks.clear
         Models::Auth.filter('services = ?', true).each do |auth|
             @nickserv_nicks << auth.nick.nick.downcase
         end
     end
 
-    def check_nickserv(nick)
+    def check_nickserv(nick, force=false)
+        populate_nickserv if @nickserv_nicks.empty?
         if(@nickserv_nicks.include?(nick.nick.downcase))
-            if(!nick.auth.authed && !@whois_cache.include?(nick.nick.downcase))
-                @pipeline << Messages::Outgoing::Whois.new(nick)
-                @whois_cache << nick.nick.downcase
+            if(force || (!nick.auth.authed && !@nickserv_cache.include?(nick.nick.downcase)))
+                @nickserv_cache << nick.nick.downcase unless @nickserv_cache.include?(nick.nick.downcase)
+                @pipeline << Messages::Outgoing::Raw.new("nickserv ACC #{nick.nick}")
             end
         end
     end
 
     def check_join(message)
-        check_nickserv(message.nick)
+        check_nickserv(message.nick) unless message.nick == me
     end
 
     def check_nicks(message)
-        message.nicks.each{|nick| check_nickserv(nick) }
+        @pipeline << Messages::Internal::TimerAdd.new(self, 20, nil, true){ message.nicks.each{|nick| check_nickserv(nick) } }
     end
 
 end

data/data/mod_spox/plugins/Banner.rb

@@ -6,33 +6,19 @@ class Banner < ModSpox::Plugin
     def initialize(pipeline)
         super
         admin = Group.find_or_create(:name => 'banner')
-        Signature.find_or_create(:signature => 'ban (\S+)', :plugin => name, :method => 'default_ban', :group_id => admin.pk,
-            :description => 'Kickban given nick from current channel').params = [:nick]
-        Signature.find_or_create(:signature => 'ban (\S+) (\S+)', :plugin => name, :method => 'channel_ban', :group_id => admin.pk,
-            :description => 'Kickban given nick from given channel').params = [:nick, :channel]
-        Signature.find_or_create(:signature => 'ban (\S+) (\S+) (\d+) ?(.+)?', :plugin => name, :method => 'full_ban', :group_id => admin.pk,
-            :description => 'Kickban given nick from given channel for given number of seconds').params = [:nick, :channel, :time, :message]
-        Signature.find_or_create(:signature => 'banmask (\S+) (\S+) (\d+) ?(.+)?', :plugin => name, :method => 'message_mask_ban', :group_id => admin.pk,
-            :description => 'Kickban given mask from given channel for given number of seconds providing an optional message'
-            ).params = [:mask, :channel, :time, :message]
-        Signature.find_or_create(:signature => 'banmask list', :plugin => name, :method => 'mask_list', :group_id => admin.pk,
-            :description => 'List all currently active banmasks')
-        Signature.find_or_create(:signature => 'banmask remove (\d+)', :plugin => name, :method => 'mask_remove', :group_id => admin.pk,
-            :description => 'Remove a currently enabled ban mask').params = [:id]
-        Signature.find_or_create(:signature => 'banlist', :plugin => name, :method => 'ban_list', :group_id => admin.pk,
-            :description => 'List all currently active bans generated from the bot')
-        Signature.find_or_create(:signature => 'banlist remove (\d+)', :plugin => name, :method => 'ban_remove', :group_id => admin.pk,
-            :description => 'Remove a current ban').params = [:id]
-        Signature.find_or_create(:signature => 'exempt mode ([ov]) ?(\S+)?', :plugin => name, :method => 'exempt_mode', :group_id => admin.pk,
-            :description => 'Exempt given modes from kick. Apply to all channels if one is not provided').params = [:mode, :channel]
-        Signature.find_or_create(:signature => 'exempt nick (\S+) ?(\S+)?', :plugin => name, :method => 'exempt_nick', :group_id => admin.pk,
-            :description => 'Exempt a nick from kicks globally or per channel').params = [:nick, :channel]
-        Signature.find_or_create(:signature => 'exempt source (\S+)', :plugin => name, :method => 'exempt_source', :group_id => admin.pk,
-            :description => 'Exempt a source from kicks globally or per channel').params = [:source, :channel]
-        Signature.find_or_create(:signature => 'exempt list (nick|mode|source)', :plugin => name, :method => 'exempt_list', :group_id => admin.pk,
-            :description => 'List current exemptions of given type').params = [:type]
-        Signature.find_or_create(:signature => 'exempt remove (nick|mode|source) (\d+)', :plugin => name, :method => 'exempt_remove', :group_id => admin.pk,
-            :description => 'Remove exemption from given type').params = [:type, :id]
+        add_sig(:sig => 'ban (\S+)', :method => :default_ban, :group => admin, :desc => 'Kickban given nick from current channel', :params => [:nick])
+        add_sig(:sig => 'ban (\S+) (\S+)', :method => :channel_ban, :group => admin, :desc => 'Kickban given nick from given channel', :params => [:nick, :channel])
+        add_sig(:sig => 'ban (\S+) (\S+) (\d+) ?(.+)?', :method => :full_ban, :group => admin, :desc => 'Kickban given nick from given channel for given number of seconds', :params => [:nick, :channel, :time, :message])
+        add_sig(:sig => 'banmask (\S+) (\S+) (\d+) ?(.+)?', :method => :message_mask_ban, :group => admin, :desc => 'Kickban given mask from given channel for given number of seconds providing an optional message', :params => [:mask, :channel, :time, :message])
+        add_sig(:sig => 'banmask list', :method => :mask_list, :group => admin, :desc => 'List all currently active banmasks')
+        add_sig(:sig => 'banmask remove (\d+)', :method => :mask_remove, :group => admin, :desc => 'Remove a currently enabled ban mask', :params => [:id])
+        add_sig(:sig => 'banlist', :method => :ban_list, :group => admin, :desc => 'List all currently active bans generated from the bot')
+        add_sig(:sig => 'banlist remove (\d+)', :method => :ban_remove, :group => admin, :desc => 'Remove a current ban', :params => [:id])
+        add_sig(:sig => 'exempt mode ([ov]) ?(\S+)?', :method => :exempt_mode, :group => admin, :desc => 'Exempt given modes from kick. Apply to all channels if one is not provided', :params => [:mode, :channel])
+        add_sig(:sig => 'exempt nick (\S+) ?(\S+)?', :method => :exempt_nick, :group => admin, :desc => 'Exempt a nick from kicks globally or per channel', :params => [:nick, :channel])
+        add_sig(:sig => 'exempt source (\S+)', :method => :exempt_source, :group => admin, :desc => 'Exempt a source from kicks globally or per channel', :params => [:source, :channel])
+        add_sig(:sig => 'exempt list (nick|mode|source)', :method => :exempt_list, :group => admin, :desc => 'List current exemptions of given type', :params => [:type])
+        add_sig(:sig => 'exempt remove (nick|mode|source) (\d+)', :method => :exempt_remove, :group => admin, :desc => 'Remove exemption from given type', :params => [:type, :id])
         @pipeline.hook(self, :mode_check, :Incoming_Mode)
         @pipeline.hook(self, :join_check, :Incoming_Join)
         @pipeline.hook(self, :who_check, :Incoming_Who)
@@ -197,7 +183,7 @@ class Banner < ModSpox::Plugin
     # List all currently active bans originating from the bot
     def ban_list(message, params)
         set = BanRecord.filter(:removed => false)
-        if(set.size > 0)
+        if(set.count > 0)
             reply(message.replyto, "Currently active bans:")
             set.each do |record|
                 remains = record.remaining.to_i - (Object::Time.now.to_i - @time.to_i)
@@ -477,16 +463,11 @@ class Banner < ModSpox::Plugin
             foreign_key :nick_id, :null => false, :table => :nicks, :key => :id
         end
 
-        before_create do
-            update_values(:stamp => Object::Time.now)
-        end
-
-        def channel
-            ModSpox::Models::Channel[channel_id]
-        end
+        many_to_one :channel, :class => ModSpox::Models::Channel
+        many_to_one :nick, :class => ModSpox::Models::Nick
 
-        def nick
-            ModSpox::Models::Nick[nick_id]
+        def before_create
+            update(:stamp => Object::Time.now)
         end
     end
 
@@ -500,9 +481,7 @@ class Banner < ModSpox::Plugin
             foreign_key :channel_id, :null => false, :table => :channels, :key => :id
         end
 
-        def channel
-            ModSpox::Models::Channel[channel_id]
-        end
+        many_to_one :channel, :class => ModSpox::Models::Channel
 
         def self.map_masks
             masks = {}
@@ -521,14 +500,9 @@ class Banner < ModSpox::Plugin
             foreign_key :nick_id, :table => :nicks, :null => false, :key => :id
             foreign_key :channel_id, :table => :channels, :key => :id
         end
-
-        def nick
-            return Models::Nick[nick_id]
-        end
-
-        def channel
-            return Models::Channel[channel_id]
-        end
+        
+        many_to_one :nick, :class => ModSpox::Models::Nick
+        many_to_one :channel, :class => ModSpox::Models::Channel
     end
 
     class BanSourceExempt < Sequel::Model
@@ -538,16 +512,14 @@ class Banner < ModSpox::Plugin
             foreign_key :channel_id, :table => :channels, :key => :id
         end
 
-        def channel
-            return Models::Channel[channel_id]
-        end
+        many_to_one :channel, :class => ModSpox::Models::Channel
 
         def mask
             return values[:source] ? Marshal.load(values[:source].unpack('m')[0]) : nil
         end
 
         def mask=(val)
-            update_values(:source => [Marshal.dump(val)].pack('m'))
+            update(:source => [Marshal.dump(val)].pack('m'))
         end
 
     end
@@ -559,10 +531,8 @@ class Banner < ModSpox::Plugin
             foreign_key :channel_id, :table => :channels, :key => :id
             index [:channel_id, :mode]
         end
-
-        def channel
-            return Models::Channel[channel_id]
-        end
+        
+        many_to_one :channel, :class => ModSpox::Models::Channel
     end
 
     class NotOperator < Exceptions::BotException