grape-slack-bot 1.3.0 → 1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 669dbf492365849f4628ed362f0a047e70d15cb80a62a236260be26d76fbaacc
-  data.tar.gz: e17819f3afa4096b5623c4a8d19f6443522c2010d528ac6a14fefc17fb3c3309
+  metadata.gz: 2d248818a6772bc6b90aaaff5e6a32f34ed8f1be71d3865435929e018f30d48b
+  data.tar.gz: 8719e28b6995efa871e4a834aa5ac884cbda4133034805e256ddf53786c1fdb2
 SHA512:
-  metadata.gz: 05de3c891473d52722c368bd587e7a90b7d8e9eaa96c4f6bd59bd4bbb5f867c265e2fab1b2e95076abd8b75c0dd9460a51ea460909afd538e9c0c0962fe8250c
-  data.tar.gz: c80d3a362202a526df44c32dad70270109ef344180d7d83d27cca9a24c9f308d422c7f8f91215a0a31b357ef2e86d14771b048f344051a7bc48ca27f80fa73d1
+  metadata.gz: 3a20d2e0f603d9f5a1cbfc24d8e08e9907b12d6d677442d63160cf0a5f57b3dc56234bd65b0d979749574e290a3a3fb00b8f014bf219c8bf969e2c4d1cd7f7f3
+  data.tar.gz: f3401998a0b1cd270e952107d86f2da78de98cc45b4260d7205998ff173e00f356d09185d08f50416bebe5b38593fe9cb40e829b2f4a4454bc3dafd53414227b

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# 1.5.0
+
+* Complete upgrade of callback storage logic
+
+# 1.4.0
+
+* Allow setting callback expiration time on save and update
+
 # 1.3.0
 
 * Clean up callback arguments, remove unused `method_name`

data/lib/slack_bot/callback.rb

@@ -3,42 +3,53 @@ require 'active_support/core_ext/numeric/time'
 
 module SlackBot
   class Callback
-    CALLBACK_CACHE_KEY = "slack-bot-callback".freeze
+    CALLBACK_KEY_PREFIX = "slack-bot-callback".freeze
+    CALLBACK_RECORD_EXPIRES_IN = 15.minutes.freeze
 
-    def self.find(id, config: nil)
+    def self.find(id, user: nil, config: nil)
       return if id.blank?
 
-      callback = new(id: id, config: config)
+      callback = new(id: id, user: user, config: config)
       callback.reload
     rescue SlackBot::Errors::CallbackNotFound
       nil
     end
 
-    def self.create(class_name:, user:, channel_id: nil, config: nil)
+    def self.create(class_name:, user:, channel_id: nil, config: nil, payload: nil, expires_in: nil, user_scope: nil)
       callback =
-        new(class_name: class_name, user: user, channel_id: channel_id, config: config)
+        new(class_name: class_name, user: user, channel_id: channel_id, payload: payload, config: config, expires_in: expires_in, user_scope: user_scope)
       callback.save
       callback
     end
 
-    attr_reader :id, :data, :args, :config
-    def initialize(id: nil, class_name: nil, user: nil, channel_id: nil, extra: nil, config: nil)
+    def self.find_or_create(id:, class_name:, user:, channel_id: nil, config: nil, payload: nil, expires_in: nil, user_scope: nil)
+      callback = find(id, user: user, config: config)
+      return callback if callback.present?
+
+      create(class_name: class_name, user: user, channel_id: channel_id, payload: payload, config: config, expires_in: expires_in, user_scope: user_scope)
+    end
+
+    attr_reader :id, :data, :args, :config, :expires_in, :user_scope
+    def initialize(id: nil, class_name: nil, user: nil, channel_id: nil, payload: nil, config: nil, expires_in: nil, user_scope: nil)
       @id = id
       @data = {
         class_name: class_name,
         user_id: user&.id,
         channel_id: channel_id,
-        extra: extra
+        payload: payload
       }
       @args = SlackBot::Args.new
       @config = config || SlackBot::Config.current_instance
+      @expires_in = expires_in || CALLBACK_RECORD_EXPIRES_IN
+      @user_scope = user_scope.nil? ? true : user_scope
     end
 
     def reload
