paddle 1.0.0 → 1.1.1

data/lib/paddle/classic/objects/plan.rb

@@ -0,0 +1,6 @@
+module Paddle
+  module Classic
+    class Plan < Object
+    end
+  end
+end

data/lib/paddle/classic/objects/product.rb

@@ -0,0 +1,6 @@
+module Paddle
+  module Classic
+    class Product < Object
+    end
+  end
+end

data/lib/paddle/classic/objects/transaction.rb

@@ -0,0 +1,6 @@
+module Paddle
+  module Classic
+    class Transaction < Object
+    end
+  end
+end

data/lib/paddle/classic/objects/user.rb

@@ -0,0 +1,6 @@
+module Paddle
+  module Classic
+    class User < Object
+    end
+  end
+end

data/lib/paddle/classic/objects/webhook.rb

@@ -0,0 +1,6 @@
+module Paddle
+  module Classic
+    class Webhook < Object
+    end
+  end
+end

data/lib/paddle/classic/resource.rb

@@ -0,0 +1,63 @@
+module Paddle
+  module Classic
+    class Resource
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+      end
+
+      private
+
+      # def get_request(url, params: {}, headers: {})
+      #   handle_response client.connection.get(url, params, headers)
+      # end
+
+      def post_request(url, body: {}, headers: {})
+        attrs = {vendor_id: client.vendor_id, vendor_auth_code: client.vendor_auth_code}
+        handle_response client.connection.post(url, attrs.merge(body), headers)
+      end
+
+      # def patch_request(url, body:, headers: {})
+      #   handle_response client.connection.patch(url, body, headers)
+      # end
+
+      # def put_request(url, body:, headers: {})
+      #   handle_response client.connection.put(url, body, headers)
+      # end
+
+      # def delete_request(url, params: {}, headers: {})
+      #   handle_response client.connection.delete(url, params, headers)
+      # end
+
+      def handle_response(response)
+        case response.status
+        when 400
+          raise Error, "Error 400: Your request was malformed. '#{response.body["message"]}'"
+        when 401
+          raise Error, "Error 401: You did not supply valid authentication credentials. '#{response.body["error"]}'"
+        when 403
+          raise Error, "Error 403: You are not allowed to perform that action. '#{response.body["error"]}'"
+        when 404
+          raise Error, "Error 404: No results were found for your request. '#{response.body["error"]}'"
+        when 409
+          raise Error, "Error 409: Your request was a conflict. '#{response.body["message"]}'"
+        when 429
+          raise Error, "Error 429: Your request exceeded the API rate limit. '#{response.body["error"]}'"
+        when 500
+          raise Error, "Error 500: We were unable to perform the request due to server-side problems. '#{response.body["error"]}'"
+        when 503
+          raise Error, "Error 503: You have been rate limited for sending more than 20 requests per second. '#{response.body["error"]}'"
+        when 501
+          raise Error, "Error 501: This resource has not been implemented. '#{response.body["error"]}'"
+        end
+
+        if response.body && response.body["error"]
+          raise Error, "Error #{response.body["error"]["code"]} - #{response.body["error"]["message"]}"
+        end
+
+        response
+      end
+    end
+  end
+end

data/lib/paddle/classic/resources/charges.rb

@@ -0,0 +1,13 @@
+module Paddle
+  module Classic
+    class ChargesResource < Resource
+
+      def create(subscription_id:, amount:, charge_name:)
+        attrs = {amount: amount, charge_name: charge_name}
+        response = post_request("2.0/subscription/#{subscription_id}/charge", body: attrs)
+        Charge.new(response.body["response"])
+      end
+
+    end
+  end
+end

data/lib/paddle/classic/resources/coupons.rb

@@ -0,0 +1,33 @@
+module Paddle
+  module Classic
+    class CouponsResource < Resource
+
+      def list(product_id:)
+        response = post_request("2.0/product/list_coupons", body: {product_id: product_id})
+        Collection.from_response(response, type: Coupon)
+      end
+
+      def create(coupon_type:, discount_type:, discount_amount:, **params)
+        attrs = {coupon_type: coupon_type, discount_type: discount_type, discount_amount: discount_amount}
+
+        response = post_request("2.1/product/create_coupon", body: attrs.merge(params))
+
+        coupons =  response.body["response"]["coupon_codes"]
+
+        coupons.map {|c| Paddle::Coupon.new(code: c)}
+      end
+
+      def delete(coupon_code:, product_id:)
+        attrs = {coupon_code: coupon_code, product_id: product_id}
+        response = post_request("2.0/product/delete_coupon", body: attrs)
+        return true if response.success?
+      end
+
+      def update(**params)
+        response = post_request("2.1/product/update_coupon", body: params)
+        return true if response.success?
+      end
+
+    end
+  end
+end

data/lib/paddle/classic/resources/licenses.rb

