solidus_webhooks 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33eeb1647a31a48efa2e66d1cb4747938f4dafd467f5ac9c1dd1713ef88e0292
-  data.tar.gz: 77f21a95ead4dbf098a7a92527354bced8078c9475edf522eee577ca8283e5e7
+  metadata.gz: d71609325f0e59694111c1efee4a131a283af6dfac87d9102a9e405dfca918ea
+  data.tar.gz: b9f80ecd1f6652d83915b2a49c083285df3e7e17c63b01414c273857daeadd44
 SHA512:
-  metadata.gz: 3b55c38a880b83ff3d95d0622dc425973590a6b1051fe8f16a9f364713b552e7cf20755f413f9c25c89b2a893cd2ebb4892230837e3000d469cbe1fcfb39d33f
-  data.tar.gz: f45d9569f09fd41009ae627bdfe10855d74bffd66a5c54daba52a2442b62be8307090e7946a0deb369f8792cf3eb82b939944457ff177e78ed1cee32fe178d7b
+  metadata.gz: 826c8abe905a3a69d7ea642b72a047534282db7bb60c3cdced93f897c2d62f887d72807aff7cb57cc5ec1082966b9602908c97d7ba2d866ad3ffb8aeb0f09ce1
+  data.tar.gz: 8fab3c87b593ca5743818ed8551296b85709813341fa5bba3ddd2561992138fc92ba984525b3080a5c30fd9d2b64f35f99d610cdcd885115f1732eadccbe4780

data/README.md

