slack-smart-bot 0.9.6 → 1.0.0

data/lib/slack/smart-bot/commands/on_master/admin_master/notify_message.rb

@@ -0,0 +1,35 @@
+class SlackSmartBot
+  # helpmaster: ----------------------------------------------
+  # helpmaster: `notify MESSAGE`
+  # helpmaster: `notify all MESSAGE`
+  # helpmaster: `notify #CHANNEL_NAME MESSAGE`
+  # helpmaster:    It will send a notification message to all bot channels
+  # helpmaster:    It will send a notification message to all channels the bot joined and private conversations with the bot
+  # helpmaster:    It will send a notification message to the specified channel and to its extended channels
+  # helpmaster:    Only works if you are on Master channel and you are a master admin user
+  # helpmaster:
+  def notify_message(dest, from, where, message)
+    if ON_MASTER_BOT
+      if ADMIN_USERS.include?(from) #admin user
+        if where.nil? #not all and not channel
+          @bots_created.each do |k, v|
+            respond message, k
+          end
+          respond "Bot channels have been notified", dest
+        elsif where == "all" #all
+          myconv = client.web_client.users_conversations(exclude_archived: true, limit: 100, types: "im, public_channel,private_channel").channels
+          myconv.each do |c|
+            respond message, c.id unless c.name == MASTER_CHANNEL
+          end
+          respond "Channels and users have been notified", dest
+        else #channel
+          respond message, where
+          @bots_created[where][:extended].each do |ch|
+            respond message, @channels_id[ch]
+          end
+          respond "Bot channel and extended channels have been notified", dest
+        end
+      end
+    end
+  end
+end

data/lib/slack/smart-bot/commands/on_master/create_bot.rb

@@ -0,0 +1,94 @@
+class SlackSmartBot
+  # helpmaster: ----------------------------------------------
+  # helpmaster: `create bot on CHANNEL_NAME`
+  # helpmaster: `create cloud bot on CHANNEL_NAME`
+  # helpmaster:    creates a new bot on the channel specified
+  # helpmaster:    it will work only if you are on Master channel
+  # helpmaster:    the admins will be the master admins, the creator of the bot and the creator of the channel
+  # helpmaster:    follow the instructions in case creating cloud bots
+  # helpmaster:
+  def create_bot(dest, from, cloud, channel)
+    if ON_MASTER_BOT
+      get_channels_name_and_id() unless @channels_name.keys.include?(channel) or @channels_id.keys.include?(channel)
+      channel_id = nil
+      if @channels_name.key?(channel) #it is an id
+        channel_id = channel
+        channel = @channels_name[channel_id]
+      elsif @channels_id.key?(channel) #it is a channel name
+        channel_id = @channels_id[channel]
+      end
+      #todo: add pagination for case more than 1000 channels on the workspace
+      channels = client.web_client.conversations_list(
+        types: "private_channel,public_channel",
+        limit: "1000",
+        exclude_archived: "true",
+      ).channels
+      channel_found = channels.detect { |c| c.name == channel }
+      members = client.web_client.conversations_members(channel: @channels_id[channel]).members unless channel_found.nil?
+
+      if channel_id.nil?
+        respond "There is no channel with that name: #{channel}, please be sure is written exactly the same", dest
+      elsif channel == MASTER_CHANNEL
+        respond "There is already a bot in this channel: #{channel}", dest
+      elsif @bots_created.keys.include?(channel_id)
+        respond "There is already a bot in this channel: #{channel}, kill it before", dest
+      elsif config[:nick_id] != channel_found.creator and !members.include?(config[:nick_id])
+        respond "You need to add first to the channel the smart bot user: #{config[:nick]}", dest
+      else
+        if channel_id != config[:channel]
+          begin
+            rules_file = "slack-smart-bot_rules_#{channel_id}_#{from.gsub(" ", "_")}.rb"
+            if defined?(RULES_FOLDER)
+              rules_file = RULES_FOLDER + rules_file
+            else
+              Dir.mkdir("rules") unless Dir.exist?("rules")
+              Dir.mkdir("rules/#{channel_id}") unless Dir.exist?("rules/#{channel_id}")
+              rules_file = "./rules/#{channel_id}/" + rules_file
+            end
+            default_rules = (__FILE__).gsub(/slack\/smart-bot\/commands\/on_master\/create_bot\.rb$/, "slack-smart-bot_rules.rb")
+            File.delete(rules_file) if File.exist?(rules_file)
+            FileUtils.copy_file(default_rules, rules_file) unless File.exist?(rules_file)
+            admin_users = Array.new()
+            creator_info = client.web_client.users_info(user: channel_found.creator)
+            admin_users = [from, creator_info.user.name] + MASTER_USERS
+            admin_users.uniq!
+            @logger.info "ruby #{$0} \"#{channel}\" \"#{admin_users.join(",")}\" \"#{rules_file}\" on"
+        
+            if cloud
+              respond "Copy the bot folder to your cloud location and run `ruby #{$0} \"#{channel}\" \"#{admin_users.join(",")}\" \"#{rules_file}\" on&`", dest
+            else
+              t = Thread.new do
+                `ruby #{$0} \"#{channel}\" \"#{admin_users.join(",")}\" \"#{rules_file}\" on`
+              end
+            end
+            @bots_created[channel_id] = {
+              creator_name: from,
+              channel_id: channel_id,
+              channel_name: @channels_name[channel_id],
+              status: :on,
+              created: Time.now.strftime("%Y-%m-%dT%H:%M:%S.000Z")[0..18],
+              rules_file: rules_file,
+              admins: admin_users.join(","),
+              extended: [],
+              cloud: cloud,
+              thread: t,
+            }
+            respond "The bot has been created on channel: #{channel}. Rules file: #{File.basename rules_file}. Admins: #{admin_users.join(", ")}", dest
+            update_bots_file()
+          rescue Exception => stack
+            @logger.fatal stack
+            message = "Problem creating the bot on channel #{channel}. Error: <#{stack}>."
+            @logger.error message
+            respond message, dest
+          end
+        else
+          respond "There is already a bot in this channel: #{channel}, and it is the Master Channel!", dest
+        end
+      end
+    else
+      @logger.info MASTER_CHANNEL
+      @logger.info @channel_id.inspect
+      respond "Sorry I cannot create bots from this channel, please visit the master channel: <##{@master_bot_id}>", dest
+    end
+  end
+end