-      @data = read_data
-      SlackBot::DevConsole.log_check("SlackBot::Callback#read_data: #{id} | #{data}")
-      raise SlackBot::Errors::CallbackNotFound if data.nil?
+      cached_data = read_data
+      SlackBot::DevConsole.log_check("SlackBot::Callback#read_data: #{id} | #{cached_data}")
+      raise SlackBot::Errors::CallbackNotFound if cached_data.nil?
 
+      @data = cached_data
       parse_args
       self
     end
@@ -55,7 +66,12 @@ module SlackBot
       return if id.blank?
       return if data.blank?
 
-      @data = data.merge(payload)
+      if @data[:payload].is_a?(Hash)
+        @data[:payload] = @data[:payload].merge(payload)
+      else
+        @data[:payload] = payload
+      end
+
       save
     end
 
@@ -72,6 +88,23 @@ module SlackBot
       end
     end
 
+    def user=(user)
+      @user = user
+      @data[:user_id] = user&.id
+    end
+
+    def class_name=(class_name)
+      @data[:class_name] = class_name
+    end
+
+    def channel_id=(channel_id)
+      @data[:channel_id] = channel_id
+    end
+
+    def payload=(payload)
+      @data[:payload] = payload
+    end
+
     def handler_class
       return if class_name.blank?
 
@@ -80,6 +113,7 @@ module SlackBot
 
     def method_missing(method_name, *args, &block)
       return data[method_name.to_sym] if data.key?(method_name.to_sym)
+      return data[:payload][method_name.to_s] if data[:payload].is_a?(Hash) && data[:payload].key?(method_name.to_s)
 
       super
     end
@@ -91,23 +125,34 @@ module SlackBot
     end
 
     def serialize_args
-      data[:args] = args.to_s
+      @data[:args] = args.to_s
     end
 
     def generate_id
-      SecureRandom.uuid
+      SecureRandom.hex(10)
+    end
+
+    def storage_key
+      if user_scope
+        raise "User is required for scoped callback" if user.blank?
+
+        "#{CALLBACK_KEY_PREFIX}:u#{user.id}:#{id}"
+      else
+        "#{CALLBACK_KEY_PREFIX}:#{id}"
+      end
     end
 
     def read_data
-      config.callback_storage_instance.read("#{CALLBACK_CACHE_KEY}:#{id}")
+      config.callback_storage_instance.read(storage_key)
     end
 
-    def write_data(data)
-      config.callback_storage_instance.write("#{CALLBACK_CACHE_KEY}:#{id}", data, expires_in: 1.hour)
+    def write_data(data, expires_in: nil)
+      expires_in ||= CALLBACK_RECORD_EXPIRES_IN
+      config.callback_storage_instance.write(storage_key, data, expires_in: expires_in)
     end
 
     def delete_data
-      config.callback_storage_instance.delete("#{CALLBACK_CACHE_KEY}:#{id}")
+      config.callback_storage_instance.delete(storage_key)
     end
   end
 end

data/lib/slack_bot/grape_extension.rb

@@ -88,7 +88,7 @@ module SlackBot
           callback = SlackBot::Callback.find(callback_id, config: config)
           raise SlackBot::Errors::CallbackNotFound.new if callback.blank?
 
-          SlackBot::DevConsole.log_check "SlackApi::Interactions##{__method__}: #{callback.id} #{callback.extra} #{callback.user_id} #{user&.id}"
+          SlackBot::DevConsole.log_check "SlackApi::Interactions##{__method__}: #{callback.id} #{callback.payload} #{callback.user_id} #{user&.id}"
 
           if callback.user_id != user.id
             raise "Callback user is not equal to action user"

data/lib/slack_bot.rb

@@ -22,5 +22,5 @@ require 'slack_bot/pager'
 require 'slack_bot/grape_extension'
 
 module SlackBot
-  VERSION = '1.3.0'.freeze
+  VERSION = '1.5.1'.freeze
 end

data/spec/slack_bot/callback_spec.rb

@@ -6,7 +6,7 @@ describe SlackBot::Callback do
       class_name: "Test",
       user: user,
       channel_id: "test_channel_id",
-      extra: { test: "test" },
+      payload: { test: "test" },
       config: config
     )
   }
@@ -26,174 +26,115 @@ describe SlackBot::Callback do
   let(:callback_id) { "test_callback_id" }
 
   describe ".find" do
