slack-smart-bot 1.10.0 → 1.11.0

data/lib/slack/smart-bot/commands/general/bot_help.rb

@@ -1,6 +1,6 @@
 class SlackSmartBot
 
-  def bot_help(user, from, dest, dchannel, specific, help_command, rules_file, savestats=true)
+  def bot_help(user, from, dest, dchannel, specific, help_command, rules_file, savestats: true, strict: false)
     save_stats(__method__) if savestats
     output = []
     if has_access?(__method__, user)
@@ -21,16 +21,25 @@ class SlackSmartBot
       commands_search = []
       if help_command.to_s != ""
         help_message.gsub(/====+/,'-'*30).split(/^\s*-------*$/).each do |h|
-          if h.match?(/[`_]#{help_command}/i) or h.match?(/^\s*command_id:\s+:#{help_command.gsub(' ', '_')}\s*$/)
-            output << h
-            help_found = true
-            commands << h
-          elsif !h.match?(/\A\s*\*/) and !h.match?(/\A\s*=+/) #to avoid general messages for bot help *General commands...*
-            all_found = true
-            help_command.to_s.split(' ') do |hc|
-              unless hc.match?(/^\s*\z/)
-                if !h.match?(/#{hc}/i)
-                  all_found = false                  
+          if strict
+            if h.match?(/`#{help_command}`/i) or h.match?(/^\s*command_id:\s+:#{help_command.gsub(' ', '_')}\s*$/)
+              output << h
+              help_found = true
+              commands << h
+              break
+            end
+          else
+            if h.match?(/[`_]#{help_command}/i) or h.match?(/^\s*command_id:\s+:#{help_command.gsub(' ', '_')}\s*$/)
+              output << h
+              help_found = true
+              commands << h
+            elsif !h.match?(/\A\s*\*/) and !h.match?(/\A\s*=+/) #to avoid general messages for bot help *General commands...*
+              all_found = true
+              help_command.to_s.split(' ') do |hc|
+                unless hc.match?(/^\s*\z/)
+                  if !h.match?(/#{hc}/i)
+                    all_found = false                  
+                  end
                 end
               end
             end

data/lib/slack/smart-bot/commands/general/delete_announcement.rb

@@ -8,7 +8,7 @@ class SlackSmartBot
       else
         channel = Thread.current[:dest]
       end
-      if File.exists?("#{config.path}/announcements/#{channel}.csv") and !@announcements.key?(channel)
+      if File.exist?("#{config.path}/announcements/#{channel}.csv") and !@announcements.key?(channel)
         t = CSV.table("#{config.path}/announcements/#{channel}.csv", headers: ['message_id', 'user_deleted', 'user_created', 'date', 'time', 'type', 'message'])
         @announcements[channel] = t
       end

data/lib/slack/smart-bot/commands/general/delete_share.rb

@@ -8,7 +8,7 @@ class SlackSmartBot
       else
         channel = Thread.current[:dest]
       end
-      if File.exists?("#{config.path}/shares/#{@channels_name[channel]}.csv") and !@shares.key?(@channels_name[channel])
+      if File.exist?("#{config.path}/shares/#{@channels_name[channel]}.csv") and !@shares.key?(@channels_name[channel])
         t = CSV.table("#{config.path}/shares/#{@channels_name[channel]}.csv", headers: ['share_id', 'user_deleted', 'user_created', 'date', 'time', 'type', 'to_channel', 'condition'])
         @shares[@channels_name[channel]] = t
       end

data/lib/slack/smart-bot/commands/general/delete_team.rb

@@ -0,0 +1,34 @@
+class SlackSmartBot
+  def delete_team(user, team_name)
+    save_stats(__method__) if answer.empty?
+
+    if Thread.current[:dest][0] == "D"
+      respond "This command cannot be called from a DM"
+    else
+      get_teams()
+      if !@teams.key?(team_name.to_sym)
+        respond "It seems like the team *#{team_name}* doesn't exist.\nRelated commands `add team TEAM_NAME PROPERTIES`, `see team TEAM_NAME`, `see teams`"
+      elsif !(@teams[team_name.to_sym].members.values + [@teams[team_name.to_sym].creator] + config.masters).flatten.include?(user.name)
+        respond "You have to be a member of the team, the creator or a Master admin to be able to delete this team."
+      else
+        if answer.empty?
+          ask "do you really want to delete the #{team_name} team? (yes/no)"
+        else
+          case answer
+          when /yes/i, /yep/i, /sure/i
+            answer_delete
+            @teams.delete(team_name.to_sym)
+            update_teams()
+            respond "The team #{team_name} has been deleted."
+          when /no/i, /nope/i, /cancel/i
+            answer_delete
+            respond "Ok, the team was not deleted"
+          else
+            respond "I don't understand"
+            ask "do you really want to delete the #{team_name} team? (yes/no)"  
+          end
+        end
+      end
+    end
+  end
+end

data/lib/slack/smart-bot/commands/general/deny_access.rb

@@ -0,0 +1,36 @@
+class SlackSmartBot
+  def deny_access(user, command_id)
+    save_stats(__method__)
+    not_allowed = ['hi_bot', 'bye_bot', "allow_access", "deny_access", "get_bot_logs", "add_routine", "pause_bot", "pause_routine", "remove_routine", "run_routine", "start_bot",
+                   "start_routine", "delete_message", "send_message", "kill_bot_on_channel", "exit_bot", "notify_message", "publish_announcements", "set_general_message",
+                   "set_maintenance", 'bot_help', 'bot_rules']
+    if !is_admin?(user.name)
+      respond "Only admins of this channel can use this command. Take a look who is an admin of this channel by calling `see admins`"
+    elsif Thread.current[:dest][0] == "D"
+      respond "This command cannot be called from a DM"
+    elsif not_allowed.include?(command_id)
+      respond "Sorry but the access for `#{command_id}` cannot be changed."
+    else
+      if Thread.current[:typem] == :on_call
+        channel = Thread.current[:dchannel]
+      elsif Thread.current[:using_channel].to_s == ""
+        channel = Thread.current[:dest]
+      else
+        channel = Thread.current[:using_channel]
+      end
+      command_ids = get_command_ids()
+      if command_ids.values.flatten.include?(command_id)
+        if !@access_channels.key?(channel)
+          @access_channels[channel] = {}
+        end
+
+        @access_channels[channel][command_id] = []
+
+        update_access_channels()
+        respond "The command `#{command_id}` won't be available in this channel. Call `allow access #{command_id}` if you want it back."
+      else
+        respond "It seems like #{command_id} is not valid. Please be sure that exists by calling `see command ids`"
+      end
+    end
+  end
+end

data/lib/slack/smart-bot/commands/general/ping_team.rb

@@ -0,0 +1,100 @@
+class SlackSmartBot
+  def ping_team(user, type, team_name, member_type, message)
+    if type == :ping
+      save_stats(:ping_team)
+      icon = ':large_green_circle:'
+    else
+      save_stats(:contact_team)
+      icon = ':email:'
+    end
+    if Thread.current[:dest][0] == "D"
+      respond "This command cannot be called from a DM"
+    else
+      get_teams()
+      if !@teams.key?(team_name.to_sym)
+        respond "It seems like the team *#{team_name}* doesn't exist.\nRelated commands `add team TEAM_NAME PROPERTIES`, `see team TEAM_NAME`, `see teams`"
+      else
+        team = @teams[team_name.to_sym].deep_copy
+
+        assigned_members = team.members.values.flatten
+        assigned_members.uniq!
+        assigned_members.dup.each do |m|
+          user_info = @users.select { |u| u.id == m or (u.key?(:enterprise_user) and u.enterprise_user.id == m) or u.name == m or (u.key?(:enterprise_user) and u.enterprise_user.name == m) }[-1]
+          assigned_members.delete(m) if user_info.nil? or user_info.deleted
+        end
+        unassigned_members = []
+        not_on_team_channel = []
+
+        if ((!team.members.key?(member_type) or member_type == 'all') and team.channels.key?("members"))
+          team_members = []
+          team.channels["members"].each do |ch|
+            get_channels_name_and_id() unless @channels_id.key?(ch)
+            tm = get_channel_members(@channels_id[ch])
+            tm.each do |m|
+              user_info = @users.select { |u| u.id == m or (u.key?(:enterprise_user) and u.enterprise_user.id == m) }[-1]
+              team_members << user_info.name unless user_info.nil? or user_info.is_app_user or user_info.is_bot or user_info.deleted
+            end
+          end
+          team_members.flatten!
+          team_members.uniq!
+          unassigned_members = team_members - assigned_members
+          unassigned_members.delete(config.nick)
+
+          unless unassigned_members.empty?
+            um = unassigned_members.dup
+            um.each do |m|
+              user_info = @users.select { |u| u.name == m or (u.key?(:enterprise_user) and u.enterprise_user.name == m) }[-1]
+              unless user_info.nil? or user_info.profile.title.to_s=='' or user_info.deleted
+                team.members[user_info.profile.title.to_snake_case] ||= []
+                team.members[user_info.profile.title.to_snake_case] << m
+                unassigned_members.delete(m)
+              end
+            end
+            unless unassigned_members.empty?
+              team.members["unassigned"] ||= []
+              team.members["unassigned"] += unassigned_members
+              team.members["unassigned"].sort!
+            end
+          end
+        end
+
+        if team.members.key?(member_type) or member_type=='all'
+          if member_type == 'all'
+            members_list = team.members.values.flatten.uniq.shuffle
+          else
+            members_list = team.members[member_type].shuffle
+          end
+          if type == :ping
+            active_members = []
+            members_list.each do |member|
+              member_info = @users.select { |u| u.name == member }[-1]
+              unless member_info.nil? or member_info.deleted
+                active = (get_presence(member_info.id).presence.to_s == "active")
+                active_members << member if active
+              end
+            end
+            members = active_members
+          else
+            members = members_list
+          end
+          members.dup.each do |m|
+            user_info = @users.select { |u| u.id == m or (u.key?(:enterprise_user) and u.enterprise_user.id == m) or u.name == m or (u.key?(:enterprise_user) and u.enterprise_user.name == m) }[-1]
+            members.delete(m) if user_info.nil? or user_info.deleted
+          end
+  
+          if members.size > 0
+            respond "#{icon} *#{type} #{team_name} team #{member_type}*\nfrom <@#{user.name}>\nto <@#{members[0..9].join('>, <@')}>#{", #{members[10..-1].join(', ')}" if members.size > 10} \n> #{message.split("\n").join("\n> ")}"
+          elsif type == :ping
+            respond "It seems like there are no available #{member_type} members on #{team_name} team. Please call `see team #{team_name}`"
+          else
+            respond "It seems like there are no #{member_type} members on #{team_name} team. Please call `see team #{team_name}`"
+          end
+        else
+          respond "The member type #{member_type} doesn't exist, please call `see team #{team_name}`"
+        end        
+
+
+      end
+    end
+  end
+end

data/lib/slack/smart-bot/commands/general/poster.rb

@@ -0,0 +1,116 @@
+def poster(permanent, emoticon_text, emoticon_bg, string, minutes)
+  chars = { a: ["0000", "1111", "1001", "1111", "1001", "1001", "0000"],
+            b: ["0000", "1111", "1001", "1110", "1001", "1111", "0000"],
+            c: ["0000", "0111", "1000", "1000", "1000", "0111", "0000"],
+            d: ["0000", "1110", "1001", "1001", "1001", "1110", "0000"],
+            e: ["0000", "1111", "1000", "1110", "1000", "1111", "0000"],
+            f: ["0000", "1111", "1000", "1110", "1000", "1000", "0000"],
+            g: ["0000", "1111", "1000", "1011", "1001", "1111", "0000"],
+            h: ["0000", "1001", "1001", "1111", "1001", "1001", "0000"],
+            i: ["000", "111", "010", "010", "010", "111", "000"],
+            j: ["0000", "0111", "0010", "0010", "1010", "0110", "0000"],
+            k: ["0000", "1001", "1010", "1100", "1010", "1001", "0000"],
+            l: ["000", "100", "100", "100", "100", "111", "000"],
+            m: ["00000", "10001", "11011", "10101", "10001", "10001", "00000"],
+            n: ["00000", "10001", "11001", "10101", "10011", "10001", "00000"],
+            o: ["0000", "0110", "1001", "1001", "1001", "0110", "0000"],
+            p: ["0000", "1110", "1001", "1110", "1000", "1000", "0000"],
+            q: ["00000", "01100", "10010", "10010", "10010", "01111", "00000"],
+            r: ["0000", "1110", "1001", "1110", "1010", "1001", "0000"],
+            s: ["0000", "0111", "1000", "0110", "0001", "1110", "0000"],
+            t: ["00000", "11111", "00100", "00100", "00100", "00100", "00000"],
+            u: ["00000", "10001", "10001", "10001", "10001", "01110", "00000"],
+            v: ["00000", "10001", "10001", "10001", "01010", "00100", "00000"],
+            w: ["0000000", "1000001", "1000001", "1001001", "1010101", "0100010", "0000000"],
+            x: ["00000", "10001", "01010", "00100", "01010", "10001", "00000"],
+            y: ["00000", "10001", "01010", "00100", "00100", "00100", "00000"],
+            z: ["00000", "11111", "00010", "00100", "01000", "11111", "00000"],
+            '!': ["0", "1", "1", "1", "0", "1", "0"],
+            '+': ["000", "000", "010", "111", "010", "000", "000"],
+            '-': ["000", "000", "000", "111", "000", "000", "000"],
+            '=': ["000", "000", "111", "000", "111", "000", "000"],
+            '?': ["000", "111", "001", "010", "000", "010", "000"],
+            '0': ["000", "111", "101", "101", "101", "111", "000"],
+            '1': ["00", "01", "11", "01", "01", "01", "00"],
+            '2': ["000", "111", "001", "010", "100", "111", "000"],
+            '3': ["000", "111", "001", "111", "001", "111", "000"],
+            '4': ["000", "101", "101", "111", "001", "001", "000"],
+            '5': ["000", "111", "100", "111", "001", "111", "000"],
+            '6': ["000", "111", "100", "111", "101", "111", "000"],
+            '7': ["000", "111", "001", "010", "100", "100", "000"],
+            '8': ["000", "111", "101", "111", "101", "111", "000"],
+            '9': ["000", "111", "101", "111", "001", "111", "000"],
+            ' ': ["0", "0", "0", "0", "0", "0", "0"] }
+
+  emoticon_bg = ":white_square:" if emoticon_bg.to_s == ""
+  emoticon_text = ":black_square:" if emoticon_text.to_s == ""
+  string.downcase!
+  messages = []
+
+  string = string.strip.split(" ").join(" ")
+  lines = [""]
+  string.split(" ").each do |t|
+    if ("#{lines[-1]}#{t}").size <= 6
+      lines[-1] = "#{lines[-1]}#{t} "
+    else
+      lines[-1].strip!
+      lines.pop if lines[-1] == ""
+      if t.size > 6
+        t.chars.each_slice(6).map(&:join).each do |tt|
+          lines << tt.strip
+        end
+        lines[-1] += " " if lines[-1].size < 6
+      else
+        lines << t.strip + " "
+      end
+    end
+  end
+  lines[-1].strip!
+  messages = []
+  lines.each do |line|
+    results = []
+    all_spaces = true
+    line.each_char do |char|
+      if chars.key?(char.to_sym)
+        results << chars[char.to_sym]
+        all_spaces = false
+      else
+        results << chars[:' ']
+      end
+    end
+    unless all_spaces
+      rtxt = ""
+      7.times do |n|
+        results.size.times do |i|
+          rtxt += "0#{results[i][n]}0"
+        end
+        rtxt += "\n"
+      end
+      rtxt.gsub!("1", emoticon_text)
+      rtxt.gsub!("0", emoticon_bg)
+      txt = ""
+      msgs = []
+      rtxt.split("\n").each do |m|
+        if (m + txt).size > 4000
+          msgs << txt unless txt == ""
+          txt = ""
+        end
+        txt += (m + "\n")
+      end
+      msgs << txt
+      msgs.flatten!
+      msgs.each do |msg|
+        messages << respond(msg, return_message: true)
+      end
+    end
+  end
+  unless permanent
+    react :heavy_check_mark
+    sleep (minutes.to_i * 60)
+    messages.delete(nil)
+    messages.each do |message|
+      delete(message.channel, message.ts)
+    end
+    react :heavy_minus_sign
+  end
+end

data/lib/slack/smart-bot/commands/general/remove_admin.rb

@@ -0,0 +1,58 @@
+class SlackSmartBot
+  def remove_admin(user, admin_user)
+    save_stats(__method__)
+    if Thread.current[:dest][0]=='D'
+      respond "This command cannot be called from a DM"
+    else
+
+      if Thread.current[:typem] == :on_call
+        channel = Thread.current[:dchannel]
+      elsif Thread.current[:using_channel].to_s==''
+        channel = Thread.current[:dest]
+      else
+        channel = Thread.current[:using_channel]
+      end
+      messages = []
+      admins = config.masters.dup
+      channels = get_channels()
+      channel_found = channels.detect { |c| c.id == channel }
+      if !channel_found.nil? and channel_found.creator.to_s != ''
+        creator_info = @users.select{|u| u.id == channel_found.creator or (u.key?(:enterprise_user) and u.enterprise_user.id == channel_found.creator)}[-1]
+        admins << creator_info.name
+      end
+      if Thread.current[:typem] == :on_bot or Thread.current[:typem] == :on_master
+        admins << config.admins.dup
+      end
+      if @admins_channels.key?(channel) and @admins_channels[channel].size > 0
+        admins << @admins_channels[channel]
+      end
+      admins.flatten!
+      admins.uniq!
+      admins.delete(nil)
+      if admins.include?(user.name)
+        admin_info = @users.select{|u| u.id == admin_user or (u.key?(:enterprise_user) and u.enterprise_user.id == admin_user)}[-1]
+        if creator_info.name == admin_info.name
+          messages << "This user created the channel and cannot be removed as an admin."
+        elsif config.masters.include?(admin_info.name) or config.masters.include?(admin_user)
+          messages << "Master admins cannot be removed as admins of this channel."
+        elsif config.admins.include?(admin_info.name) or config.admins.include?(admin_user)
+          messages << "This user is a defaulted admin for this channel and cannot be removed using this command."
+        elsif !admins.include?(admin_info.name)
+          messages << "This user is not an admin of this channel."
+        else
+          @admins_channels[channel] ||= []
+          @admins_channels[channel].delete(admin_info.name)
+          update_admins_channels()
+          messages << "The user is not an admin of this channel from now on."
+          admins.delete(admin_info.name)
+        end
+        messages << "*Admins*: <@#{admins.join('>, <@')}>"
+      else
+        messages << "Only the creator of the channel, Master admins or admins can remove an admin of this channel."
+        messages << "*Admins*: <@#{admins.join('>, <@')}>"
+      end
+
+      respond messages.join("\n")
+    end
+  end
+end

data/lib/slack/smart-bot/commands/general/see_access.rb

@@ -0,0 +1,24 @@
+class SlackSmartBot
+  def see_access(command_id)
+    save_stats(__method__)
+    if Thread.current[:typem] == :on_call
+      channel = Thread.current[:dchannel]
+    elsif Thread.current[:using_channel].to_s == ""
+      channel = Thread.current[:dest]
+    else
+      channel = Thread.current[:using_channel]
+    end
+    command_ids = get_command_ids()
+    if command_ids.values.flatten.include?(command_id)
+      if @access_channels.key?(channel) and @access_channels[channel].key?(command_id) and @access_channels[channel][command_id].size > 0
+        respond "Only these users have access to `#{command_id}` in this channel: <@#{@access_channels[channel][command_id].join(">, <@")}>"
+      elsif @access_channels.key?(channel) and @access_channels[channel].key?(command_id) and @access_channels[channel][command_id].empty?
+        respond "`#{command_id}` is not possible to be used in this channel. Please contact an admin if you want to use it."
+      else
+        respond "`#{command_id}` seems to be available in this channel."
+      end
+    else
+      respond "It seems like #{command_id} is not valid. Please be sure that exists by calling `see command ids`"
+    end
+  end
+end

data/lib/slack/smart-bot/commands/general/see_admins.rb

@@ -0,0 +1,33 @@
+class SlackSmartBot
+  def see_admins()
+    save_stats(__method__)
+    if Thread.current[:typem] == :on_call
+      channel = Thread.current[:dchannel]
+    elsif Thread.current[:using_channel].to_s==''
+      channel = Thread.current[:dest]
+    else
+      channel = Thread.current[:using_channel]
+    end
+
+    messages = []
+    admins = []
+    channels = get_channels()
+    channel_found = channels.detect { |c| c.id == channel }
+    if !channel_found.nil? and channel_found.creator.to_s != ''
+      messages << "*Channel creator*: <@#{channel_found.creator}>" 
+      creator_info = @users.select{|u| u.id == channel_found.creator or (u.key?(:enterprise_user) and u.enterprise_user.id == channel_found.creator)}[-1]
+    else
+      creator_info = {name: []}
+    end
+    messages << "*Master admins*: <@#{config.masters.join('>, <@')}>"
+    if Thread.current[:typem] == :on_bot or Thread.current[:typem] == :on_master
+      admins = config.admins.dup
+    end
+    if @admins_channels.key?(channel) and @admins_channels[channel].size > 0
+      admins = (@admins_channels[channel] + admins).uniq
+    end
+    admins = admins - config.masters - [creator_info.name]
+    messages << "*Admins*: <@#{admins.join('>, <@')}>" unless admins.empty?
+    respond messages.join("\n")
+  end
+end

data/lib/slack/smart-bot/commands/general/see_announcements.rb

@@ -3,7 +3,7 @@ class SlackSmartBot
   def see_announcements(user, type, channel, mention=false, publish=false)
     save_stats(__method__)
     typem = Thread.current[:typem]
-    general_message = "\nRelated commands `add announcement MESSAGE`, `delete announcement ID`"
+    general_message = ""
     if channel == ''
       if typem == :on_call
         channel = Thread.current[:dchannel]
@@ -51,7 +51,7 @@ class SlackSmartBot
           see_announcements_on_demand = false
         end
         if channel_id == Thread.current[:dest] or see_announcements_on_demand or publish #master admin user or publish_announcements
-          if File.exists?("#{config.path}/announcements/#{channel_id}.csv") and (!@announcements.key?(channel_id) or see_announcements_on_demand) # to force to have the last version that maybe was updated by other SmartBot in case of demand
+          if File.exist?("#{config.path}/announcements/#{channel_id}.csv") and (!@announcements.key?(channel_id) or see_announcements_on_demand) # to force to have the last version that maybe was updated by other SmartBot in case of demand
             t = CSV.table("#{config.path}/announcements/#{channel_id}.csv", headers: ['message_id', 'user_deleted', 'user_created', 'date', 'time', 'type', 'message'])
             @announcements[channel_id] = t
           end
@@ -70,6 +70,8 @@ class SlackSmartBot
                   user_created = "<@#{m[:user_created]}>"
                 else
                   user_created = m[:user_created]
+                  user_info = @users.select { |u| u.name == user_created or (u.key?(:enterprise_user) and u.enterprise_user.name == user_created) }[-1]
+                  user_created = user_info.profile.display_name unless user_info.nil?
                 end
                 if type == 'all' and channel_id[0]=='D'
                   message << "\t#{m[:message_id]} #{emoji} *_#{m[:date]}_* #{m[:time]} *:* \t*private*"
@@ -88,8 +90,8 @@ class SlackSmartBot
               else
                 message.unshift("*Announcements for channel <##{channel_id}>*")
               end
-              message << general_message
-              respond message.join("\n"), dest
+              message << general_message unless general_message.empty?
+              respond message.join("\n"), dest, unfurl_links: false, unfurl_media: false
             else
               if typem == :on_dm and channel_id[0]=='D'
                 respond("There are no #{type} announcements#{general_message}", dest) unless type == 'all'

data/lib/slack/smart-bot/commands/general/see_command_ids.rb

@@ -0,0 +1,29 @@
+class SlackSmartBot
+  def see_command_ids()
+    save_stats(__method__)
+    commands = get_command_ids()
+
+    respond "*General Commands*: #{(commands[:general]+commands[:general_commands]).sort.join(' / ')}" unless commands[:general].empty?
+
+    respond "*On Bot general*: #{commands[:on_bot_general].sort.join(' / ')}" unless commands[:on_bot_general].empty?
+
+    respond "*On Bot on demand*: #{commands[:on_bot_on_demand].sort.join(' / ')}" unless commands[:on_bot_on_demand].empty?
+
+    respond "*On Bot admin*: #{commands[:on_bot_admin].sort.join(' / ')}" unless commands[:on_bot_admin].empty?
+    
+    respond "*On Bot master admin*: #{commands[:on_bot_master_admin].sort.join(' / ')}" unless commands[:on_bot_master_admin].empty?
+
+    respond "*On extended*: #{commands[:on_extended].sort.join(' / ')}" unless commands[:on_extended].empty?
+
+    respond "*On Master*: #{commands[:on_master].sort.join(' / ')}" unless commands[:on_master].empty?
+
+    respond "*On Master admin*: #{commands[:on_master_admin].sort.join(' / ')}" unless commands[:on_master_admin].empty?
+    
+    respond "*On Master master admin*: #{commands[:on_master_master_admin].sort.join(' / ')}" unless commands[:on_master_master_admin].empty?
+
+    respond "*General Rules*: #{commands[:general_rules].sort.join(' / ')}" unless commands[:general_rules].empty?
+
+    respond "*Rules*: #{commands[:rules].sort.join(' / ')}" unless commands[:rules].empty?
+
+  end
+end

data/lib/slack/smart-bot/commands/general/see_favorite_commands.rb

@@ -15,14 +15,13 @@ class SlackSmartBot
         respond "There is no data stored."
       else
         count_commands = {}
+        
         files.each do |file|
           CSV.foreach(file, headers: true, header_converters: :symbol, converters: :numeric) do |row|
             row[:dest_channel_id] = row[:bot_channel_id] if row[:dest_channel_id].to_s[0] == "D"
-            
-            if ((only_mine and row[:user_name]==user.name) or (!only_mine and !config.admins.include?(row[:user_name]))) and 
+            if ((only_mine and row[:user_name]==user.name) or (!only_mine and !config.masters.include?(row[:user_name]))) and 
               row[:dest_channel_id] == channel and !row[:user_name].include?('routine/') and 
               row[:command] != 'dont_understand'
-
               row[:command] = 'bot_help' if row[:command] == 'bot_rules'
               count_commands[row[:command]] ||= 0
               count_commands[row[:command]] += 1
@@ -41,7 +40,7 @@ class SlackSmartBot
           commands.each do |command|
             unless output.match?(/^\s*command_id:\s+:#{command}\s*$/)
               i+=1
-              output += bot_help(user, user.name, Thread.current[:dest], channel, false, command.gsub('_',' '), config.rules_file, false)
+              output += bot_help(user, user.name, Thread.current[:dest], channel, false, command.gsub('_',' '), config.rules_file, savestats: false, strict: true)
               break if i>=5
             end
           end

data/lib/slack/smart-bot/commands/general/see_statuses.rb

@@ -22,6 +22,12 @@ class SlackSmartBot
     members = get_channel_members(cdest)
     if members.include?(user.id)
       list = {}
+      only_active = false
+      if types == ['available']
+        only_active = true
+        not_on = true
+        types = [':palm_tree:', ':spiral_calendar_pad:', ':face_with_thermometer:']
+      end
       members.each do |member|
         info = get_user_info(member)
         text = info.user.profile.status_text
@@ -29,26 +35,33 @@ class SlackSmartBot
         exp = info.user.profile.expiration
         unless (((!types.empty? and !types.include?(emoji)) or (emoji.to_s == "" and text.to_s == "" and exp.to_s == "")) and !not_on) or
                (not_on and types.include?(emoji)) or info.user.deleted or info.user.is_bot or info.user.is_app_user
-          emoji = ":white_square:" if emoji.to_s == ""
-          list[emoji] ||= []
-          list[emoji] << {
-            type: "context",
-            elements: [
-              {
-                          type: "plain_text",
-                          text: "\t\t",
-                        },
-              {
-                          type: "image",
-                          image_url: info.user.profile.image_24,
-                          alt_text: info.user.name,
-                        },
-              {
-                          type: "mrkdwn",
-                          text: " *#{info.user.profile.real_name}* (#{info.user.name}) #{text} #{exp}",
-                        },
-            ],
-          }
+          if only_active
+            active = (get_presence(member).presence.to_s == 'active')
+          else
+            active = false
+          end
+          if !only_active or (only_active and active)
+            emoji = ":white_square:" if emoji.to_s == ""
+            list[emoji] ||= []
+            list[emoji] << {
+              type: "context",
+              elements: [
+                {
+                            type: "plain_text",
+                            text: "\t\t",
+                          },
+                {
+                            type: "image",
+                            image_url: info.user.profile.image_24,
+                            alt_text: info.user.name,
+                          },
+                {
+                            type: "mrkdwn",
+                            text: " *#{info.user.profile.real_name}* (#{info.user.name}) #{text} #{exp}",
+                          },
+              ],
+            }
+          end
         end
       end
       if list.size > 0
@@ -59,7 +72,7 @@ class SlackSmartBot
                       elements: [
                         {
                             type: "mrkdwn",
-                            text: "*Users* #{emoji} on <##{cdest}>",
+                            text: "#{'*Available* ' if only_active}*Members* #{emoji} on <##{cdest}>",
                           },
                       ],
                     },