@@ -0,0 +1,15 @@
+module Paddle
+  module Classic
+    class LicensesResource < Resource
+
+      def generate(product_id:, allowed_uses:, **params)
+        attrs = {product_id: product_id, allowed_uses: allowed_uses}
+
+        response = post_request("2.0/product/generate_license", body: attrs.merge(params))
+
+        License.new(response.body["response"]) if response.success?
+      end
+
+    end
+  end
+end

data/lib/paddle/classic/resources/modifiers.rb

@@ -0,0 +1,26 @@
+module Paddle
+  module Classic
+    class ModifiersResource < Resource
+
+      def list(**params)
+        response = post_request("2.0/subscription/modifiers", body: params)
+        Collection.from_response(response, type: Modifier)
+      end
+
+      def create(subscription_id:, modifier_amount:, **params)
+        attrs = {subscription_id: subscription_id, modifier_amount: modifier_amount}
+        create_response = post_request("2.0/subscription/modifiers/create", body: attrs.merge(params))
+
+        response = post_request("2.0/subscription/modifiers", body: {subscription_id: subscription_id} )
+        Collection.from_response(response, type: Modifier)
+      end
+
+      def delete(modifier_id:)
+        attrs = {modifier_id: modifier_id}
+        response = post_request("2.0/subscription/modifiers/delete", body: attrs)
+        return true if response.success?
+      end
+
+    end
+  end
+end

data/lib/paddle/classic/resources/pay_links.rb

@@ -0,0 +1,13 @@
+module Paddle
+  module Classic
+    class PayLinksResource < Resource
+
+      def generate(**params)
+        response = post_request("2.0/product/generate_pay_link", body: params)
+
+        PayLink.new(response.body["response"]) if response.success?
+      end
+
+    end
+  end
+end

data/lib/paddle/classic/resources/payments.rb

@@ -0,0 +1,24 @@
+module Paddle
+  module Classic
+    class PaymentsResource < Resource
+
+      def list(**params)
+        response = post_request("2.0/subscription/payments", body: params)
+        Collection.from_response(response, type: Payment)
+      end
+
+      def reschedule(payment_id:, date:)
+        attrs = {payment_id: payment_id, date: date}
+        response = post_request("2.0/subscription/payments_reschedule", body: attrs)
+        return true if response.success?
+      end
+
+      def refund(order_id:, **params)
+        attrs = {order_id: order_id}
+        response = post_request("2.0/payment/refund", body: attrs.merge(params))
+        PaymentRefund.new(response.body["response"])
+      end
+
+    end
+  end
+end

data/lib/paddle/classic/resources/plans.rb

@@ -0,0 +1,21 @@
+module Paddle
+  module Classic
+    class PlansResource < Resource
+
+      def list
+        response = post_request("2.0/subscription/plans")
+        Collection.from_response(response, type: Plan)
+      end
+
+      def create(name:, type:, **params)
+        attrs = {plan_name: name, plan_type: type}
+        create_response = post_request("2.0/subscription/plans_create", body: attrs.merge(params))
+
+        # After creating the Plan, because it doesn't return the whole record, grab it from the API and return that
+        response = post_request("2.0/subscription/plans", body: {plan: create_response.body["response"]["product_id"]} )
+        Plan.new(response.body.dig("response")[0]) if response.success?
+      end
+
+    end
+  end
+end

data/lib/paddle/classic/resources/products.rb

@@ -0,0 +1,12 @@
+module Paddle
+  module Classic
+    class ProductsResource < Resource
+
+      def list
+        response = post_request("2.0/product/get_products")
+        Collection.from_response(response, type: Product, key: "products")
+      end
+
+    end
+  end
+end

data/lib/paddle/classic/resources/transactions.rb

@@ -0,0 +1,12 @@
+module Paddle
+  module Classic
+    class TransactionsResource < Resource
+
+      def list(entity:, id:)
+        response = post_request("2.0/#{entity}/#{id}/transactions")
+        Collection.from_response(response, type: Transaction)
+      end
+
+    end
+  end
+end

data/lib/paddle/classic/resources/users.rb