-    subject(:find) { described_class.find(callback_id, config: config) }
+    subject(:find) { described_class.find(callback_id, user: user, config: config) }
 
-    before do
-      allow(callback_storage_instance).to receive(:read).with("slack-bot-callback:test_callback_id").and_return(data)
-    end
-
-    context "when callback is found" do
-      let(:data) { { class_name: "Test", user_id: 1, channel_id: "test_channel_id", extra: { test: "test" }, args: "" } }
-
-      it "returns callback" do
-        expect(find).to be_a(described_class)
-        expect(find.id).to eq(callback_id)
-        expect(find.class_name).to eq("Test")
-        expect(find.user).to eq(user)
-        expect(find.user_id).to eq(1)
-        expect(find.channel_id).to eq("test_channel_id")
-        expect(find.extra).to eq({ test: "test" })
-      end
-    end
-
-    context "when callback is not found" do
-      let(:data) { nil }
-
-      it "returns nil" do
-        expect(find).to eq(nil)
-      end
-    end
-  end
-
-  describe ".create" do
-    subject(:create) { described_class.create(class_name: "Test", user: user, channel_id: "test_channel_id", config: config) }
-
-    before do
-      allow_any_instance_of(described_class).to receive(:generate_id).and_return("test_callback_id")
-      allow(callback_storage_instance).to receive(:write).with("slack-bot-callback:test_callback_id", {
-        args: "",
-        class_name: "Test",
-        user_id: 1,
-        channel_id: "test_channel_id",
-        extra: nil
-      }, expires_in: 1.hour)
-    end
-
-    let(:data) { { class_name: "Test", user_id: 1, channel_id: "test_channel_id", extra: nil } }
-
-    it "returns callback" do
-      expect(create).to be_a(described_class)
-      expect(create.id).to eq("test_callback_id")
-      expect(create.class_name).to eq("Test")
-      expect(create.user).to eq(user)
-      expect(create.user_id).to eq(1)
-      expect(create.channel_id).to eq("test_channel_id")
-      expect(create.extra).to eq(nil)
-    end
-  end
-
-  describe "#reload" do
-    subject(:reload) { callback.reload }
-    let(:callback) {
-      described_class.new(id: "test_callback_id", config: config)
-    }
-    let(:data) {
+    let(:cached_data) {
       {
         class_name: "Test",
-        user_id: 1,
+        user_id: user.id,
         channel_id: "test_channel_id",
-        extra: { test: "test" },
-        args: ""
+        payload: { test: "test" },
+        args: "test"
       }
     }
 
     before do
-      allow(callback_storage_instance).to receive(:read).with("slack-bot-callback:test_callback_id").and_return(data)
+      allow(callback_storage_instance).to receive(:read).with("#{SlackBot::Callback::CALLBACK_KEY_PREFIX}:u#{user.id}:#{callback_id}").and_return(cached_data)
     end
 
     it "returns callback" do
-      expect(reload).to be_a(described_class)
-      expect(reload.id).to eq("test_callback_id")
-      expect(reload.class_name).to eq("Test")
-      expect(reload.user).to eq(user)
-      expect(reload.user_id).to eq(1)
-      expect(reload.channel_id).to eq("test_channel_id")
-      expect(reload.extra).to eq({ test: "test" })
+      expect(find).to be_a(described_class)
+      expect(find.id).to eq(callback_id)
+      expect(find.class_name).to eq("Test")
+      expect(find.user).to eq(user)
+      expect(find.channel_id).to eq("test_channel_id")
+      expect(find.payload).to eq({ test: "test" })
+      expect(find.args).to be_a(SlackBot::Args)
     end
 
     context "when callback is not found" do
-      let(:data) { nil }
+      let(:cached_data) { nil }
 
-      it "raises error" do
-        expect { reload }.to raise_error(SlackBot::Errors::CallbackNotFound)
+      it "returns nil" do
+        expect(find).to be_nil
       end
     end
   end
 
-  describe "#save" do
-    subject(:save) { callback.save }
-    let(:callback) {
-      described_class.new(
+  describe ".create" do
+    subject(:create) {
+      described_class.create(
         class_name: "Test",
         user: user,
         channel_id: "test_channel_id",
-        extra: { test: "test" },
+        payload: { test: "test" },
         config: config
       )
     }
 
-    before do
-      allow_any_instance_of(described_class).to receive(:generate_id).and_return("test_callback_id")
-      allow(callback_storage_instance).to receive(:write).with("slack-bot-callback:test_callback_id", {
-        args: "",
+    let(:cached_data) {
+      {
         class_name: "Test",
-        user_id: 1,
+        user_id: user.id,
         channel_id: "test_channel_id",
-        extra: { test: "test" }
-      }, expires_in: 1.hour)
+        payload: { test: "test" },
+        args: ""
+      }
+    }
+
+    before do
+      allow_any_instance_of(described_class).to receive(:generate_id).and_return(callback_id)
+      allow(callback_storage_instance).to receive(:write).with("#{SlackBot::Callback::CALLBACK_KEY_PREFIX}:u#{user.id}:#{callback_id}", cached_data, expires_in: SlackBot::Callback::CALLBACK_RECORD_EXPIRES_IN).and_return(cached_data)
+      allow(callback_storage_instance).to receive(:read).with("#{SlackBot::Callback::CALLBACK_KEY_PREFIX}:u#{user.id}:#{callback_id}").and_return(cached_data)
     end
 
-    it "returns callback" do
-      expect { save }.not_to raise_error
-      expect(callback).to be_a(described_class)
-      expect(callback.id).to eq("test_callback_id")
-      expect(callback.args).to be_a(SlackBot::Args)
+    it "creates callback" do
+      expect(create).to be_a(described_class)
+      expect(create.id).to be_present
+      expect(create.class_name).to eq("Test")
+      expect(create.user).to eq(user)
+      expect(create.channel_id).to eq("test_channel_id")
+      expect(create.payload).to eq({ test: "test" })
+      expect(create.args).to be_a(SlackBot::Args)
     end
   end
 
-  describe "#update" do
-    subject(:update) { callback.update(payload) }
-    let(:callback) {
-      described_class.new(
-        id: "test_callback_id",
+  describe ".find_or_create" do
+    subject(:find_or_create) {
+      described_class.find_or_create(
+        id: callback_id,
         class_name: "Test",
         user: user,
         channel_id: "test_channel_id",
-        extra: { test: "test" },
+        payload: { test: "test" },
         config: config
       )
     }
 
-    before do
-      allow(callback_storage_instance).to receive(:write).with("slack-bot-callback:test_callback_id", {
-        args: "",
+    let(:cached_data) {
+      {
         class_name: "Test",
-        user_id: 1,
+        user_id: user.id,
         channel_id: "test_channel_id",
-        extra: { test: "test" },
-        test: "test"
-      }, expires_in: 1.hour)
-    end
-
-    let(:payload) { { test: "test" } }
+        payload: { test: "test" },
+        args: ""
+      }
+    }
 
-    it "returns callback" do
-      expect { update }.not_to raise_error
-      expect(callback).to be_a(described_class)
-      expect(callback.id).to eq("test_callback_id")
-      expect(callback.args).to be_a(SlackBot::Args)
+    before do
+      allow_any_instance_of(described_class).to receive(:generate_id).and_return(callback_id)
+      allow(callback_storage_instance).to receive(:write).with("#{SlackBot::Callback::CALLBACK_KEY_PREFIX}:u#{user.id}:#{callback_id}", cached_data, expires_in: SlackBot::Callback::CALLBACK_RECORD_EXPIRES_IN).and_return(cached_data)
+      allow(callback_storage_instance).to receive(:read).with("#{SlackBot::Callback::CALLBACK_KEY_PREFIX}:u#{user.id}:#{callback_id}").and_return(cached_data)
     end
-  end
-
-  describe "#destroy" do
-
-  end
-
-  describe "#user" do
-
-  end
-
-  describe "#handler_class" do
 
+    it "finds or creates callback" do
+      expect(find_or_create).to be_a(described_class)
+      expect(find_or_create.id).to eq(callback_id)
+      expect(find_or_create.class_name).to eq("Test")
+      expect(find_or_create.user).to eq(user)
+      expect(find_or_create.channel_id).to eq("test_channel_id")
+      expect(find_or_create.payload).to eq({ test: "test" })
+      expect(find_or_create.args).to be_a(SlackBot::Args)
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: grape-slack-bot
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.5.1
 platform: ruby
 authors:
 - Andrei Makarov