@@ -108,6 +108,20 @@ Spree::RoleConfiguration.configure do |config|
 end
 ```
 
+### Accessing the API User
+
+If you need to access the API user that is making the call to the webhook, you can just accept an additional argument in the callable handler.
+
+Example:
+
+```ruby
+SolidusWebhooks.config.register_webhook_handler :tracking_number, -> payload, user {
+  Rails.logger.info "Received payload from user #{user.email}: #{payload.to_json}"
+  # …
+}
+```
+
+
 Installation
 ------------
 

data/app/controllers/spree/webhooks_controller.rb

@@ -4,10 +4,11 @@ class Spree::WebhooksController < Spree::Api::BaseController
   def receive
     webhook = Spree::Webhook.find(params[:id])
     payload = request.request_parameters["webhook"]
+    user = current_api_user
 
     authorize! :receive, webhook
 
-    webhook.receive(payload)
+    webhook.receive(payload, user)
 
     head :ok
   end

data/app/models/spree/webhook.rb

@@ -4,8 +4,12 @@ class Spree::Webhook
 
   WebhookNotFound = Class.new(StandardError)
 
-  def receive(payload)
-    handler.call(payload)
+  def receive(payload, user)
+    if handler_arity == 1
+      handler.call(payload)
+    else
+      handler.call(payload, user)
+    end
   end
 
   def self.find(id)
@@ -16,4 +20,14 @@ class Spree::Webhook
 
     new(id: id, handler: handler)
   end
+
+  private
+
+  def handler_arity
+    if handler.respond_to?(:arity)
+      handler.arity
+    else
+      handler.method(:call).arity
+    end
+  end
 end

data/lib/solidus_webhooks/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SolidusWebhooks
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/spec/features/can_register_a_handler_and_receive_webhooks_spec.rb

@@ -3,45 +3,73 @@ require 'spec_helper'
 RSpec.feature "Can register a handler and receive Webhooks", type: :request do
   background do
     SolidusWebhooks.reset_config!
-    SolidusWebhooks.config.register_webhook_handler :foo, foo_handler
-    SolidusWebhooks.config.register_webhook_handler :bar, bar_handler
+    SolidusWebhooks.config.register_webhook_handler :proc, proc_handler
+    SolidusWebhooks.config.register_webhook_handler :method, method_handler
+    SolidusWebhooks.config.register_webhook_handler :user, user_handler
+    SolidusWebhooks.config.register_webhook_handler :splat, splat_handler
+    SolidusWebhooks.config.register_webhook_handler :method_and_user, method_and_user_handler
   end
 
-  let(:foo_payloads) { [] }
-  let(:bar_payloads) { [] }
+  let(:proc_payloads) { [] }
+  let(:method_payloads) { [] }
+  let(:user_payloads) { [] }
+  let(:splat_payloads) { [] }
+  let(:method_and_user_payloads) { [] }
 
-  let(:foo_handler) { ->(payload) { foo_payloads << payload } }
-  let(:bar_handler) { ->(payload) { bar_payloads << payload } }
+  let(:proc_handler) { ->(payload) { proc_payloads << payload } }
+  let(:method_handler) { Struct.new(:payloads) do
+    def call(payload) payloads << payload end
+  end.new(method_payloads) }
+  let(:user_handler) { ->(payload, user) { user_payloads << [payload, user] } }
+  let(:splat_handler) { ->(*args) { splat_payloads << args } }
+  let(:method_and_user_handler) { Struct.new(:payloads) do
+    def call(payload, user) payloads << payload end
+  end.new(method_and_user_payloads) }
 
-  let(:token) { create(:admin_user, spree_api_key: "123").spree_api_key }
-  let(:token_without_permission) { create(:user, spree_api_key: "456").spree_api_key }
+  let(:authorized_user) { create(:admin_user, spree_api_key: "123") }
+  let(:authorized_token) { authorized_user.spree_api_key }
+
+  let(:unauthorized_user) { create(:user, spree_api_key: "456") }
+  let(:unauthorized_token) { unauthorized_user.spree_api_key }
 
   scenario "calls the handler passing the payload" do
-    post "/webhooks/foo?token=#{token}", as: :json, params: {a: 123}
+    post "/webhooks/proc?token=#{authorized_token}", as: :json, params: {a: 123}
+    expect(response).to have_http_status(:ok)
+
+    post "/webhooks/proc?token=#{authorized_token}", as: :json, params: {b: 456}
+    expect(response).to have_http_status(:ok)
+
+    post "/webhooks/method?token=#{authorized_token}", as: :json, params: {c: 789}
+    expect(response).to have_http_status(:ok)
+
+    post "/webhooks/user?token=#{authorized_token}", as: :json, params: {d: 012}
     expect(response).to have_http_status(:ok)
 
-    post "/webhooks/foo?token=#{token}", as: :json, params: {b: 456}
+    post "/webhooks/splat?token=#{authorized_token}", as: :json, params: {e: 345}
     expect(response).to have_http_status(:ok)
 
-    post "/webhooks/bar?token=#{token}", as: :json, params: {c: 789}
+    post "/webhooks/method_and_user?token=#{authorized_token}", as: :json, params: {f: 678}
     expect(response).to have_http_status(:ok)
 
-    expect(foo_payloads).to eq([{'a' => 123}, {'b' => 456}])
-    expect(bar_payloads).to eq([{'c' => 789}])
+    expect(proc_payloads).to eq([{'a' => 123}, {'b' => 456}])
+    expect(method_payloads).to eq([{'c' => 789}])
+    expect(user_payloads).to eq([[{'d' => 012}, authorized_user]])
+    expect(splat_payloads).to eq([[{'e' => 345}, authorized_user]])
+    expect(method_and_user_payloads).to eq([{'f' => 678}])
   end
 
   scenario "receives a bad handler id" do
-    post "/webhooks/baz?token=#{token}", as: :json, params: {a: 123}
+    post "/webhooks/abc?token=#{authorized_token}", as: :json, params: {a: 123}
     expect(response).to have_http_status(:not_found)
   end
 
   scenario "refuses a bad token" do
-    post "/webhooks/baz?token=b4d-t0k3n", as: :json, params: {a: 123}
+    post "/webhooks/user?token=b4d-t0k3n", as: :json, params: {a: 123}
     expect(response).to have_http_status(:unauthorized)
   end
 
   scenario "refuses a token without permissions" do
-    post "/webhooks/foo?token=#{token_without_permission}", as: :json, params: {a: 123}
+    post "/webhooks/proc?token=#{unauthorized_token}", as: :json, params: {a: 123}
     expect(response).to have_http_status(:unauthorized)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solidus_webhooks
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Elia Schito
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-14 00:00:00.000000000 Z
+date: 2020-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: solidus_core