@@ -0,0 +1,42 @@
+module Paddle
+  module Classic
+    class UsersResource < Resource
+
+      def list(**params)
+        response = post_request("2.0/subscription/users", body: params)
+        Collection.from_response(response, type: User)
+      end
+
+      def update(subscription_id:, **params)
+        attrs = {subscription_id: subscription_id}
+        response = post_request("2.0/subscription/users/update", body: attrs.merge(params))
+        User.new(response.body["response"]) if response.success?
+      end
+
+      def pause(subscription_id:, **params)
+        attrs = {subscription_id: subscription_id, pause: true}
+        response = post_request("2.0/subscription/users/update", body: attrs.merge(params))
+        User.new(response.body["response"]) if response.success?
+      end
+
+      def unpause(subscription_id:, **params)
+        attrs = {subscription_id: subscription_id, pause: false}
+        response = post_request("2.0/subscription/users/update", body: attrs.merge(params))
+        User.new(response.body["response"]) if response.success?
+      end
+
+      def update_postcode(subscription_id:, postcode:)
+        attrs = {subscription_id: subscription_id, postcode: postcode}
+        response = post_request("2.0/subscription/users/postcode", body: attrs)
+        return true if response.success?
+      end
+
+      def cancel(subscription_id:)
+        attrs = {subscription_id: subscription_id}
+        response = post_request("2.0/subscription/users_cancel", body: attrs)
+        return true if response.success?
+      end
+
+    end
+  end
+end

data/lib/paddle/classic/resources/webhooks.rb

@@ -0,0 +1,12 @@
+module Paddle
+  module Classic
+    class WebhooksResource < Resource
+
+      def list(**params)
+        response = post_request("2.0/alert/webhooks", body: params)
+        Collection.from_response(response, type: Webhook, key: "data")
+      end
+
+    end
+  end
+end

data/lib/paddle/client.rb

@@ -0,0 +1,71 @@
+module Paddle
+  class Client
+
+    class << self
+
+      def connection
+        @connection ||= Faraday.new(Paddle.config.url) do |conn|
+          conn.request :authorization, :Bearer, Paddle.config.api_key
+
+          conn.headers = {
+            "User-Agent" => "paddlerb/v#{VERSION} (github.com/deanpcmad/paddlerb)"
+          }
+
+          conn.request :json
+
+          conn.response :json, content_type: "application/json"
+        end
+      end
+
+
+      def get_request(url, params: {}, headers: {})
+        handle_response connection.get(url, params, headers)
+      end
+
+      def post_request(url, body: {}, headers: {})
+        handle_response connection.post(url, body, headers)
+      end
+
+      def patch_request(url, body:, headers: {})
+        handle_response connection.patch(url, body, headers)
+      end
+
+      def delete_request(url, headers: {})
+        handle_response connection.delete(url, headers)
+      end
+
+      def handle_response(response)
+        case response.status
+        when 400
+          raise Error, "Error 400: Your request was malformed. '#{response.body["error"]["code"]}'"
+        when 401
+          raise Error, "Error 401: You did not supply valid authentication credentials. '#{response.body["error"]}'"
+        when 403
+          raise Error, "Error 403: You are not allowed to perform that action. '#{response.body["error"]["code"]}'"
+        when 404
+          raise Error, "Error 404: No results were found for your request. '#{response.body["error"]["code"]}'"
+        when 409
+          raise Error, "Error 409: Your request was a conflict. '#{response.body["error"]["code"]}'"
+        when 429
+          raise Error, "Error 429: Your request exceeded the API rate limit. '#{response.body["error"]["code"]}'"
+        when 500
+          raise Error, "Error 500: We were unable to perform the request due to server-side problems. '#{response.body["error"]["code"]}'"
+        when 503
+          raise Error, "Error 503: You have been rate limited for sending more than 20 requests per second. '#{response.body["error"]["code"]}'"
+        when 501
+          raise Error, "Error 501: This resource has not been implemented. '#{response.body["error"]["code"]}'"
+        when 204
+          return true
+        end
+
+        if response.body && response.body["error"]
+          raise Error, "Error #{response.body["error"]["code"]} - #{response.body["errors"]["message"]}"
+        end
+
+        response
+      end
+
+    end
+
+  end
+end

data/lib/paddle/collection.rb

@@ -0,0 +1,27 @@
+module Paddle
+  class Collection
+    attr_reader :data, :total
+
+    def self.from_response(response, type:)
+      body = response.body
+
+      data  = body["data"].map { |attrs| type.new(attrs) }
+
+      if body["meta"]["pagination"]
+        total = body["meta"]["pagination"]["estimated_total"]
+      else
+        total = body["data"].count
+      end
+
+      new(
+        data: data,
+        total: total
+      )
+    end
+
+    def initialize(data:, total:)
+      @data = data
+      @total = total
+    end
+  end
+end

data/lib/paddle/configuration.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Paddle
+  class Configuration
+
+    attr_reader :environment
+
+    attr_accessor :api_key
+
+    def initialize
+      @environment ||= :production
+    end
+
+    def environment=(env)
+      env = env.to_sym
+      unless [:development, :sandbox, :production].include?(env)
+        raise ArgumentError, "#{env.inspect} is not a valid environment"
+      end
+      @environment = env
+    end
+
+    def url
+      case @environment
+      when :production
+        "https://api.paddle.com"
+      when :development, :sandbox
+        "https://sandbox-api.paddle.com"
+      end
+    end
+
+  end
+end

data/lib/paddle/error.rb

