slack-wrapper 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cdc038bb2fcc4cda46b1ebb672d67f68324014a5
+  data.tar.gz: 5bb831450a48fe3b92ff3ee5187a6b6621fc0ca8
+SHA512:
+  metadata.gz: fdbecf535d28e18ed447ea643d0b10a88e9bad4aac85ab0dafd7bf6858268d68b08a7de026bda4287357de94394589380c11c5375d1dba86957d84dd6dafffb4
+  data.tar.gz: 6c43eef3cc80b7a9b7fcc6876c2d46f613d81f80afe2f816057ddc3c4e9084f0d9d15a63c1ef2bd130eb3e3d2d723ee86d793bda4b3efaf328a493dadd24bae4

data/lib/slack-wrapper.rb

@@ -0,0 +1,18 @@
+require 'net/https'
+require 'net/http/post/multipart'
+require 'json'
+require 'uri'
+
+require_relative 'slack-wrapper/errors.rb'
+require_relative 'slack-wrapper/config.rb'
+require_relative 'slack-wrapper/api.rb'
+
+module Slack
+  extend self
+  def id
+    Slack::API::Auth.whoami['id']
+  end
+  def name
+    Slack::API::Auth.whoami['name']
+  end
+end

data/lib/slack-wrapper/api.rb

@@ -0,0 +1,17 @@
+require_relative 'api/auth.rb'
+require_relative 'api/bots.rb'
+require_relative 'api/channels.rb'
+require_relative 'api/chat.rb'
+require_relative 'api/files.rb'
+require_relative 'api/im.rb'
+require_relative 'api/permissions.rb'
+require_relative 'api/rtm.rb'
+require_relative 'api/users.rb'
+
+module Slack
+  module API
+    extend self
+  end
+  class << self
+  end
+end

data/lib/slack-wrapper/api/auth.rb

@@ -0,0 +1,36 @@
+module Slack
+  module API
+    module Auth
+      extend self
+      def is_valid?
+        case Slack::Config.token
+          when nil
+            false
+          when String
+            uri  = URI.parse('https://slack.com/api/auth.test')
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = true
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+            req  = Net::HTTP::Post.new("#{uri.to_s}?token=#{Slack::Config.token}")
+            resp = http.request(req)
+            false unless resp.code == 200
+            JSON.parse(resp.body)['ok']
+          else
+            false
+        end
+      end
+      def whoami
+        uri  = URI.parse('https://slack.com/api/auth.test')
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        req  = Net::HTTP::Post.new("#{uri.to_s}?token=#{Slack::Config.token}")
+        resp = http.request(req)
+        false unless resp.code == 200
+        data = JSON.parse(resp.body)
+        return {"name" => data['user'], 'id' => data['user_id']}
+      end
+      is_valid?
+    end
+  end
+end

data/lib/slack-wrapper/api/bots.rb

@@ -0,0 +1,29 @@
+# https://api.slack.com/methods/bots.info
+module Slack
+  module API
+    module Bots
+      extend self
+      def info(opts={})
+        if Slack::API::Auth
+          opts['token'] = Slack::Config.token
+          uri = URI.parse('https://slack.com/api/bots.info')
+          req = Net::HTTP::Post::Multipart.new(uri.path, opts)
+          res = Net::HTTP::new(uri.host, uri.port)
+          res.use_ssl = true
+          res.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          resp = res.start do |http|
+            http.request(req)
+          end
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            JSON.parse(resp.body)['bot']
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+    end
+  end
+end

data/lib/slack-wrapper/api/channels.rb

