paddle_pay 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d4b576ab1993da2a68d2157288909b5a32263c0e64fba65c8f590ade235e34e4
+  data.tar.gz: 055e96a399e3b98a508ff638506bb44383fc05020258202447d314ffc7d1a402
+SHA512:
+  metadata.gz: 4d4abed1bfa549c2fc8c50522c462d65ed0a82a92b046e9b72663556e90d5f16f07a17d61f8dc127b9a6b963a03bcc098a12c233f488372d16b4666b40ae120f
+  data.tar.gz: 5f82a368c69a8231840ecf002702ab0e44ec9e8e38f3ff8cf25135dd4e1a6da8bb41ba1215bf8147799afc442f85f63f83455116edfd7cad6e6bc88348beeeee

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2020 Nicolas Metzger
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,207 @@
+# PaddlePay
+
+A Ruby wrapper for the paddle.com API.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'paddle_pay'
+```
+
+And then execute:
+
+    $ bundle
+
+## Configuration
+
+Configure the gem with the credentials obtained from the Paddle Dashboard
+
+```ruby
+PaddlePay.configure do |config|
+  config.vendor_id = 'YOUR VENDOR ID'
+  config.vendor_auth_code = 'YOUR VENDOR AUTH CODE'
+end
+```
+## Usage
+
+### Product
+List all published one-time products associated with your account:
+```ruby
+PaddlePay::Product.list(filters = {}, options = {})
+```
+
+##### Coupons
+Return any available coupons valid for a specified one-time product or subscription plan:
+```ruby
+product_id = 123456
+PaddlePay::Product::Coupon.list(product_id, options = {})
+```
+
+Create a new coupon for the given product or a checkout:
+```ruby
+attributes = { coupon_type: 'checkout', discount_type: 'percentage', discount_amount: '20', allowed_uses: 10 }
+PaddlePay::Product::Coupon.create(attributes, options = {})
+```
+
+Delete a given coupon and prevent it from being further used:
+```ruby
+coupon_code = 'ABCDEFG'
+product_id = 123456
+PaddlePay::Product::Coupon.delete(coupon_code, product_id, options = {})
+```
+
+Updating a single coupon code:
+```ruby
+coupon_code = 'ABCDEFG'
+attributes = { allowed_uses: 10 }
+PaddlePay::Product::Coupon.update_code(coupon_code, attributes = {}, options = {})
+```
+
+Updating a group of coupons:
+```ruby
+group = 'GROUP123'
+attributes = { allowed_uses: 10 }
+PaddlePay::Product::Coupon.update_group(group, attributes = {}, options = {})
+```
+
+##### Pay Links
+Set custom attributes for a one-time or subscription checkout link:
+```ruby
+attributes = { product_id: '123456' }
+PaddlePay::Product::PayLink.generate(attributes, options = {})
+```
+
+##### Payments
+Request a refund for a one-time payment, either in full or partial:
+```ruby
+order_id = 123456
+PaddlePay::Product::Payment.refund(order_id, attributes = {}, options = {})
+```
+
+### Subscription
+
+##### Plans
+List all of the available subscription plans:
+```ruby
+PaddlePay::Subscription::Plan.list(filters = {}, options = {})
+```
+
+Create a new subscription billing plan:
+```ruby
+attributes = { plan_name: 'Test', plan_trial_days: 30, plan_length: 1, plan_type: 'month', main_currency_code: 'USD', recurring_price_usd: '5.00' }
+PaddlePay::Subscription::Plan.create(attributes, options = {})
+```
+
+##### Subscription Users
+List all users subscribed to any of your subscription plans:
+```ruby
+PaddlePay::Subscription::User.list(filters = {}, options = {})
+```
+
+Cancel the specified subscription:
+```ruby
+subscription_id = 1234567
+PaddlePay::Subscription::User.cancel(subscription_id, options = {})
+```
+
+Update the quantity, price, and/or plan of a user’s subscription:
+```ruby
+subscription_id = 1234567
+attributes = { recurring_price: '10.00', currency: 'USD', quantity: 1, plan_id: 12345 }
+PaddlePay::Subscription::User.update(subscription_id, attributes, options = {})
+```
+
+Get a preview of subscription changes before they are committed:
+```ruby
+PaddlePay::Subscription::User.preview_update(subscription_id, attributes, options = {})
+```
+##### Modifiers
+List all the subscription modifiers:
+```ruby
+PaddlePay::Subscription::Modifier.list(filters = {}, options = {})
+```
+
+Add a modifier to a recurring subscription:
+```ruby
+attributes = { subscription_id: 1234567, modifier_amount: '1.00', modifier_description: 'Test' }
+PaddlePay::Subscription::Modifier.create(attributes, options = {})
+```
+
+Delete an existing subscription price modifier:
+```ruby
+modifier_id = 12345
+PaddlePay::Subscription::Modifier.delete(modifier_id, options = {})
+```
+
+##### Payments
+List all paid and upcoming (unpaid) payments:
+```ruby
+PaddlePay::Subscription::Payment.list(filters = {}, options = {})
+```
+Change the due date on an upcoming subscription payment:
+```ruby
+payment_id = 123456
+date = '2020-12-31' # in format YYYY-MM-DD
+PaddlePay::Subscription::Payment.reschedule(payment_id, date, options = {})
+```
+
+Request a refund for a subscription payment, either in full or partial:
+```ruby
+order_id = 123456
+PaddlePay::Subscription::Payment.refund(order_id, attributes = {}, options = {})
+```
+
+##### One-off Charges
+Make immediate one-time charges on top of an existing subscription:
+```ruby
+subscription_id = 1234567
+amount = '5.00'
+charge_name = 'Test'
+PaddlePay::Subscription::Charge.create(subscription_id, amount, charge_name, options = {})
+```
+
+### Alert
+
+##### Webhooks
+Retrieve past events and alerts that Paddle has sent to webhooks on your account:
+```ruby
+PaddlePay::Alert::Webhook.history(filters = {}, options = {})
+```
+
+### Transaction
+Retrieve transactions for related entities within Paddle:
+##### Checkout
+```ruby
+id = '123456'
+PaddlePay::Transaction::Checkout.list(id, options = {})
+```
+##### Order
+```ruby
+id = '123456'
+PaddlePay::Transaction::Order.list(id, options = {})
+```
+##### Product
+```ruby
+id = '123456'
+PaddlePay::Transaction::Product.list(id, options = {})
+```
+##### Subscription
+```ruby
+id = '123456'
+PaddlePay::Transaction::Subscription.list(id, options = {})
+```
+##### User
+```ruby
+id = '123456'
+PaddlePay::Transaction::User.list(id, options = {})
+```
+
+## Development
+
+Check out the repository and run `bin/setup` to install dependencies. For configuration run `mv .env.template .env` and set your credentials in the required fields. After that, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/paddle_pay.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'json'
+
+require_relative 'paddle_pay/configuration'
+require_relative 'paddle_pay/connection'
+require_relative 'paddle_pay/util'
+require_relative 'paddle_pay/version'
+require_relative 'paddle_pay/errors/paddle_pay_error'
+require_relative 'paddle_pay/models/alert/webhook'
+require_relative 'paddle_pay/models/product/coupon'
+require_relative 'paddle_pay/models/product/license'
+require_relative 'paddle_pay/models/product/pay_link'
+require_relative 'paddle_pay/models/product/payment'
+require_relative 'paddle_pay/models/product/product'
+require_relative 'paddle_pay/models/subscription/charge'
+require_relative 'paddle_pay/models/subscription/modifier'
+require_relative 'paddle_pay/models/subscription/payment'
+require_relative 'paddle_pay/models/subscription/plan'
+require_relative 'paddle_pay/models/subscription/user'
+require_relative 'paddle_pay/models/transaction/checkout'
+require_relative 'paddle_pay/models/transaction/order'
+require_relative 'paddle_pay/models/transaction/product'
+require_relative 'paddle_pay/models/transaction/subscription'
+require_relative 'paddle_pay/models/transaction/user'
+
+module PaddlePay
+  class << self
+    attr_writer :config
+  end
+
+  def self.configure
+    yield(config) if block_given?
+  end
+
+  def self.config
+    @config ||= PaddlePay::Configuration.new
+  end
+end

data/lib/paddle_pay/configuration.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module PaddlePay
+  class Configuration
+    attr_reader :vendors_url
+    attr_reader :vendor_auth_code
+    attr_reader :vendor_id
+
+    def initialize
+      @vendors_url = 'https://vendors.paddle.com/api'
+    end
+
+    attr_writer :vendor_auth_code
+
+    attr_writer :vendor_id
+  end
+end

data/lib/paddle_pay/connection.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module PaddlePay
+  module Connection
+    class << self
+      def request(url, options = {})
+        request_url = PaddlePay.config.vendors_url
+        params = options.delete(:params) || {}
+        headers = options.delete(:headers) || {}
+        body = options.delete(:body) || {}
+
+        conn = Faraday.new(url: request_url) do |faraday|
+          faraday.request :url_encoded
+          faraday.response :raise_error
+          faraday.adapter :net_http
+        end
+
+        begin
+          response = conn.post(url, config.merge(body)) do |req|
+            req.params.merge!(params)
+            req.headers.merge!(headers)
+          end
+          result = parse(response)
+          unless result['success']
+            raise PaddlePayError.new(result['error']['message'], result['error']['code'])
+          end
+
+          PaddlePay::Util.convert_hash_keys(result['response'])
+        rescue Faraday::BadRequestError => e
+          raise BadRequestError.new(e.response[:body], e.response[:status])
+        rescue Faraday::UnauthorizedError => e
+          raise UnauthorizedError.new(e.response[:body], e.response[:status])
+        rescue Faraday::ForbiddenError => e
+          raise ForbiddenError.new(e.response[:body], e.response[:status])
+        rescue Faraday::ResourceNotFound => e
+          raise ResourceNotFoundError.new(e.response[:body], e.response[:status])
+        rescue Faraday::ProxyAuthError => e
+          raise ProxyAuthError.new(e.response[:body], e.response[:status])
+        rescue Faraday::ConflictError => e
+          raise ConflictError.new(e.response[:body], e.response[:status])
+        rescue Faraday::UnprocessableEntityError => e
+          raise UnprocessableEntityError.new(e.response[:body], e.response[:status])
+        rescue Faraday::TimeoutError => e
+          raise TimeoutError, 'The connection has timed out'
+        rescue Faraday::ConnectionFailed => e
+          raise ConnectionError, 'The connection failed'
+        rescue Faraday::ServerError => e
+          raise ServerError.new(e.response[:body], e.response[:status])
+        end
+      end
+
+      private
+
+      def parse(response)
+        JSON.parse(response.body)
+      rescue JSON::ParserError
+        raise ParseError, "Invalid response object from API: #{response.body.inspect} " \
+                    "(HTTP response code was #{response.status})"
+      end
+
+      def config
+        {
+          vendor_id: PaddlePay.config.vendor_id,
+          vendor_auth_code: PaddlePay.config.vendor_auth_code
+        }
+      end
+    end
+  end
+end

data/lib/paddle_pay/errors/paddle_pay_error.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# based off of stripe gem: https://github.com/stripe/stripe-ruby
+module PaddlePay
+  class PaddlePayError < StandardError
+    attr_reader :code
+    attr_reader :message
+
+    def initialize(message, code = nil)
+      super("#{message} #{'(Code ' + code.to_s + ')' if code}")
+      @code = code
+      @message = message
+    end
+  end
+
+  class ClientError < PaddlePayError
+  end
+
+  class BadRequestError < ClientError
+  end
+
+  class UnauthorizedError < ClientError
+  end
+
+  class ForbiddenError < ClientError
+  end
+
+  class ResourceNotFoundError < ClientError
+  end
+
+  class ProxyAuthError < ClientError
+  end
+
+  class ConflictError < ClientError
+  end
+
+  class UnprocessableEntityError < ClientError
+  end
+
+  class ServerError < PaddlePayError
+  end
+
+  class LimitExceededError < ServerError
+  end
+
+  class ConnectionError < ServerError
+  end
+
+  class TimeoutError < ServerError
+  end
+
+  class ParseError < ServerError
+  end
+end

data/lib/paddle_pay/models/alert/webhook.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module PaddlePay
+  module Alert
+    module Webhook
+      class << self
+        def history(filters = {}, options = {})
+          options.merge!({ body: filters }) if filters.is_a?(::Hash)
+          Connection.request('2.0/alert/webhooks', options)
+        end
+      end
+    end
+  end
+end

data/lib/paddle_pay/models/product/coupon.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module PaddlePay
+  module Product
+    module Coupon
+      class << self
+        def list(product_id, options = {})
+          options.merge!({ body: { product_id: product_id } })
+          Connection.request('2.0/product/list_coupons', options)
+        end
+
+        def create(attributes, options = {})
+          options.merge!({ body: attributes }) if attributes.is_a?(::Hash)
+          Connection.request('2.1/product/create_coupon', options)
+        end
+
+        def delete(coupon_code, product_id, options = {})
+          options.merge!({ body: { coupon_code: coupon_code, product_id: product_id } })
+          Connection.request('2.0/product/delete_coupon', options)
+        end
+
+        def update_code(coupon_code, attributes = {}, options = {})
+          attributes.merge!(coupon_code: coupon_code)
+          options.merge!({ body: attributes })
+          Connection.request('2.1/product/update_coupon', options)
+        end
+
+        def update_group(group, attributes = {}, options = {})
+          attributes.merge!(group: group)
+          options.merge!({ body: attributes })
+          Connection.request('2.1/product/update_coupon', options)
+        end
+      end
+    end
+  end
+end