slack-smart-bot 1.14.2 → 1.15.0

data/lib/slack/smart-bot/utils/get_access_channels.rb

@@ -1,11 +1,30 @@
 class SlackSmartBot
 
   def get_access_channels()
-    if File.exist?("#{config.path}/rules/#{@channel_id}/access_channels.rb")
-      file_conf = IO.readlines("#{config.path}/rules/#{@channel_id}/access_channels.rb").join
-      unless file_conf.to_s() == ""
+    require 'yaml'
+    access_ch_file = "#{config.path}/rules/#{@channel_id}/access_channels"
+    if File.exist?("#{access_ch_file}.rb") #backwards compatible
+      file_conf = IO.readlines("#{access_ch_file}.rb").join
+      if file_conf.to_s() == ""
+        @access_channels = {}
+      else
         @access_channels = eval(file_conf)
       end
+      File.open("#{access_ch_file}.yaml", 'w') {|file| file.write(@access_channels.to_yaml) }
+      File.delete("#{access_ch_file}.rb")
+    end
+
+    if File.exist?("#{access_ch_file}.yaml")      
+      access_channels = @access_channels
+      10.times do
+        access_channels = YAML.load(File.read("#{access_ch_file}.yaml"))
+        if access_channels.is_a?(Hash)
+          break
+        else
+          sleep (0.1*(rand(2)+1))
+        end
+      end
+      @access_channels = access_channels unless access_channels.is_a?(FalseClass)
     else
       @access_channels = {}
     end

data/lib/slack/smart-bot/utils/get_channels_name_and_id.rb

@@ -5,14 +5,13 @@ class SlackSmartBot
     @channels_id = Hash.new()
     @channels_name = Hash.new()
     @channels_creator = Hash.new()
-    @users = get_users() if @users.empty?
     @channels_list.each do |ch|
       unless ch.is_archived
         @channels_id[ch.name] = ch.id
         @channels_name[ch.id] = ch.name
-        user_info = @users.select{|u| u.id == ch.creator or (u.key?(:enterprise_user) and u.enterprise_user.id == ch.creator)}[-1]
-        @channels_creator[ch.id] = user_info.name unless user_info.nil?
-        @channels_creator[ch.name] = user_info.name unless user_info.nil?
+        user_info = find_user(ch.creator)
+        @channels_creator[ch.id] = "#{user_info.team_id}_#{user_info.name}" unless user_info.nil?
+        @channels_creator[ch.name] = "#{user_info.team_id}_#{user_info.name}" unless user_info.nil?
       end
     end
   end

data/lib/slack/smart-bot/utils/get_command_ids.rb

@@ -17,13 +17,13 @@ class SlackSmartBot
     typem = Thread.current[:typem]
     user = Thread.current[:user]
     # :on_call, :on_bot, :on_extended, :on_dm, :on_master, :on_pg, :on_pub