data/lib/slack/smart-bot/listen.rb

@@ -0,0 +1,36 @@
+class SlackSmartBot
+  def listen
+    @salutations = [config[:nick], "<@#{config[:nick_id]}>", "bot", "smart"]
+    @pings = []
+    get_bots_created()
+    client.on :message do |data|
+      unless data.user == "USLACKBOT"
+        treat_message(data)
+      end
+    end
+
+    restarts = 0
+    started = false
+    while restarts < 200 and !started
+      begin
+        @logger.info "Bot starting: #{config.inspect}"
+        client.start!
+      rescue Slack::RealTime::Client::ClientAlreadyStartedError
+        @logger.info "ClientAlreadyStarted so we continue with execution"
+        started = true
+      rescue Exception => e
+        started = false
+        restarts += 1
+        if restarts < 200
+          @logger.info "*" * 50
+          @logger.fatal "Rescued on starting: #{e.inspect}"
+          @logger.info "Waiting 60 seconds to retry. restarts: #{restarts}"
+          puts "#{Time.now}: Not able to start client. Waiting 60 seconds to retry: #{config.inspect}"
+          sleep 60
+        else
+          exit!
+        end
+      end
+    end
+  end
+end

data/lib/slack/smart-bot/process.rb

@@ -0,0 +1,169 @@
+require_relative "commands/general/hi_bot"
+require_relative "commands/general/bye_bot"
+require_relative "commands/general/bot_help"
+require_relative "commands/on_bot/ruby_code"
+require_relative "commands/general/use_rules"
+require_relative "commands/general/stop_using_rules"
+require_relative "commands/on_master/admin_master/exit_bot"
+require_relative "commands/on_master/admin_master/notify_message"
+require_relative "commands/on_master/admin/kill_bot_on_channel"
+require_relative "commands/on_master/create_bot"
+require_relative "commands/on_bot/admin/add_routine"
+require_relative "commands/on_bot/admin/start_bot"
+require_relative "commands/on_bot/admin/pause_bot"
+require_relative "commands/on_bot/admin/remove_routine"
+require_relative "commands/on_bot/admin/run_routine"
+require_relative "commands/on_bot/admin/pause_routine"
+require_relative "commands/on_bot/admin/start_routine"
+require_relative "commands/on_bot/admin/see_routines"
+require_relative "commands/on_bot/admin/extend_rules"
+require_relative "commands/on_bot/admin/stop_using_rules_on"
+require_relative "commands/general/bot_status"
+require_relative "commands/on_bot/add_shortcut"
+require_relative "commands/on_bot/delete_shortcut"
+require_relative "commands/on_bot/see_shortcuts"
+require_relative "commands/on_extended/bot_rules"
+
+class SlackSmartBot
+  def process(user, command, dest, dchannel, rules_file, typem, files)
+    from = user.name
+    if user.profile.display_name.to_s.match?(/\A\s*\z/)
+      user.profile.display_name = user.profile.real_name
+    end
+    display_name = user.profile.display_name
+    processed = true
+
+    on_demand = false
+    if command.match(/^@?(#{config[:nick]}):*\s+(.+)/im) or
+       command.match(/^()!(.+)/im) or
+       command.match(/^()<@#{config[:nick_id]}>\s+(.+)/im)
+      command = $2
+      on_demand = true
+    end
+
+    #todo: check :on_pg in this case
+    if typem == :on_master or typem == :on_bot or typem == :on_pg or typem == :on_dm
+      case command
+
+      when /^\s*(Hello|Hallo|Hi|Hola|What's\sup|Hey|Hæ)\s(#{@salutations.join("|")})\s*$/i
+        hi_bot(user, dest, dchannel, from, display_name)
+      when /^\s*(Bye|Bæ|Good\sBye|Adiós|Ciao|Bless|Bless\sBless|Adeu)\s(#{@salutations.join("|")})\s*$/i
+        bye_bot(dest, from, display_name)
+      when /^\s*bot\s+(rules|help)\s*(.+)?$/i, /^bot,? what can I do/i
+        $1.to_s.match?(/rules/i) ? specific = true : specific = false
+        help_command = $2
+
+        bot_help(user, from, dest, dchannel, specific, help_command, rules_file)
+      when /^\s*use\s+(rules\s+)?(from\s+)?<#C\w+\|(.+)>\s*$/i, /^use\s+(rules\s+)?(from\s+)?([^\s]+\s*$)/i
+        channel = $3
+        use_rules(dest, channel, user, dchannel)
+      when /^\s*stop using rules (from\s+)<#\w+\|(.+)>/i, /^stop using rules (from\s+)(.+)/i
+        channel = $2
+        stop_using_rules(dest, channel, user, dchannel)
+      when /^\s*extend\s+rules\s+(to\s+)<#C\w+\|(.+)>/i, /^extend\s+rules\s+(to\s+)(.+)/i,
+           /^\s*use\s+rules\s+(on\s+)<#C\w+\|(.+)>/i, /^use\s+rules\s+(on\s+)(.+)/i
+        channel = $2
+        extend_rules(dest, user, from, channel, typem)
+      when /^\s*stop using rules (on\s+)<#\w+\|(.+)>/i, /^stop using rules (on\s+)(.+)/i
+        channel = $2
+        stop_using_rules_on(dest, user, from, channel, typem)
+      when /^\s*exit\sbot\s*$/i, /^quit\sbot\s*$/i, /^close\sbot\s*$/i
+        exit_bot(command, from, dest, display_name)
+      when /^\s*start\s(this\s)?bot$/i
+        start_bot(dest, from)
+      when /^\s*pause\s(this\s)?bot$/i
+        pause_bot(dest, from)
+      when /^\s*bot\sstatus/i
+        bot_status(dest, from)
+      when /\Anotify\s+<#(C\w+)\|.+>\s+(.+)\s*\z/im, /\Anotify\s+(all)?\s*(.+)\s*\z/im
+        where = $1
+        message = $2
+        notify_message(dest, from, where, message)
+      when /^\s*create\s+(cloud\s+)?bot\s+on\s+<#C\w+\|(.+)>\s*/i, /^create\s+(cloud\s+)?bot\s+on\s+(.+)\s*/i
+        cloud = !$1.nil?
+        channel = $2
+        create_bot(dest, from, cloud, channel)
+      when /^\s*kill\sbot\son\s<#C\w+\|(.+)>\s*$/i, /^kill\sbot\son\s(.+)\s*$/i
+        channel = $1
+        kill_bot_on_channel(dest, from, channel)
+      when /^\s*(add|create)\s+routine\s+(\w+)\s+(every)\s+(\d+)\s*(days|hours|minutes|seconds|mins|min|secs|sec|d|h|m|s)\s*(\s.+)?\s*$/i,
+           /^\s*(add|create)\s+routine\s+(\w+)\s+(at)\s+(\d+:\d+:?\d+?)\s*()(\s.+)?\s*$/i
+        name = $2.downcase
+        type = $3
+        number_time = $4
+        period = $5
+        command_to_run = $6
+        add_routine(dest, from, user, name, type, number_time, period, command_to_run, files)
+      when /^\s*(kill|delete|remove)\s+routine\s+(\w+)\s*$/i
+        name = $2.downcase
+        remove_routine(dest, from, name)
+      when /^\s*(run|execute)\s+routine\s+(\w+)\s*$/i
+        name = $2.downcase
+        run_routine(dest, from, name)
+      when /^\s*pause\s+routine\s+(\w+)\s*$/i
+        name = $1.downcase
+        pause_routine(dest, from, name)
+      when /^\s*start\s+routine\s+(\w+)\s*$/i
+        name = $1.downcase
+        start_routine(dest, from, name)
+      when /^\s*see\s+(all\s+)?routines\s*$/i
+        all = $1.to_s != ""
+        see_routines(dest, from, user, all)
+      else
+        processed = false
+      end
+    else
+      processed = false
+    end
+
+    # only when :on and (listening or on demand or direct message)
+    if @status == :on and
+       (@questions.keys.include?(from) or
+        (@listening.include?(from) and typem != :on_extended) or
+        typem == :on_dm or typem == :on_pg or on_demand)
+      processed2 = true
+
+      case command
+
+      # bot rules for extended channels
+      when /^bot\s+rules\s*(.+)?$/i
+        help_command = $1
+        bot_rules(dest, help_command, typem, rules_file, from)
+      when /^\s*(add\s)?shortcut\s(for\sall)?\s*(.+)\s*:\s*(.+)/i, /^(add\s)sc\s(for\sall)?\s*(.+)\s*:\s*(.+)/i
+        for_all = $2
+        shortcut_name = $3.to_s.downcase
+        command_to_run = $4
+        add_shortcut(dest, from, typem, for_all, shortcut_name, command, command_to_run)
+      when /^\s*delete\s+shortcut\s+(.+)/i, /^delete\s+sc\s+(.+)/i
+        shortcut = $1.to_s.downcase
+        delete_shortcut(dest, from, shortcut, typem, command)
+      when /^\s*see\sshortcuts/i, /^see\ssc/i
+        see_shortcuts(dest, from, typem)
+
+        #kept to be backwards compatible
+      when /^\s*id\schannel\s<#C\w+\|(.+)>\s*/i, /^id channel (.+)/
+        unless typem == :on_extended
+          channel_name = $1
+          get_channels_name_and_id()
+          if @channels_id.keys.include?(channel_name)
+            respond "the id of #{channel_name} is #{@channels_id[channel_name]}", dest
+          else
+            respond "channel: #{channel_name} not found", dest
+          end
+        end
+      when /^\s*ruby\s(.+)/im, /^\s*code\s(.+)/im
+        code = $1
+        code.gsub!("\\n", "\n")
+        code.gsub!("\\r", "\r")
+        @logger.info code
+        ruby_code(dest, code, rules_file)
+      else
+        processed2 = false
+      end #of case
+
+      processed = true if processed or processed2
+    end
+
+    return processed
+  end
+end

data/lib/slack/smart-bot/process_first.rb

@@ -0,0 +1,201 @@
+class SlackSmartBot
+  def process_first(user, text, dest, dchannel, typem, files)
+    nick = user.name
+    rules_file = ""
+
+    if typem == :on_call
+      rules_file = RULES_FILE
+    elsif dest[0] == "C" or dest[0] == "G" # on a channel or private channel
+      rules_file = RULES_FILE
+
+      if @rules_imported.key?(user.id) and @rules_imported[user.id].key?(dchannel)
+        unless @bots_created.key?(@rules_imported[user.id][dchannel])
+          get_bots_created()
+        end
+        if @bots_created.key?(@rules_imported[user.id][dchannel])
+          rules_file = @bots_created[@rules_imported[user.id][dchannel]][:rules_file]
+        end
+      end
+    elsif dest[0] == "D" and @rules_imported.key?(user.id) and @rules_imported[user.id].key?(user.id) #direct message
+      unless @bots_created.key?(@rules_imported[user.id][user.id])
+        get_bots_created()
+      end
+      if @bots_created.key?(@rules_imported[user.id][user.id])
+        rules_file = @bots_created[@rules_imported[user.id][user.id]][:rules_file]
+      end
+    end
+
+    if nick == config[:nick] #if message is coming from the bot
+      begin
+        case text
+        when /^Bot has been (closed|killed) by/i
+          if CHANNEL == @channels_name[dchannel]
+            @logger.info "#{nick}: #{text}"
+            exit!
+          end
+        when /^Changed status on (.+) to :(.+)/i
+          channel_name = $1
+          status = $2
+          if ON_MASTER_BOT or CHANNEL == channel_name
+            @bots_created[@channels_id[channel_name]][:status] = status.to_sym
+            update_bots_file()
+            if CHANNEL == channel_name
+              @logger.info "#{nick}: #{text}"
+            else #on master bot
+              @logger.info "Changed status on #{channel_name} to :#{status}"
+            end
+          end
+        when /extended the rules from (.+) to be used on (.+)\.$/i
+          from_name = $1
+          to_name = $2
+          if ON_MASTER_BOT and @bots_created[@channels_id[from_name]][:cloud]
+            @bots_created[@channels_id[from_name]][:extended] << to_name
+            @bots_created[@channels_id[from_name]][:extended].uniq!
+            update_bots_file()
+          end
+        when /removed the access to the rules of (.+) from (.+)\.$/i
+          from_name = $1
+          to_name = $2
+          if ON_MASTER_BOT and @bots_created[@channels_id[from_name]][:cloud]
+            @bots_created[@channels_id[from_name]][:extended].delete(to_name)
+            update_bots_file()
+          end
+        end
+
+        return :next #don't continue analyzing #jal
+      rescue Exception => stack
+        @logger.fatal stack
+        return :next #jal
+      end
+    end
+
+    #only for shortcuts
+    if text.match(/^@?(#{config[:nick]}):*\s+(.+)\s*/im) or
+       text.match(/^()!\s*(.+)\s*/im) or
+       text.match(/^()<@#{config[:nick_id]}>\s+(.+)\s*/im)
+      command = $2
+      addexcl = true
+    else
+      addexcl = false
+      command = text.downcase.lstrip.rstrip
+    end
+    if command.scan(/^(shortcut|sc)\s+([^:]+)\s*$/i).any? or
+       (@shortcuts.keys.include?(:all) and @shortcuts[:all].keys.include?(command)) or
+       (@shortcuts.keys.include?(nick) and @shortcuts[nick].keys.include?(command))
+      command = $2.downcase unless $2.nil?
+      if @shortcuts.keys.include?(nick) and @shortcuts[nick].keys.include?(command)
+        text = @shortcuts[nick][command].dup
+      elsif @shortcuts.keys.include?(:all) and @shortcuts[:all].keys.include?(command)
+        text = @shortcuts[:all][command].dup
+      else
+        respond "Shortcut not found", dest unless dest[0] == "C" and dchannel != dest #on extended channel
+        return :next #jal
+      end
+      text = "!" + text if addexcl and text[0] != "!"
+    end
+
+    command = text
+
+    begin
+      t = Thread.new do
+        begin
+          Thread.current[:dest] = dest
+          Thread.current[:user] = user
+          Thread.current[:command] = command
+          Thread.current[:rules_file] = rules_file
+          processed = process(user, command, dest, dchannel, rules_file, typem, files)
+          @logger.info "command: #{nick}> #{command}" if processed
+          on_demand = false
+          if command.match(/^@?(#{config[:nick]}):*\s+(.+)/im) or
+             command.match(/^()!(.+)/im) or
+             command.match(/^()<@#{config[:nick_id]}>\s+(.+)/im)
+            command = $2
+            Thread.current[:command] = command
+            on_demand = true
+          end
+          if @status == :on and
+             (@questions.keys.include?(nick) or
+              (@listening.include?(nick) and typem != :on_extended) or
+              dest[0] == "D" or on_demand)
+            @logger.info "command: #{nick}> #{command}" unless processed
+            #todo: verify this
+
+            if dest[0] == "C" or dest[0] == "G" or (dest[0] == "D" and typem == :on_call)
+              if typem != :on_call and @rules_imported.key?(user.id) and @rules_imported[user.id].key?(dchannel)
+                if @bots_created.key?(@rules_imported[user.id][dchannel])
+                  if @bots_created[@rules_imported[user.id][dchannel]][:status] != :on
+                    respond "The bot on that channel is not :on", dest
+                    rules_file = ""
+                  end
+                end
+              end
+              unless rules_file.empty?
+                begin
+                  eval(File.new(rules_file).read) if File.exist?(rules_file)
+                rescue Exception => stack
+                  @logger.fatal "ERROR ON RULES FILE: #{rules_file}"
+                  @logger.fatal stack
+                end
+                if defined?(rules)
+                  command[0] = "" if command[0] == "!"
+                  command.gsub!(/^@\w+:*\s*/, "")
+                  if method(:rules).parameters.size == 4
+                    rules(user, command, processed, dest)
+                  elsif method(:rules).parameters.size == 5
+                    rules(user, command, processed, dest, files)
+                  else
+                    rules(user, command, processed, dest, files, rules_file)
+                  end
+                else
+                  @logger.warn "It seems like rules method is not defined"
+                end
+              end
+            elsif @rules_imported.key?(user.id) and @rules_imported[user.id].key?(user.id)
+              if @bots_created.key?(@rules_imported[user.id][user.id])
+                if @bots_created[@rules_imported[user.id][user.id]][:status] == :on
+                  begin
+                    eval(File.new(rules_file).read) if File.exist?(rules_file)
+                  rescue Exception => stack
+                    @logger.fatal "ERROR ON imported RULES FILE: #{rules_file}"
+                    @logger.fatal stack
+                  end
+                else
+                  respond "The bot on <##{@rules_imported[user.id][user.id]}|#{@bots_created[@rules_imported[user.id][user.id]][:channel_name]}> is not :on", dest
+                  rules_file = ""
+                end
+              end
+
+              unless rules_file.empty?
+                if defined?(rules)
+                  command[0] = "" if command[0] == "!"
+                  command.gsub!(/^@\w+:*\s*/, "")
+                  if method(:rules).parameters.size == 4
+                    rules(user, command, processed, dest)
+                  elsif method(:rules).parameters.size == 5
+                    rules(user, command, processed, dest, files)
+                  else
+                    rules(user, command, processed, dest, files, rules_file)
+                  end
+                else
+                  @logger.warn "It seems like rules method is not defined"
+                end
+              end
+            else
+              @logger.info "it is a direct message with no rules file selected so no rules file executed."
+              if command.match?(/^\s*bot\s+rules\s*$/i)
+                respond "No rules running. You can use the command `use rules from CHANNEL` to specify the rules you want to use on this private conversation.\n`bot help` to see available commands.", dest
+              end
+              unless processed
+                dont_understand(__FILE__, command, user, dest)
+              end
+            end
+          end
+        rescue Exception => stack
+          @logger.fatal stack
+        end
+      end
+    rescue => e
+      @logger.error "exception: #{e.inspect}"
+    end
+  end
+end