@@ -0,0 +1,4 @@
+module Paddle
+  class Error < StandardError
+  end
+end

data/lib/paddle/models/address.rb

@@ -0,0 +1,30 @@
+module Paddle
+  class Address < Object
+
+    class << self
+
+      def list(customer:, **params)
+        response = Client.get_request("customers/#{customer}/addresses", params: params)
+        Collection.from_response(response, type: Address)
+      end
+
+      def create(customer:, country_code:, postal_code:, **params)
+        attrs = {country_code: country_code, postal_code: postal_code}
+        response = Client.post_request("customers/#{customer}/addresses", body: attrs.merge(params))
+        Address.new(response.body["data"])
+      end
+
+      def retrieve(customer:, id:)
+        response = Client.get_request("customers/#{customer}/addresses/#{id}")
+        Address.new(response.body["data"])
+      end
+
+      def update(customer:, id:, **params)
+        response = Client.patch_request("customers/#{customer}/addresses/#{id}", body: params)
+        Address.new(response.body["data"])
+      end
+
+    end
+
+  end
+end

data/lib/paddle/models/adjustment.rb

@@ -0,0 +1,20 @@
+module Paddle
+  class Adjustment < Object
+
+    class << self
+
+      def list(**params)
+        response = Client.get_request("adjustments", params: params)
+        Collection.from_response(response, type: Adjustment)
+      end
+
+      def create(transaction_id:, action:, reason:, items:, **params)
+        attrs = {transaction_id: transaction_id, action: action, reason: reason, items: items}
+        response = Client.post_request("adjustments", body: attrs.merge(params))
+        Adjustment.new(response.body["data"])
+      end
+
+    end
+
+  end
+end

data/lib/paddle/models/business.rb

@@ -0,0 +1,30 @@
+module Paddle
+  class Business < Object
+
+    class << self
+
+      def list(customer:, **params)
+        response = Client.get_request("customers/#{customer}/businesses", params: params)
+        Collection.from_response(response, type: Business)
+      end
+
+      def create(customer:, name:, **params)
+        attrs = {name: name}
+        response = Client.post_request("customers/#{customer}/businesses", body: attrs.merge(params))
+        Business.new(response.body["data"])
+      end
+
+      def retrieve(customer:, id:)
+        response = Client.get_request("customers/#{customer}/businesses/#{id}")
+        Business.new(response.body["data"])
+      end
+
+      def update(customer:, id:, **params)
+        response = Client.patch_request("customers/#{customer}/businesses/#{id}", body: params)
+        Business.new(response.body["data"])
+      end
+
+    end
+
+  end
+end

data/lib/paddle/models/customer.rb

@@ -0,0 +1,30 @@
+module Paddle
+  class Customer < Object
+
+    class << self
+
+      def list(**params)
+        response = Client.get_request("customers", params: params)
+        Collection.from_response(response, type: Customer)
+      end
+
+      def create(email:, **params)
+        attrs = {email: email}
+        response = Client.post_request("customers", body: attrs.merge(params))
+        Customer.new(response.body["data"])
+      end
+
+      def retrieve(id:)
+        response = Client.get_request("customers/#{id}")
+        Customer.new(response.body["data"])
+      end
+
+      def update(id:, **params)
+        response = Client.patch_request("customers/#{id}", body: params)
+        Customer.new(response.body["data"])
+      end
+
+    end
+
+  end
+end

data/lib/paddle/models/discount.rb

@@ -0,0 +1,30 @@
+module Paddle
+  class Discount < Object
+
+    class << self
+
+      def list(**params)
+        response = Client.get_request("discounts", params: params)
+        Collection.from_response(response, type: Discount)
+      end
+
+      def create(amount:, description:, type:, **params)
+        attrs = {amount: amount, description: description, type: type}
+        response = Client.post_request("discounts", body: attrs.merge(params))
+        Discount.new(response.body["data"])
+      end
+
+      def retrieve(id:)
+        response = Client.get_request("discounts/#{id}")
+        Discount.new(response.body["data"])
+      end
+
+      def update(id:, **params)
+        response = Client.patch_request("discounts/#{id}", body: params)
+        Discount.new(response.body["data"])
+      end
+
+    end
+
+  end
+end

data/lib/paddle/models/event.rb

@@ -0,0 +1,14 @@
+module Paddle
+  class Event < Object
+
+    class << self
+
+      def list(**params)
+        response = Client.get_request("events", params: params)
+        Collection.from_response(response, type: Event)
+      end
+
+    end
+
+  end
+end

data/lib/paddle/models/event_type.rb

@@ -0,0 +1,14 @@
+module Paddle
+  class EventType < Object
+
+    class << self
+
+      def list
+        response = Client.get_request("event-types")
+        Collection.from_response(response, type: EventType)
+      end
+
+    end
+
+  end
+end