-    admin = is_admin?(user.name)
+    admin = is_admin?(user)
 
     commands[:general] = (Dir.entries("#{__dir__}/../commands/general/").select { |e| e.match?(/\.rb/) }).sort.join('|').gsub('.rb','').split('|')
     general = File.read("#{__dir__}/../commands/general_bot_commands.rb")
     commands[:general] += general.scan(/^\s*#\s*help\w*:\s+command_id:\s+:(\w+)\s*$/i).flatten
     commands[:general].uniq!
-    
+
     if typem == :on_bot or typem == :on_master
       commands[:on_bot_general] = (Dir.entries("#{__dir__}/../commands/on_bot/general/").select { |e| e.match?(/\.rb/) }).sort.join('|').gsub('.rb','').split('|')
     end
@@ -36,7 +36,7 @@ class SlackSmartBot
       commands[:on_bot_admin] = (Dir.entries("#{__dir__}/../commands/on_bot/admin/").select { |e| e.match?(/\.rb/) }).sort.join('|').gsub('.rb','').split('|')
     end
 
-    if (typem == :on_bot or typem == :on_master) and config.masters.include?(user.name)
+    if (typem == :on_bot or typem == :on_master) and config.team_id_masters.include?("#{user.team_id}_#{user.name}")
       commands[:on_bot_master_admin] = (Dir.entries("#{__dir__}/../commands/on_bot/admin_master/").select { |e| e.match?(/\.rb/) }).sort.join('|').gsub('.rb','').split('|')
     end
 
@@ -53,7 +53,7 @@ class SlackSmartBot
       commands[:on_master_admin] = (Dir.entries("#{__dir__}/../commands/on_master/admin/").select { |e| e.match?(/\.rb/) }).sort.join('|').gsub('.rb','').split('|')
     end
 
-    if typem == :on_master and config.masters.include?(user.name)
+    if typem == :on_master and config.team_id_masters.include?("#{user.team_id}_#{user.name}")
       commands[:on_master_master_admin] = (Dir.entries("#{__dir__}/../commands/on_master/admin_master/").select { |e| e.match?(/\.rb/) }).sort.join('|').gsub('.rb','').split('|')
     end
 
@@ -75,7 +75,7 @@ class SlackSmartBot
           general_rules = File.read("#{config.path}/rules/general_rules.rb")
           commands[:general_rules] = general_rules.scan(/^\s*#\s*help\w*:\s+command_id:\s+:(\w+)\s*$/i).flatten
           commands[:general_rules]+= general_rules.scan(/^\s*save_stats\(?\s*:(\w+)\s*,?/i).flatten
-          commands[:general_rules].uniq!  
+          commands[:general_rules].uniq!
         end
       end
     end

data/lib/slack/smart-bot/utils/get_countries_candelarific.rb

@@ -0,0 +1,18 @@
+class SlackSmartBot
+  def get_countries_candelarific()
+    http = NiceHttp.new("#{config[:public_holidays][:host]}/api/v2")
+    if File.exist?("#{config.path}/vacations/countries_candelarific.json")
+      @countries_candelarific = JSON.parse(File.read("#{config.path}/vacations/countries_candelarific.json"))
+    else
+      response = http.get "/countries?api_key=#{config[:public_holidays][:api_key]}"
+      countries_candelarific = response.data.json(:countries)
+      if countries_candelarific.is_a?(Array)
+        File.write("#{config.path}/vacations/countries_candelarific.json", countries_candelarific.to_json)
+        @countries_candelarific = JSON.parse(countries_candelarific.to_json)
+      else
+        @countries_candelarific = []
+      end
+    end
+    http.close
+  end
+end

data/lib/slack/smart-bot/utils/get_help.rb

@@ -1,25 +1,27 @@
 class SlackSmartBot
-  def get_help(rules_file, dest, from, only_rules, expanded, descriptions: true, only_normal_user: false)
+  def get_help(rules_file, dest, user, only_rules, expanded, descriptions: true, only_normal_user: false)
     order = {
-      general: [:bot_help, :hi_bot, :bye_bot, :add_admin, :remove_admin, :see_admins, :poster, :add_announcement, :delete_announcement, 
-                :see_announcements, :see_command_ids, :share_messages, :see_shares, :delete_share, :see_favorite_commands, :see_statuses, 
+      general: [:bot_help, :hi_bot, :bye_bot, :add_admin, :remove_admin, :see_admins, :add_announcement, :delete_announcement,
+                :see_announcements, :see_command_ids, :share_messages, :see_shares, :delete_share, :see_favorite_commands, :see_statuses,
                 :allow_access, :see_access, :deny_access, :add_team, :add_memo_team, :delete_memo_team, :set_memo_status, :see_teams, :update_team, :ping_team, :delete_team,
-                :see_memos_team, :add_vacation, :remove_vacation, :see_vacations, :see_vacations_team, :public_holidays, :set_public_holidays, :create_loop, :quit_loop, 
-                :get_personal_settings, :delete_personal_settings, :set_personal_settings, 
-                :open_ai_chat, :open_ai_generate_image, :open_ai_edit_image, :open_ai_variations_image, :open_ai_whisper, :open_ai_models ],
+                :see_memos_team, :add_vacation, :remove_vacation, :see_vacations, :see_vacations_team, :public_holidays, :set_public_holidays, :create_loop, :quit_loop,
+                :get_personal_settings, :delete_personal_settings, :set_personal_settings,
+                :open_ai_chat, :open_ai_chat_get_prompts, :open_ai_chat_delete_session, :open_ai_chat_share_session, :open_ai_chat_list_sessions,
+                :open_ai_chat_list_sessions, :open_ai_chat_copy_session,
+                :open_ai_generate_image, :open_ai_edit_image, :open_ai_variations_image, :open_ai_whisper, :open_ai_models, :recap, :summarize, :get_smartbot_readme, :poster ],
       on_bot_general: [:whats_new, :suggest_command, :bot_status, :use_rules, :stop_using_rules, :bot_stats, :leaderboard],
       on_bot: [:ruby_code, :repl, :get_repl, :run_repl, :delete_repl, :see_repls, :kill_repl, :add_shortcut, :delete_shortcut, :see_shortcuts],
       on_bot_admin: [:extend_rules, :stop_using_rules_on, :start_bot, :pause_bot, :add_routine,
         :see_routines, :start_routine, :pause_routine, :remove_routine, :see_result_routine, :run_routine]
     }
-    if config.masters.include?(from)
+    if config.team_id_masters.include?("#{user.team_id}_#{user.name}")
       user_type = :master # master admin
-    elsif is_admin?(from)
+    elsif is_admin?(user)
       user_type = :admin
     else
       user_type = :normal #normal user
     end
-    
+
     # channel_type: :bot, :master_bot, :direct, :extended, :external
     if dest[0] == "D"
       channel_type = :direct
@@ -36,7 +38,7 @@ class SlackSmartBot
     end
 
     if only_normal_user
-      user_type = :normal 
+      user_type = :normal
       channel_type = :bot
     end
 
@@ -51,7 +53,7 @@ class SlackSmartBot
     end
     if rules_file != ""
       help[:rules_file] = build_help(config.path+rules_file, expanded)[user_type].values.join("\n") + "\n"
-     
+
       # to get all the help from other rules files added to the main rules file by using require or load. For example general_rules.rb
       res = IO.readlines(config.path+rules_file).join.scan(/$\s*(load|require)\s("|')(.+)("|')/)
       rules_help = []
@@ -79,7 +81,7 @@ class SlackSmartBot
       commands_on_extended_from_on_bot = [:repl, :see_repls, :get_repl, :run_repl, :delete_repl, :kill_repl, :ruby_code]
       commands_on_extended_from_on_bot.each do |cm|
         help[:on_extended][cm] = help[:on_bot][cm] if help[:on_bot].key?(cm)
-      end      
+      end
     end
     help = remove_hash_keys(help, :admin_master) unless user_type == :master
     help = remove_hash_keys(help, :admin) unless user_type == :admin or user_type == :master
@@ -92,12 +94,12 @@ class SlackSmartBot
       txt += "===================================
       For the Smart Bot start listening to you say *hi bot*
       To run a command on demand even when the Smart Bot is not listening to you:
-            *!THE_COMMAND*
-            *@NAME_OF_BOT THE_COMMAND*
-            *NAME_OF_BOT THE_COMMAND*
+            `!THE_COMMAND`
+            `@NAME_OF_BOT THE_COMMAND`
+            `NAME_OF_BOT THE_COMMAND`
       To run a command on demand and add the respond on a thread:
-            *^THE_COMMAND*
-            *!!THE_COMMAND*\n"
+            `^THE_COMMAND`
+            `!!THE_COMMAND`\n"
     end
     if channel_type == :direct and expanded and descriptions
       txt += "===================================
@@ -125,7 +127,7 @@ class SlackSmartBot
       if descriptions
         if channel_type == :direct
           txt += "===================================
-          *General commands:*\n"
+          *General commands on Bot channel:*\n"
         else
           txt += "===================================
           *General commands on Bot channel even when the Smart Bot is not listening to you:*\n"
@@ -204,7 +206,7 @@ class SlackSmartBot
         txt += "===================================
          *Specific commands on this Channel, call them !THE_COMMAND or !!THE_COMMAND:*\n" if descriptions
       end
-  
+
       txt += help.rules_file
     end
     return txt

data/lib/slack/smart-bot/utils/get_openai_sessions.rb

@@ -0,0 +1,47 @@
+class SlackSmartBot
+  def get_openai_sessions(session_name='', team_id: '', user_name: '')
+    require 'yaml'
+    unless Thread.current[:user].nil?
+      user_name = Thread.current[:user].name if user_name == ''
+      team_id = Thread.current[:user].team_id if team_id == ''
+      team_id_user = team_id + "_" + user_name
+    end
+
+    # get folders on openai folder
+    folders = Dir.glob(File.join(config.path, "openai", "*")).select {|f| File.directory? f}
+    # get files on every team folder
+    files = []
+    folders.each do |folder|
+      files += Dir.glob(File.join(folder, "o_*.yaml"))
+    end
+    @datetime_open_ai_file ||= {}
+    
+    files.each do |file|
+      if !defined?(@datetime_open_ai_file) or !@datetime_open_ai_file.key?(file) or @datetime_open_ai_file[file] != File.mtime(file)
+        opean_ai_user = YAML.load(Utils::Encryption.decrypt(File.read(file), config))
+        #user_file will be the team_id _ + the user name
+        user_team_id = File.basename(File.dirname(file))
+        user_file = user_team_id + "_" + File.basename(file).gsub("o_","").gsub(".yaml","")
+        
+        if @open_ai.key?(user_file) and @open_ai[user_file].key?(:chat_gpt) and @open_ai[user_file][:chat_gpt].key?(:sessions) and
+          @open_ai[user_file][:chat_gpt][:sessions].key?("")
+          temp_session = @open_ai[user_file][:chat_gpt][:sessions][""].deep_copy 
+        else
+          temp_session = nil
+        end
+        @open_ai[user_file] = opean_ai_user
+        @open_ai[user_file][:chat_gpt][:sessions][""] = temp_session unless temp_session.nil?
+        @datetime_open_ai_file[file] = File.mtime(file)
+      end
+    end
+    if session_name != ''
+      file_name = File.join(config.path, "openai", "#{team_id}/#{user_name}/session_#{session_name}.txt")
+      if File.exist?(file_name)
+        @ai_gpt ||= {}
+        @ai_gpt[team_id_user] ||= {}
+        content = File.read(file_name)
+        @ai_gpt[team_id_user][session_name] = Utils::Encryption.decrypt(content, config).force_encoding("UTF-8").split("\n")
+      end
+    end
+  end
+end

data/lib/slack/smart-bot/utils/get_personal_settings.rb

@@ -1,13 +1,39 @@
 class SlackSmartBot
-  def get_personal_settings
+  def get_personal_settings()
     @personal_settings ||= {}
     @datetime_personal_settings_file ||= {}
-    files = Dir.glob(File.join(config.path, "personal_settings", "ps_*.yaml"))
+    @personal_settings_hash ||= {}
+
+    folders = Dir.glob(File.join(config.path, "personal_settings", "*")).select {|f| File.directory? f}
+    files = []
+    folders.each do |folder|
+      files += Dir.glob(File.join(folder, "ps_*.yaml"))
+    end
+
     files.each do |file|
       if !defined?(@datetime_personal_settings_file) or !@datetime_personal_settings_file.key?(file) or @datetime_personal_settings_file[file] != File.mtime(file)
         user_personal_settings = YAML.load(Utils::Encryption.decrypt(File.read(file),config))
-        @personal_settings[File.basename(file).gsub("ps_","").gsub(".yaml","")] = user_personal_settings
+
+        user_team_id = File.basename(File.dirname(file))
+        user_file = user_team_id + "_" + File.basename(file).gsub("ps_","").gsub(".yaml","")
+
+        @personal_settings[user_file] = user_personal_settings
         @datetime_personal_settings_file[file] = File.mtime(file)
+
+        @personal_settings.each do |user, ps|
+          @personal_settings_hash[user] = {}
+          ps.each do |key, value|
+            t = @personal_settings_hash[user]
+            key.split('.').each_with_index do |k, i|
+              if i == key.split('.').size - 1 #last element
+                t[k.to_s.to_sym] = value
+              else
+                t[k.to_s.to_sym] ||= {}
+                t = t[k.to_s.to_sym]
+              end
+            end
+          end
+        end
       end
     end
   end

data/lib/slack/smart-bot/utils/get_rules_imported.rb

@@ -1,14 +1,35 @@
 class SlackSmartBot
 
   def get_rules_imported
-    if File.exist?("#{config.path}/rules/rules_imported.rb")
-      if !defined?(@datetime_rules_imported) or @datetime_rules_imported != File.mtime("#{config.path}/rules/rules_imported.rb")        
-        @datetime_rules_imported = File.mtime("#{config.path}/rules/rules_imported.rb")
-        file_conf = IO.readlines("#{config.path}/rules/rules_imported.rb").join
-        unless file_conf.to_s() == ""
-          @rules_imported = eval(file_conf)
+    require 'yaml'
+    file_path = "#{config.path}/rules/rules_imported"
+    if File.exist?("#{file_path}.rb") #backwards compatible
+      file_conf = IO.readlines("#{file_path}.rb").join
+      if file_conf.to_s() == ""
+        @rules_imported = {}
+      else
+        @rules_imported = eval(file_conf)
+      end
+      File.open("#{file_path}.yaml", 'w') {|file| file.write(@rules_imported.to_yaml) }
+      File.delete("#{file_path}.rb")
+    end
+
+    if File.exist?("#{file_path}.yaml")      
+      if !defined?(@datetime_rules_imported) or @datetime_rules_imported != File.mtime("#{file_path}.yaml")        
+        @datetime_rules_imported = File.mtime("#{file_path}.yaml")
+        rules_imported = @rules_imported
+        10.times do
+          rules_imported = YAML.load(File.read("#{file_path}.yaml"))
+          if rules_imported.is_a?(Hash)
+            break
+          else
+            sleep (0.1*(rand(2)+1))
+          end
         end
+        @rules_imported = rules_imported unless rules_imported.is_a?(FalseClass)
       end
+    else
+      @rules_imported = {}
     end
   end
   

data/lib/slack/smart-bot/utils/get_shares.rb

@@ -4,7 +4,7 @@ class SlackSmartBot
     channel = @channels_name[@channel_id]
     if File.exist?("#{config.path}/shares/#{channel}.csv")
       "#{config.path}/shares/#{channel}.csv"
-      t = CSV.table("#{config.path}/shares/#{channel}.csv", headers: ['share_id', 'user_deleted', 'user_created', 'date', 'time', 'type', 'to_channel', 'condition'])
+      t = CSV.table("#{config.path}/shares/#{channel}.csv", headers: ['share_id', 'user_team_id_deleted', 'user_deleted', 'user_team_id_created', 'user_created', 'date', 'time', 'type', 'to_channel', 'condition'])
       t.delete_if {|row| row[:user_deleted] != ''}
       @shares[channel] = t
     end

data/lib/slack/smart-bot/utils/get_team_members.rb

@@ -3,7 +3,7 @@ class SlackSmartBot
     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]
+      user_info = find_user(m)
       assigned_members.delete(m) if user_info.nil? or user_info.deleted
     end
     channels_members = []
@@ -18,15 +18,15 @@ class SlackSmartBot
         else
           channels_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.is_app_user or user_info.is_bot
+            user_info = find_user(m)
+            team_members << "#{user_info.team_id}_#{user_info.name}" unless user_info.nil? or user_info.is_app_user or user_info.is_bot
           end
         end
       end
       team_members.flatten!
       team_members.uniq!
       unassigned_members = team_members - assigned_members
-      unassigned_members.delete(config.nick)
+      unassigned_members.delete("#{config.team_id}_#{config.nick}")
       not_on_team_channel = assigned_members - team_members
       all_team_members += team_members
     else

data/lib/slack/smart-bot/utils/get_vacations.rb

@@ -14,13 +14,21 @@ class SlackSmartBot
       @logger.info "Deleting old_vacations_file: #{old_vacations_file}"
       File.delete(old_vacations_file)
     end
-    files = Dir.glob(File.join(config.path, "vacations", "v_*.yaml"))
-    @datetime_vacations_file ||= {}
-    files.each do |file|
-      if !defined?(@datetime_vacations_file) or !@datetime_vacations_file.key?(file) or @datetime_vacations_file[file] != File.mtime(file)
-        vacations_user = YAML.load(Utils::Encryption.decrypt(File.read(file), config))
-        @vacations[File.basename(file).gsub("v_","").gsub(".yaml","")] = vacations_user
-        @datetime_vacations_file[file] = File.mtime(file)
+    # get the yaml files. They will be on /vacations then in there a folder for each team and inside the yaml files for each user
+    folders = Dir.glob(File.join(config.path, "vacations", "*"))
+    folders.each do |folder|
+      if File.directory?(folder)
+        files = Dir.glob(File.join(folder, "*.yaml"))
+        @datetime_vacations_file ||= {}
+        files.each do |file|
+          if !defined?(@datetime_vacations_file) or !@datetime_vacations_file.key?(file) or @datetime_vacations_file[file] != File.mtime(file)
+            vacations_user = YAML.load(Utils::Encryption.decrypt(File.read(file), config))
+            #the key of @vacations will be the team_id_user_name
+            team_id = File.basename(folder)
+            @vacations["#{team_id}_#{File.basename(file).gsub("v_","").gsub(".yaml","")}"] = vacations_user
+            @datetime_vacations_file[file] = File.mtime(file)
+          end
+        end
       end
     end
   end

data/lib/slack/smart-bot/utils/has_access.rb

@@ -1,8 +1,11 @@
 class SlackSmartBot
   def has_access?(method, user = nil)
     user = Thread.current[:user] if user.nil?
+    team_id_user = "#{user.team_id}_#{user.name}"
     if config[:allow_access].key?(method) and !config[:allow_access][method].include?(user.name) and !config[:allow_access][method].include?(user.id) and
-       (!user.key?(:enterprise_user) or (user.key?(:enterprise_user) and !config[:allow_access][method].include?(user[:enterprise_user].id)))
+      !config[:allow_access][method].include?(team_id_user) and
+       (!user.key?(:enterprise_user) or (user.key?(:enterprise_user) and !config[:allow_access][method].include?(user[:enterprise_user].id) and
+       !config[:allow_access][method].include?("#{user[:enterprise_user].enterprise_id}_#{user[:enterprise_user].name}")))
       respond "You don't have access to use this command, please contact an Admin to be able to use it: <@#{config.admins.join(">, <@")}>"
       return false
     else
@@ -13,14 +16,17 @@ class SlackSmartBot
       else
         channel = Thread.current[:using_channel]
       end
-      if !@access_channels.key?(channel) or !@access_channels[channel].key?(method.to_s) or @access_channels[channel][method.to_s].include?(user.name)
+      if !@access_channels.key?(channel) or !@access_channels[channel].key?(method.to_s) or
+        @access_channels[channel][method.to_s].include?(user.name) or
+        @access_channels[channel][method.to_s].include?(team_id_user)
         return true
       else
         if @admins_channels.key?(channel) and !@admins_channels[channel].empty?
-            respond "You don't have access to use this command, please contact an Admin to be able to use it: <@#{@admins_channels[channel].join(">, <@")}>"
+            admins = @admins_channels[channel].map { |a| a.split('_')[1..-1].join('_') }
+            respond "You don't have access to use this command, please contact an Admin to be able to use it: <@#{admins.join(">, <@")}>"
         else
             respond "You don't have access to use this command, please contact an Admin to be able to use it."
-        end        
+        end
         return false
       end
     end

data/lib/slack/smart-bot/utils/is_admin.rb

@@ -1,27 +1,35 @@
 class SlackSmartBot
-    def is_admin?(from=nil)
-        if from.nil?
+    def is_admin?(user=nil)
+        if user.nil?
             user = Thread.current[:user]
-            from = user.name
+            team_id_user_name = "#{user.team_id}_#{user.name}"
+        elsif user.is_a?(String) and user.match?(/^[A-Z0-9]{7,11}_/)
+            team_id = user.split('_')[0]
+            user_name = user.split('_')[1..-1].join('_')
+            team_id_user_name = "#{team_id}_#{user_name}"
+        elsif user.is_a?(String)
+            team_id_user_name = "#{config.team_id}_#{user}"
+        else
+            team_id_user_name = "#{user.team_id}_#{user.name}"
         end
-        
-        if (Thread.current[:dchannel].to_s!='' and !@channels_creator.key?(Thread.current[:dchannel])) or 
-            (Thread.current[:dest].to_s!='' and Thread.current[:dest][0]!='D' and !@channels_creator.key?(Thread.current[:dest])) or 
-            (Thread.current[:using_channel].to_s!='' and !@channels_creator.key?(:using_channel))
-            get_channels_name_and_id() 
+
+        if (Thread.current[:dchannel].to_s!='' and Thread.current[:dchannel][0]!='D' and !@channels_creator.key?(Thread.current[:dchannel])) or
+            (Thread.current[:dest].to_s!='' and Thread.current[:dest][0]!='D' and !@channels_creator.key?(Thread.current[:dest])) or
+            (Thread.current[:using_channel].to_s!='' and !@channels_creator.key?(Thread.current[:using_channel]))
+            get_channels_name_and_id()
         end
 
-        if config.masters.include?(from) or 
-           config.admins.include?(from) or 
-           (Thread.current[:typem] == :on_call and @admins_channels.key?(Thread.current[:dchannel]) and @admins_channels[Thread.current[:dchannel]].include?(from)) or
-           (Thread.current[:using_channel].to_s == '' and @admins_channels.key?(Thread.current[:dest]) and @admins_channels[Thread.current[:dest]].include?(from)) or
-           (@admins_channels.key?(Thread.current[:using_channel]) and @admins_channels[Thread.current[:using_channel]].include?(from)) or 
-           (Thread.current[:using_channel].to_s=='' and @channels_creator.key?(Thread.current[:dest]) and from == @channels_creator[Thread.current[:dest]]) or 
-           (Thread.current[:typem] == :on_call  and @channels_creator.key?(Thread.current[:dchannel]) and from == @channels_creator[Thread.current[:dchannel]]) or 
-           (@channels_creator.key?(Thread.current[:using_channel]) and from == @channels_creator[Thread.current[:using_channel]])
+        if config.team_id_masters.include?(team_id_user_name) or
+           config.team_id_admins.include?(team_id_user_name) or
+           (Thread.current[:typem] == :on_call and @admins_channels.key?(Thread.current[:dchannel]) and @admins_channels[Thread.current[:dchannel]].include?(team_id_user_name)) or
+           (Thread.current[:using_channel].to_s == '' and @admins_channels.key?(Thread.current[:dest]) and @admins_channels[Thread.current[:dest]].include?(team_id_user_name)) or
+           (@admins_channels.key?(Thread.current[:using_channel]) and @admins_channels[Thread.current[:using_channel]].include?(team_id_user_name)) or
+           (Thread.current[:using_channel].to_s=='' and @channels_creator.key?(Thread.current[:dest]) and team_id_user_name == @channels_creator[Thread.current[:dest]]) or
+           (Thread.current[:typem] == :on_call  and @channels_creator.key?(Thread.current[:dchannel]) and team_id_user_name == @channels_creator[Thread.current[:dchannel]]) or
+           (@channels_creator.key?(Thread.current[:using_channel]) and team_id_user_name == @channels_creator[Thread.current[:using_channel]])
             return true
         else
             return false
         end
     end
-end
+end

data/lib/slack/smart-bot/utils/local_time.rb

@@ -0,0 +1,29 @@
+class SlackSmartBot
+  def local_time(country_region, return_default_if_not_found = true)
+    require "tzinfo"
+    @time_zone_identifiers ||= TZInfo::Timezone.all_identifiers
+    country, region = country_region.to_s.split("/")
+    identifier = nil
+    if region.nil?        
+      get_countries_candelarific() if !defined?(@countries_candelarific)  
+      found_country = @countries_candelarific.find { |c| c.country_name.match?(/^\s*#{country}\s*$/i) }
+      unless found_country.nil?
+        country_iso = found_country["iso-3166"]
+        found_country = TZInfo::Country.get(country_iso).zone_identifiers
+        region = found_country.first.split("/").last unless found_country.empty?
+      end
+    end
+    identifier = @time_zone_identifiers.find { |id| id.downcase.include?(region.to_s.gsub(" ", "_").downcase) } unless region.nil?
+    identifier = @time_zone_identifiers.find { |id| id.downcase.include?(country.to_s.gsub(" ", "_").downcase) } if identifier.nil?
+    if identifier.nil?
+      if return_default_if_not_found
+        return local_time(config.public_holidays.default_calendar, false)
+      else
+        return nil
+      end
+    else
+      tz = TZInfo::Timezone.get(identifier)
+      return tz.now
+    end
+  end
+end

data/lib/slack/smart-bot/utils/save_stats.rb

@@ -8,7 +8,7 @@ class SlackSmartBot
           require "csv"
           if !File.exist?("#{config.stats_path}.#{Time.now.strftime("%Y-%m")}.log")
             CSV.open("#{config.stats_path}.#{Time.now.strftime("%Y-%m")}.log", "wb") do |csv|
-              csv << ["date", "bot_channel", "bot_channel_id", "dest_channel", "dest_channel_id", "type_message", "user_name", "user_id", "text", "command", "files", "time_zone", "job_title"]
+              csv << ["date", "bot_channel", "bot_channel_id", "dest_channel", "dest_channel_id", "type_message", "user_name", "user_id", "text", "command", "files", "time_zone", "job_title", "team_id"]
             end
           end
           if data.empty?
@@ -36,17 +36,19 @@ class SlackSmartBot
             user_name = data.user.name
             user_id = data.user.id
           end
-          user_info = @users.select { |u| u.id == user_id or (u.key?(:enterprise_user) and u.enterprise_user.id == user_id) }[-1]
+          user_info = find_user(data.user.id)
           if user_info.nil? or user_info.is_app_user or user_info.is_bot
             time_zone = ''
             job_title = ''
+            team_id = ''
           else
             time_zone = user_info.tz_label
             job_title = user_info.profile.title
+            team_id = user_info.team_id
           end
           command_txt = "#{method} encrypted" if command_ids_not_to_log.include?(method.to_s)
           CSV.open("#{config.stats_path}.#{Time.now.strftime("%Y-%m")}.log", "a+") do |csv|
-            csv << [Time.now, config.channel, @channel_id, @channels_name[data.dest], data.dest, data.typem, user_name, user_id, command_txt, method, data.files, time_zone, job_title]
+            csv << [Time.now, config.channel, @channel_id, @channels_name[data.dest], data.dest, data.typem, user_name, user_id, command_txt, method, data.files, time_zone, job_title, team_id]
           end
         rescue Exception => exception
           @logger.fatal "There was a problem on the stats"

data/lib/slack/smart-bot/utils/update_access_channels.rb

@@ -1,8 +1,24 @@
 class SlackSmartBot
 
   def update_access_channels()
-    file = File.open("#{config.path}/rules/#{@channel_id}/access_channels.rb", "w")
-    file.write (@access_channels.inspect)
-    file.close
+    require 'yaml'
+    access_ch_file = "#{config.path}/rules/#{@channel_id}/access_channels"
+
+    if File.exist?("#{access_ch_file}.rb") #backwards compatible
+      file_conf = IO.readlines("#{access_ch_file}.rb").join
+      if file_conf.to_s() == ""
+        @access_channels = {}
+      else
+        @access_channels = eval(file_conf)
+      end
+      File.open("#{access_ch_file}.yaml", 'w') {|file| file.write(@access_channels.to_yaml) }
+      File.delete("#{access_ch_file}.rb")
+    end
+
+    File.open("#{access_ch_file}.yaml", 'w') {|file|
+      file.flock(File::LOCK_EX)
+      file.write(@access_channels.to_yaml) 
+      file.flock(File::LOCK_UN)
+    }
   end
 end

data/lib/slack/smart-bot/utils/update_openai_sessions.rb

@@ -0,0 +1,42 @@
+class SlackSmartBot
+  def update_openai_sessions(session_name='', team_id: '', user_name: '')
+    require 'yaml'
+    user_name = Thread.current[:user].name if user_name == ''
+    team_id = Thread.current[:user].team_id if team_id == ''
+    team_id_user = team_id + "_" + user_name
+
+    unless Dir.exist?("#{config.path}/openai/#{team_id}")
+      Dir.mkdir("#{config.path}/openai/#{team_id}")
+    end
+
+    unless Dir.exist?("#{config.path}/openai/#{team_id}/#{user_name}")
+      Dir.mkdir("#{config.path}/openai/#{team_id}/#{user_name}")
+    end
+    file_name = File.join(config.path, "openai/#{team_id}", "o_#{user_name}.yaml")
+    data = @open_ai[team_id_user].deep_copy
+    if data.key?(:chat_gpt) and data[:chat_gpt].key?(:sessions)
+      data[:chat_gpt][:sessions].delete('') #temporary session
+    end
+    File.open(file_name, 'w') {|file|
+      file.flock(File::LOCK_EX)
+      file.write(Utils::Encryption.encrypt(data.to_yaml, config))
+      file.flock(File::LOCK_UN)
+    }
+    @datetime_open_ai_file[file_name] = File.mtime(file_name)
+    if session_name != ''
+      if !@open_ai[team_id_user][:chat_gpt][:sessions].key?(session_name) #delete file if session is not longer available
+        if File.exist?(File.join(config.path, "openai/#{team_id}", "#{user_name}/session_#{session_name}.txt"))
+          File.delete(File.join(config.path, "openai/#{team_id}", "#{user_name}/session_#{session_name}.txt"))
+        end
+      else
+        file_name = File.join(config.path, "openai/#{team_id}", "#{user_name}/session_#{session_name}.txt")
+        content = @ai_gpt[team_id_user][session_name].join("\n").force_encoding("UTF-8")
+        File.open(file_name, 'w') {|file|
+            file.flock(File::LOCK_EX)
+          file.write(Utils::Encryption.encrypt(content, config))
+          file.flock(File::LOCK_UN)
+        }
+      end
+    end
+  end
+end