@@ -0,0 +1,277 @@
+# https://api.slack.com/methods/channels.list
+# https://api.slack.com/methods/channels.create
+# https://api.slack.com/methods/channels.archive
+# https://api.slack.com/methods/channels.unarchive
+# https://api.slack.com/methods/channels.info
+# https://api.slack.com/methods/channels.history
+# https://api.slack.com/methods/channels.join
+# https://api.slack.com/methods/channels.leave
+# https://api.slack.com/methods/channels.invite
+# https://api.slack.com/methods/channels.kick
+# https://api.slack.com/methods/channels.rename
+# https://api.slack.com/methods/channels.setPurpose
+# https://api.slack.com/methods/channels.setTopic
+module Slack
+  module API
+    module Channels
+      extend self
+      def get_channels(archived=false)
+        if Slack::API::Auth
+          uri  = URI.parse('https://slack.com/api/channels.list')
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          if archived
+            url = "#{uri.to_s}?token=#{Slack::Config.token}&exclude_members=true"
+          else
+            url = "#{uri.to_s}?token=#{Slack::Config.token}&exclude_archived=true&exclude_members=true"
+          end
+          req  = Net::HTTP::Post.new(url)
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            JSON.parse(resp.body)['channels']
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def all_channels
+        get_channels(true)
+      end
+      def active_channels
+        get_channels()
+      end
+      def search(term, archived=false, regex=false)
+        channels = get_channels(archived)
+        if regex
+          channels.select{|c| c['name'] =~ /#{term}/}
+        else
+          channels.select{|c| c['name'] == term}.first
+        end
+      end
+      def create(name, validate=false)
+        if Slack::API::Auth
+          uri  = URI.parse('https://slack.com/api/channels.create')
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req  = Net::HTTP::Post.new("#{uri.to_s}?token=#{Slack::Config.token}&name=#{name}&validate=#{validate}")
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            JSON.parse(resp.body)['channel']
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def archive(id)
+        if Slack::API::Auth
+          uri  = URI.parse('https://slack.com/api/channels.archive')
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req  = Net::HTTP::Post.new("#{uri.to_s}?token=#{Slack::Config.token}&channel=#{id}")
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            true
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def unarchive(id)
+        if Slack::API::Auth
+          uri  = URI.parse('https://slack.com/api/channels.unarchive')
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req  = Net::HTTP::Post.new("#{uri.to_s}?token=#{Slack::Config.token}&channel=#{id}")
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            true
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def info(id)
+        if Slack::API::Auth
+          uri  = URI.parse('https://slack.com/api/channels.info')
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req  = Net::HTTP::Post.new("#{uri.to_s}?token=#{Slack::Config.token}&channel=#{id}")
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            JSON.parse(resp.body)['channel']
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def history(id, count)
+        if Slack::API::Auth
+          uri  = URI.parse('https://slack.com/api/channels.history')
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req  = Net::HTTP::Post.new("#{uri.to_s}?token=#{Slack::Config.token}&channel=#{id}&count=#{count}")
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            JSON.parse(resp.body)['messages']
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def join(name)
+        if Slack::API::Auth
+          uri  = URI.parse('https://slack.com/api/channels.join')
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req  = Net::HTTP::Post.new("#{uri.to_s}?token=#{Slack::Config.token}&name=#{name}")
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            true
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def leave(id)
+        if Slack::API::Auth
+          uri  = URI.parse('https://slack.com/api/channels.join')
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req  = Net::HTTP::Post.new("#{uri.to_s}?token=#{Slack::Config.token}&channel=#{id}")
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            true
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def invite_user(user, channel)
+        if Slack::API::Auth
+          uri  = URI.parse('https://slack.com/api/channels.invite')
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req  = Net::HTTP::Post.new("#{uri.to_s}?token=#{Slack::Config.token}&channel=#{channel}&user=#{user}")
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            true
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def kick_user(user, channel)
+        if Slack::API::Auth
+          uri  = URI.parse('https://slack.com/api/channels.kick')
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req  = Net::HTTP::Post.new("#{uri.to_s}?token=#{Slack::Config.token}&channel=#{channel}&user=#{user}")
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            true
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def rename(id, name)
+        if Slack::API::Auth
+          uri  = URI.parse('https://slack.com/api/channels.rename')
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req  = Net::HTTP::Post.new("#{uri.to_s}?token=#{Slack::Config.token}&channel=#{id}&name=#{name}")
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            true
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def set_purpose(id, text)
+        text = URI.escape(text)
+        if Slack::API::Auth
+          uri  = URI.parse('https://slack.com/api/channels.setPurpose')
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req  = Net::HTTP::Post.new("#{uri.to_s}?token=#{Slack::Config.token}&channel=#{id}&purpose=#{text}")
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            true
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def set_topic(id, text)
+        text = URI.escape(text)
+        if Slack::API::Auth
+          uri  = URI.parse('https://slack.com/api/channels.setTopic')
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req  = Net::HTTP::Post.new("#{uri.to_s}?token=#{Slack::Config.token}&channel=#{id}&topic=#{text}")
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            true
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+    end
+    class << self
+    end
+  end
+end

data/lib/slack-wrapper/api/chat.rb

@@ -0,0 +1,136 @@
+# https://api.slack.com/methods/chat.update
+# https://api.slack.com/methods/chat.delete
+# https://api.slack.com/methods/chat.postMessage
+# https://api.slack.com/methods/chat.meMessage
+# https://api.slack.com/methods/chat.postMessage
+module Slack
+  module API
+    module Chat
+      extend self
+      def update(text, ts, channel, obj=nil)
+        if Slack::API::Auth
+          text = URI.escape(text)
+          uri  = URI.parse('https://slack.com/api/chat.update')
+          case obj
+            when nil
+              url = "#{uri.to_s}?token=#{Slack::Config.token}&channel=#{channel}&text=#{text}&as_user=true&ts=#{ts}"
+            when Array
+              url = "#{uri.to_s}?token=#{Slack::Config.token}&channel=#{channel}&text=#{text}&as_user=true&attachments=#{URI.escape(obj.to_json)}&ts=#{ts}"
+            else
+              Slack::Errors.new({'error'  => 'invalid_attachment',
+                                 'detail' => 'Attachment object must be an Array'})
+          end
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req  = Net::HTTP::Post.new(url)
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            true
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def delete(ts, channel)
+        if Slack::API::Auth
+          text = URI.escape(text)
+          uri  = URI.parse('https://slack.com/api/chat.delete')
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req  = Net::HTTP::Post.new("#{uri.to_s}?token=#{Slack::Config.token}&channel=#{channel}&as_user=true&ts=#{ts}")
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            true
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def post(text, channel, obj=nil)
+        if Slack::API::Auth
+          text = URI.escape(text)
+          uri  = URI.parse('https://slack.com/api/chat.postMessage')
+          case obj
+            when nil
+              url = "#{uri.to_s}?token=#{Slack::Config.token}&channel=#{channel}&text=#{text}&as_user=true"
+            when Array
+              url = "#{uri.to_s}?token=#{Slack::Config.token}&channel=#{channel}&text=#{text}&as_user=true&attachments=#{URI.escape(obj.to_json)}"
+            else
+              Slack::Errors.new({'error'  => 'invalid_attachment',
+                                 'detail' => 'Attachment object must be an Array'})
+          end
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req  = Net::HTTP::Post.new(url)
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            true
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def post_me(text, channel)
+        if Slack::API::Auth
+          text = URI.escape(text)
+          uri  = URI.parse('https://slack.com/api/chat.meMessage')
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req  = Net::HTTP::Post.new("#{uri.to_s}?token=#{Slack::Config.token}&channel=#{channel}&text=#{text}")
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            true
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def post_ephemeral(text, channel, user, obj=nil)
+        if Slack::API::Auth
+          text = URI.escape(text)
+          uri  = URI.parse('https://slack.com/api/chat.postEphemeral')
+          case obj
+            when nil
+              url = "#{uri.to_s}?token=#{Slack::Config.token}&channel=#{channel}&text=#{text}&as_user=true&user=#{user}"
+            when Array
+              url = "#{uri.to_s}?token=#{Slack::Config.token}&channel=#{channel}&text=#{text}&as_user=true&user=#{user}&attachments=#{URI.escape(obj.to_json)}"
+            else
+              Slack::Errors.new({'error'  => 'invalid_attachment',
+                                 'detail' => 'Attachment object must be an Array'})
+          end
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req  = Net::HTTP::Post.new(url)
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            true
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+    end
+    class << self
+    end
+  end
+end

data/lib/slack-wrapper/api/files.rb

@@ -0,0 +1,185 @@
+# https://api.slack.com/methods/files.list
+# https://api.slack.com/methods/files.delete
+# https://api.slack.com/methods/files.upload
+# https://api.slack.com/methods/files.comments.add
+# https://api.slack.com/methods/files.comments.delete
+# https://api.slack.com/methods/files.comments.edit
+# https://api.slack.com/methods/files.revokePublicURL
+# https://api.slack.com/methods/files.sharedPublicURL
+module Slack
+  module API
+    module Files
+      extend self
+      def get_files(type='all')
+        if Slack::API::Auth
+          type.split(',').each do |t|
+            case t
+              when 'all', 'spaces', 'snippets', 'images', 'gdocs', 'zips', 'pdfs'
+                next
+              else
+                Slack::Errors.new({'error'  => 'invalid file type',
+                                   'detail' => 'Only all, spaces, snippets, images, gdocs, zips, pdfs supported'})
+            end
+          end
+          uri  = URI.parse('https://slack.com/api/files.list')
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req  = Net::HTTP::Post.new("#{uri.to_s}?token=#{Slack::Config.token}&types=#{type}")
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            JSON.parse(resp.body)['files']
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def search(term, regex=false)
+        files = get_files
+        if regex
+          files.select{|f| f['name'] =~ /#{term}/}
+        else
+          files.select{|f| f['name'] == term}.first
+        end
+      end
+      def delete(id)
+        if Slack::API::Auth
+          uri  = URI.parse('https://slack.com/api/files.delete')
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req  = Net::HTTP::Post.new("#{uri.to_s}?token=#{Slack::Config.token}&file=#{id}")
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            true
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def upload(file, channel, opts={})
+        Slack::Errors.new({'error'  => 'file_invalid', 'detail' => 'Object is missing or is not a file'}) unless File.file?(file)
+        opts['channels']        = channel
+        opts['title']           = File.basename(file) unless opts.has_key? :title
+        opts['filename']        = File.basename(file) unless opts.has_key? :filename
+        opts['filetype']        = 'auto' unless opts.has_key? :filetype
+        opts['initial_comment'] = '' unless opts.has_key? :initial_comment
+        if Slack::API::Auth
+          uri = URI.parse('https://slack.com/api/files.upload')
+          opts['token'] = Slack::Config.token
+          File.open(file) do |f|
+            opts['file'] = UploadIO.new(f, `file --brief --mime-type #{file}`.strip, opts['filename'])
+            req = Net::HTTP::Post::Multipart.new(uri.path, opts)
+            res = Net::HTTP::new(uri.host, uri.port)
+            res.use_ssl = true
+            res.verify_mode = OpenSSL::SSL::VERIFY_NONE
+            resp = res.start do |http|
+              http.request(req)
+            end
+            false unless resp.code == 200
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def add_comment(text, file)
+        if Slack::API::Auth
+          uri  = URI.parse('https://slack.com/api/files.comments.add')
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req  = Net::HTTP::Post.new("#{uri.to_s}?token=#{Slack::Config.token}&file=#{file}&comment=#{text}")
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            JSON.parse(resp.body)['files']
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def delete_comment(file, id)
+        if Slack::API::Auth
+          uri  = URI.parse('https://slack.com/api/files.comments.delete')
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req  = Net::HTTP::Post.new("#{uri.to_s}?token=#{Slack::Config.token}&file=#{file}&id=#{id}")
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            JSON.parse(resp.body)['files']
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def edit_comment(text, file, id)
+        if Slack::API::Auth
+          uri  = URI.parse('https://slack.com/api/files.comments.edit')
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req  = Net::HTTP::Post.new("#{uri.to_s}?token=#{Slack::Config.token}&comment=#{text}&file=#{file}&id=#{id}")
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            JSON.parse(resp.body)['files']
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def revoke_URL(file)
+        if Slack::API::Auth
+          uri  = URI.parse('https://slack.com/api/files.sharedPublicURL')
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req  = Net::HTTP::Post.new("#{uri.to_s}?token=#{Slack::Config.token}&file=#{file}")
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            JSON.parse(resp.body)['file']['url']
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def enable_URL(file)
+        if Slack::API::Auth
+          uri  = URI.parse('https://slack.com/api/files.revokePublicURL')
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req  = Net::HTTP::Post.new("#{uri.to_s}?token=#{Slack::Config.token}&file=#{file}")
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            JSON.parse(resp.body)['files']
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+    end
+    class << self
+    end
+  end
+end

data/lib/slack-wrapper/api/im.rb

@@ -0,0 +1,105 @@
+# https://api.slack.com/methods/im.open
+# https://api.slack.com/methods/im.close
+# https://api.slack.com/methods/im.history
+# https://api.slack.com/methods/im.list
+module Slack
+  module API
+    module IM
+      extend self
+      def open(id, opts={})
+        if Slack::API::Auth
+          opts['user'] = id
+          opts['return_im'] = true
+          opts['token'] = Slack::Config.token
+          opts['include_locale'] = true
+          uri = URI.parse('https://slack.com/api/im.open')
+          req = Net::HTTP::Post::Multipart.new(uri.path, opts)
+          res = Net::HTTP::new(uri.host, uri.port)
+          res.use_ssl = true
+          res.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          resp = res.start do |http|
+            http.request(req)
+          end
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            JSON.parse(resp.body)['channel']
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def close(id, opts={})
+        if Slack::API::Auth
+          opts['channel'] = id
+          opts['token'] = Slack::Config.token
+          uri = URI.parse('https://slack.com/api/im.close')
+          req = Net::HTTP::Post::Multipart.new(uri.path, opts)
+          res = Net::HTTP::new(uri.host, uri.port)
+          res.use_ssl = true
+          res.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          resp = res.start do |http|
+            http.request(req)
+          end
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            true
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def history(id, opts={})
+        if Slack::API::Auth
+          opts['channel'] = id
+          opts['token'] = Slack::Config.token
+          uri = URI.parse('https://slack.com/api/im.history')
+          req = Net::HTTP::Post::Multipart.new(uri.path, opts)
+          res = Net::HTTP::new(uri.host, uri.port)
+          res.use_ssl = true
+          res.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          resp = res.start do |http|
+            http.request(req)
+          end
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            JSON.parse(resp.body)['messages']
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def list(opts={})
+        if Slack::API::Auth
+          opts['token'] = Slack::Config.token
+          uri = URI.parse('https://slack.com/api/im.list')
+          req = Net::HTTP::Post::Multipart.new(uri.path, opts)
+          res = Net::HTTP::new(uri.host, uri.port)
+          res.use_ssl = true
+          res.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          resp = res.start do |http|
+            http.request(req)
+          end
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            JSON.parse(resp.body)['ims']
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+    end
+    class << self
+      def im
+        IM
+      end
+    end
+  end
+end

data/lib/slack-wrapper/api/permissions.rb

@@ -0,0 +1,57 @@
+# https://api.slack.com/methods/apps.permissions.info
+# https://api.slack.com/methods/apps.permissions.request
+# Slack API still in development for feature, leaving as is for now
+module Slack
+  module API
+    class Permissions
+      def show(opts={})
+        if Slack::API::Auth
+          opts['token'] = Slack::Config.token
+          uri = URI.parse('https://slack.com/api/apps.permissions.info')
+          req = Net::HTTP::Post::Multipart.new(uri.path, opts)
+          res = Net::HTTP::new(uri.host, uri.port)
+          res.use_ssl = true
+          res.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          resp = res.start do |http|
+            http.request(req)
+          end
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            JSON.parse(resp.body)['info']
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def request(opts={})
+        if Slack::API::Auth
+          if opts.key?('scopes') && opts.key?("trigger_id")
+            Slack::Errors.new({'error' => 'no_scope', 'detail' => 'You must provide a comma separated scope'}) if opts['scopes'].empty?
+            Slack::Errors.new({'error' => 'no_trigger_id', 'detail' => 'You must provide a trigger id'}) if opts['trigger_id'].empty?
+          else
+            Slack::Errors.new({'error' => 'invalid_parameters', 'detail' => 'You must provide both scopes and trigger_id as options'})
+          end
+          opts['token'] = Slack::Config.token
+          uri = URI.parse('https://slack.com/api/apps.permissions.info')
+          req = Net::HTTP::Post::Multipart.new(uri.path, opts)
+          res = Net::HTTP::new(uri.host, uri.port)
+          res.use_ssl = true
+          res.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          resp = res.start do |http|
+            http.request(req)
+          end
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            true
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+    end
+  end
+end

data/lib/slack-wrapper/api/rtm.rb

@@ -0,0 +1,58 @@
+# https://api.slack.com/methods/rtm.connect
+# https://api.slack.com/methods/rtm.start
+module Slack
+  module API
+    module RTM
+      extend self
+      def connect(opts={})
+        if Slack::API::Auth
+          opts['token'] = Slack::Config.token
+          uri = URI.parse('https://slack.com/api/rtm.connect')
+          req = Net::HTTP::Post::Multipart.new(uri.path, opts)
+          res = Net::HTTP::new(uri.host, uri.port)
+          res.use_ssl = true
+          res.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          resp = res.start do |http|
+            http.request(req)
+          end
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            JSON.parse(resp.body)['url']
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def start(opts={})
+        opts['no_unreads'] = true unless opts.key? 'no_unreads'
+        opts['simple_latest'] = true unless opts.key? 'simple_latest'
+        opts['token'] = Slack::Config.token
+        if Slack::API::Auth
+          uri = URI.parse('https://slack.com/api/rtm.start')
+          req = Net::HTTP::Post::Multipart.new(uri.path, opts)
+          res = Net::HTTP::new(uri.host, uri.port)
+          res.use_ssl = true
+          res.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          resp = res.start do |http|
+            http.request(req)
+          end
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            JSON.parse(resp.body)
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+    end
+    class << self
+      def rtm
+        RTM
+      end
+    end
+  end
+end

data/lib/slack-wrapper/api/users.rb

@@ -0,0 +1,115 @@
+# https://api.slack.com/methods/users.info
+# https://api.slack.com/methods/users.list
+# https://api.slack.com/methods/users.profile.get
+# https://api.slack.com/methods/users.profile.set
+module Slack
+  module API
+    module Users
+      extend self
+      def info(id)
+        if Slack::API::Auth
+          uri  = URI.parse('https://slack.com/api/users.info')
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req  = Net::HTTP::Post.new("#{uri.to_s}?token=#{Slack::Config.token}&user=#{id}")
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            JSON.parse(resp.body)['user']
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def get_list()
+        if Slack::API::Auth
+          uri  = URI.parse('https://slack.com/api/users.list')
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req  = Net::HTTP::Post.new("#{uri.to_s}?token=#{Slack::Config.token}&presence=false")
+          resp = http.request(req)
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            JSON.parse(resp.body)['members']
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def search(term, what='username', regex=false)
+        users = get_list()
+        out = nil
+        case what
+          when 'email'
+            out = users.select{|u| u['profile']['email'] == term} unless regex
+            out = users.select{|u| u['profile']['email'] =~ /#{term}/}.first if regex
+          when 'username'
+            out = users.select{|u| u['name'] == term}.first unless regex
+            out = users.select{|u| u['name'] =~ /#{term}/} if regex
+          when 'name'
+            out = users.select{|u| u['profile']['real_name'] == term}.first unless regex
+            out = users.select{|u| u['profile']['real_name'] =~ /#{term}/} if regex
+          else
+            Slack::Errors.new({"error"   => "invalid_search_term",
+                               "detail"  => "You can only search by username, name, or email"})
+        end
+        out
+      end
+      def get_profile(id)
+        opts = {}
+        if Slack::API::Auth
+          opts['user'] = id
+          opts['token'] = Slack::Config.token
+          opts['include_labels'] = true
+          uri = URI.parse('https://slack.com/api/users.profile.get')
+          opts['token'] = Slack::Config.token
+          req = Net::HTTP::Post::Multipart.new(uri.path, opts)
+          res = Net::HTTP::new(uri.host, uri.port)
+          res.use_ssl = true
+          res.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          resp = res.start do |http|
+            http.request(req)
+          end
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            JSON.parse(resp.body)['profile']
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+      def set_profile(opts = {})
+        if Slack::API::Auth
+          opts['token'] = Slack::Config.token
+          uri = URI.parse('https://slack.com/api/users.profile.set')
+          opts['token'] = Slack::Config.token
+          req = Net::HTTP::Post::Multipart.new(uri.path, opts)
+          res = Net::HTTP::new(uri.host, uri.port)
+          res.use_ssl = true
+          res.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          resp = res.start do |http|
+            http.request(req)
+          end
+          false unless resp.code == 200
+          if JSON.parse(resp.body)['ok']
+            JSON.parse(resp.body)['profile']
+          else
+            Slack::Errors.new(JSON.parse(resp.body))
+          end
+        else
+          Slack::Errors.new({"error" => "not_authed"})
+        end
+      end
+    end
+    class << self
+    end
+  end
+end

data/lib/slack-wrapper/config.rb

@@ -0,0 +1,19 @@
+module Slack
+  module Config
+    extend self
+    attr_accessor :token, :logger
+    def reset
+      self.token  = ENV['SLACK_TOKEN'] ? ENV['SLACK_TOKEN'] : nil
+      self.logger = ENV['LOG_LEVEL'] ? ENV['LOG_LEVEL'] : nil
+    end
+    reset
+  end
+  class << self
+    def configure
+      block_given? ? yield(Config) : Config
+    end
+    def config
+      Config
+    end
+  end
+end

data/lib/slack-wrapper/errors.rb

@@ -0,0 +1,27 @@
+module Slack
+  class Errors
+    def initialize(object)
+      handle(object)
+    end
+    def handle(object)
+      raise RuntimeError, message(object)
+    end
+    def message(object)
+      case object['error']
+        when nil
+          error = "Undefined Error"
+        when "not_authed"
+          object['detail'] = "Invalid Token, check configuration"
+        when String
+          error = object['error']
+      end
+      case object['detail']
+        when nil
+          detail = "Details unknown"
+        when String
+          detail = object['detail']
+      end
+      "Error '#{error}' occured. Details: #{detail}"
+    end
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: slack-wrapper
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jason Colyer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-09-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: multipart-post
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Simple Slack API wrapper for ruby
+email: jcolyer2007@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/slack-wrapper.rb
+- lib/slack-wrapper/api.rb
+- lib/slack-wrapper/api/auth.rb
+- lib/slack-wrapper/api/bots.rb
+- lib/slack-wrapper/api/channels.rb
+- lib/slack-wrapper/api/chat.rb
+- lib/slack-wrapper/api/files.rb
+- lib/slack-wrapper/api/im.rb
+- lib/slack-wrapper/api/permissions.rb
+- lib/slack-wrapper/api/rtm.rb
+- lib/slack-wrapper/api/users.rb
+- lib/slack-wrapper/config.rb
+- lib/slack-wrapper/errors.rb
+homepage: https://rubygems.org/gems/slack-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: TBD
+test_files: []