parallel588-klaviyo 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ca42f71d0ad66aa987267caa2a80c6211277bd24
-  data.tar.gz: 3d3334697ff2b0130f90252f7996506cfc601037
+  metadata.gz: f20c322826f6e2c97eeb107ed11482d783c30555
+  data.tar.gz: ed8f644a6be432c04c74d9c5b7eac502ad2b13b5
 SHA512:
-  metadata.gz: e8a4f80d8ad00dc698732e2eae1558cbcb017c93cd43f2eeae88798d4a61090a8ecbdbd34232683f4de73ec1681bce4722ee3e22ff8ea05b42ee06d7a4df7c59
-  data.tar.gz: 2db5c4d013e7d6b183820ac04bcca622d282d70ff1118113346456646177329d8675e215c0c1bdd45c56c1ed0a91939a6f7aae697ac7a11ce72b594da61c52db
+  metadata.gz: a26848c0c3885b018fdd7f9a5455bc6d3ddeae71d43a3d526285e9c18800d44e1107ca34afd88a09683a1e5d686f42e39ad6accc649db2f10e898bb454db1a83
+  data.tar.gz: 41a2cc7c7b3ae68dcd40a3f93c6aa60243f179bea8c64d8fc11b2a9e7b097072c75e811ff6a251938998ea2682b92a35bc58a8bc5a131cd8b1764e30771b3bed

data/lib/klaviyo/client.rb

@@ -1,7 +1,11 @@
+require_relative 'client_dsl'
+require_relative 'errors'
 module Klaviyo
   API_ENDPOINT = 'https://a.klaviyo.com'
 
   class Client
+    extend ClientDSL
+
     attr_reader :api_key, :conn, :token
     def initialize(api_key, token)
       @api_key = api_key
@@ -9,12 +13,13 @@ module Klaviyo
       @conn = Faraday.new(
         url: API_ENDPOINT,
         ssl: { ca_path: Klaviyo::DEFAULT_CA_BUNDLE_PATH }
-      ) do |b|
-        b.headers['Accept'] = 'application/json'
-        b.request  :url_encoded
-        b.response :logger
-        b.response :json, content_type: 'application/json'
-        b.adapter  Faraday.default_adapter
+      ) do |f|
+        f.headers['Accept'] = 'application/json'
+        f.request  :url_encoded
+        f.response :logger
+        f.response :json, content_type: 'application/json'
+        f.adapter Faraday.default_adapter
+        f.use Errors::RequestError
       end
     end
 
@@ -36,10 +41,42 @@ module Klaviyo
       )
     end
 
+    define_api_method resource: :people, action: :identify
+    define_api_method resource: :people, action: :find
+    define_api_method resource: :people, action: :exclusions
+    define_api_method resource: :people, action: :exclude
+    define_api_method resource: :people, action: :update
+    define_api_method resource: :people, action: :events
+    define_api_method resource: :people, action: :metric_events
+
+    define_api_method resource: :lists, action: :all
+    define_api_method resource: :lists, action: :find
+    define_api_method resource: :lists, action: :create
+    define_api_method resource: :lists, action: :update
+    define_api_method resource: :lists, action: :delete
+    define_api_method resource: :lists, action: :include_member_in_list?
+    define_api_method resource: :lists, action: :include_member_in_segment?
+    define_api_method resource: :lists, action: :subscribe
+    define_api_method resource: :lists, action: :unsubscribe
+    define_api_method resource: :lists, action: :batch_subscribe
+    define_api_method resource: :lists, action: :unsubscribes
+
+    define_api_method resource: :templates, action: :all
+    define_api_method resource: :templates, action: :create
+    define_api_method resource: :templates, action: :update
+    define_api_method resource: :templates, action: :delete
+    define_api_method resource: :templates, action: :clone
+    define_api_method resource: :templates, action: :render
+    define_api_method resource: :templates, action: :render_and_send
+
     private
 
     def constantize(class_name)
-      Object.module_eval(class_name.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase })
+      Object.module_eval(
+        class_name.to_s.gsub(/\/(.?)/) {
+          "::#{$1.upcase}"
+        }.gsub(/(?:^|_)(.)/) { $1.upcase }
+      )
     end
   end
 end

data/lib/klaviyo/client_dsl.rb

@@ -0,0 +1,29 @@
+module Klaviyo
+  module ClientDSL
+    def define_api_method(resource:, action:)
+      @@resources ||= {}
+
+      @@resources[resource] ||
+        begin
+          @@resources[resource] = Class.new do
+            class << self
+              attr_accessor :client
+
+              def define_action(resource, action)
+                define_singleton_method action do |*args|
+                  client.invoke(resource, action, *args)
+                end
+              end
+            end
+          end
+
+          define_method resource do
+            @@resources[resource].client = self
+            @@resources[resource]
+          end
+        end
+
+      @@resources[resource].define_action(resource, action)
+    end
+  end
+end

data/lib/klaviyo/errors.rb

@@ -0,0 +1,38 @@
+module Klaviyo
+  module Errors
+    class KlaviyoError < ::StandardError; end
+    class NotFound < KlaviyoError; end
+    class UnprocessableEntity < KlaviyoError; end
+    class InternalServerError < KlaviyoError; end
+    class NotAuthorized < KlaviyoError; end
+
+    class RequestError < Faraday::Response::Middleware
+
+      def on_complete(env)
+
+        # Ignore any non-error response codes
+        return if (status = env[:status]) < 400
+        case status
+        when 404
+          raise Errors::NotFound, env[:body]
+        when 422
+          raise Errors::UnprocessableEntity, env[:body]
+        when 401
+          raise Errors::NotAuthorized, env[:body]
+        when 407
+          # mimic the behavior that we get with proxy requests with HTTPS
+          raise Faraday::Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
+        else
+          raise Errors::InternalServerError, env[:body] # Treat any other errors as 500
+        end
+      end
+
+    end
+
+  end
+end
+
+#400 Bad request - Request is missing or has a bad parameter.
+#401 Not Authorized - Request is missing or has an invalid API key.
+#404 Not Found - The requested resource doesn't exist.
+#500 Server errors - Something is wrong on Klaviyo's end.

data/lib/klaviyo/lists/api_operations.rb

@@ -1,5 +1,3 @@
-require_relative 'collection'
-require_relative 'entry'
 module Klaviyo
   module Lists
     # https://www.klaviyo.com/docs/api/lists
@@ -7,61 +5,64 @@ module Klaviyo
     module ApiOperations
 
       def all(client:, page: 0, per: 50)
-        Collection.new(
-          client.conn.get(
-          '/api/v1/lists',
-          api_key: client.api_key,
-          page: page, count: per
-        ).body)
+        Klaviyo::Resource.build_collection(
+          client.conn.get('/api/v1/lists',
+                          api_key: client.api_key,
+                          page: page, count: per
+                         ).body
+        )
       end
 
       def find(client:, id:)
-        Entry.new(
-          client.conn.get(
-          "/api/v1/list/#{id}", api_key: client.api_key
-        ).body)
+        Klaviyo::Resource.build(
+          client.conn.get("/api/v1/list/#{id}",
+                          api_key: client.api_key
+                         ).body
+        )
       end
 
       def create(client:, name:, list_type: 'standart')
-        res = client.conn.post(
-          '/api/v1/lists',
-          api_key: client.api_key,
-          name: name,
-          list_type: list_type
+        Klaviyo::Resource.build(
+          client.conn.post('/api/v1/lists',
+                           api_key: client.api_key,
+                           name: name,
+                           list_type: list_type
+                          ).body
         )
-        Entry(res.body)
       end
 
       def update(client:, id:, name:)
-        res = client.conn.put(
-          "/api/v1/list/#{id}",
-          api_key: client.api_key,
-          name: name
+        Klaviyo::Resource.build(
+          client.conn.put("/api/v1/list/#{id}",
+                          api_key: client.api_key,
+                          name: name
+                         ).body
         )
-        Entry.new(res.body)
       end
 
       def delete(client:, id:)
-        res = client.conn.delete(
-          "/api/v1/list/#{id}",
-          api_key: client.api_key
+        Klaviyo::Resource.build(
+          client.conn.delete("/api/v1/list/#{id}",
+                             api_key: client.api_key
+                            ).body
         )
-        Entry.new(res.body)
       end
 
       def include_member_in_list?(client:, id:, email:)
-        client.conn.get(
-          "/api/v1/list/#{id}/members",
-          api_key: client.api_key,
-          email: email
+        Klaviyo::Resource.build_collection(
+          client.conn.get("/api/v1/list/#{id}/members",
+                          api_key: client.api_key,
+                          email: email
+                         ).body
         )
       end
 
       def include_member_in_segment?(client:, segment_id:, email:)
-        client.conn.get(
-          "/api/v1/segment/#{segment_id}/members",
-          api_key: client.api_key,
-          email: email
+        Klaviyo::Resource.build_collection(
+          client.conn.get("/api/v1/segment/#{segment_id}/members",
+                          api_key: client.api_key,
+                          email: email
+                         ).body
         )
       end
 
@@ -69,21 +70,23 @@ module Klaviyo
       # @id - list id
       #
       def subscribe(client:, id:, email:, properties: {}, confirm_optin: true)
-        client.conn.post(
-          "/api/v1/list/#{id}/members",
-          api_key: client.api_key,
-          email: email,
-          properties: properties,
-          confirm_optin: confirm_optin
+        Klaviyo::Resource.build(
+          client.conn.post("/api/v1/list/#{id}/members",
+                           api_key: client.api_key,
+                           email: email,
+                           properties: properties,
+                           confirm_optin: confirm_optin
+                          ).body
         )
       end
 
       def unsubscribe(client:, id:, email:, ts: Time.now.to_i)
-        client.conn.post(
-          "/api/v1/list/#{id}/members/exclude",
-          api_key: client.api_key,
-          email: email,
-          timestamp: ts
+        Klaviyo::Resource.build(
+          client.conn.post("/api/v1/list/#{id}/members/exclude",
+                           api_key: client.api_key,
+                           email: email,
+                           timestamp: ts
+                          ).body
         )
       end
 

data/lib/klaviyo/lists.rb

@@ -1,5 +1,4 @@
 require_relative 'lists/api_operations'
-require_relative 'lists/collection'
 
 module Klaviyo
   module Lists

data/lib/klaviyo/people/api_operations.rb

@@ -3,38 +3,15 @@ module Klaviyo
     # https://www.klaviyo.com/docs/api/people
     #
     module ApiOperations
-      Result = Struct.new(:response) do
-        def success?
-          response.to_s == '1'
-        end
-      end
-      ErrorResult = Struct.new(:response) do
-        def success?; false; end
-        def status; response['status']; end
-        def message; response['message']; end
-      end
-
-      Person = Struct.new(:attrs) do
-        def method_missing(method_name, *arguments, &block)
-          if attrs.key?(method_name.to_s)
-            attrs[method_name.to_s]
-          elsif attrs.key?("$#{method_name}")
-            attrs["$#{method_name}"]
-          else
-            super
-          end
-        end
-      end
 
       # https://www.klaviyo.com/docs/http-api#people
       # invoke(:people, :identify, properties: { '$email': 'useremail@ua.com' })
       #
       def identify(client:, properties: {})
-        res = client.conn.get(
+        client.conn.get(
           '/api/identify',
           client.build_params(properties: properties)
-        )
-        Result.new(res.body)
+        ).body.to_s == '1'
       end
 
       #
@@ -60,19 +37,17 @@ module Klaviyo
       end
 
       def find(client:, id:)
-        res = client.conn.get("/api/v1/person/#{id}", api_key: client.api_key)
-        if res.success?
-          Person.new(res.body)
-        else
-          ErrorResult.new(res.body)
-        end
+        Klaviyo::Resource.build(
+          client.conn.get("/api/v1/person/#{id}", api_key: client.api_key).body
+        )
       end
 
       def update(client:, id:, attrs: {})
-        client.conn.put(
+        Klaviyo::Resource.build(
+          client.conn.put(
           "/api/v1/person/#{id}",
           { api_key: client.api_key }.merge(attrs)
-        )
+        ).body)
       end
 
       def events(client:, id:, sort: 'desc', per: 100, since: Time.now.to_i)

data/lib/klaviyo/resource.rb

@@ -0,0 +1,62 @@
+module Klaviyo
+  module Resource
+    KlaviyoObject = Struct.new(:attrs) do
+      def method_missing(method_name, *arguments, &block)
+        if attrs.key?(method_name.to_s) || attrs.key?("$#{method_name}")
+          attr_value = attrs[method_name.to_s] || attrs["$#{method_name}"]
+          if attr_value.is_a?(Hash) &&
+             attr_value.key?('object') && attr_value.key?('id')
+            attrs[method_name.to_s] = Klaviyo::Resource.build(attr_value)
+          else
+            attr_value
+          end
+        else
+          super
+        end
+      end
+    end
+
+    class KlaviyoCollection
+      include Enumerable
+
+      attr_reader :meta, :items
+
+      def initialize(data)
+        @items = data.delete('data').map { |attrs| Klaviyo::Resource.build(attrs) }
+        @meta = data
+      end
+
+      def each(&blk)
+        item.each(&blk)
+      end
+    end
+
+    class Person < KlaviyoObject; end
+    class List < KlaviyoObject; end
+    class Folder < KlaviyoObject; end
+    class Membership < KlaviyoObject; end
+
+    def self.build(attrs)
+
+      object = attrs.delete('object')
+      case object.to_s
+      when 'person'
+        Person.new(attrs)
+      when 'list'
+        List.new(attrs)
+      when 'folder'
+        Folder.new(attrs)
+      when 'membership'
+        Membership.new(attrs)
+      else
+        KlaviyoObject.new(attrs)
+      end
+
+    end
+
+    def self.build_collection(data)
+      KlaviyoCollection.new(data)
+    end
+
+  end
+end

data/lib/klaviyo/templates/api_operations.rb

@@ -5,7 +5,11 @@ module Klaviyo
     module ApiOperations
 
       def all(client:)
-        client.conn.get('/api/v1/email-templates', api_key: client.api_key)
+        Klaviyo::Resource.build_collection(
+          client.conn.get('/api/v1/email-templates',
+                          api_key: client.api_key
+                         ).body
+        )
       end
 
       def create(client:, name:, html:)

data/lib/klaviyo/version.rb

@@ -1,3 +1,3 @@
 module Klaviyo
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 end

data/lib/klaviyo.rb

@@ -1,9 +1,4 @@
 require 'klaviyo/version'
-require 'klaviyo/client'
-require 'klaviyo/templates'
-require 'klaviyo/lists'
-require 'klaviyo/event'
-require 'klaviyo/people'
 
 require 'active_support'
 require 'active_support/core_ext'
@@ -12,6 +7,15 @@ require 'faraday_middleware'
 require 'json'
 require 'virtus'
 
+require 'klaviyo/client'
+require 'klaviyo/errors'
+require 'klaviyo/resource'
+require 'klaviyo/templates'
+require 'klaviyo/lists'
+require 'klaviyo/event'
+require 'klaviyo/people'
+
+
 
 module Klaviyo
   DEFAULT_CA_BUNDLE_PATH = File.dirname(__FILE__) + '/data'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parallel588-klaviyo
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Maxim Pechnikov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-04-08 00:00:00.000000000 Z
+date: 2016-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: virtus
@@ -168,13 +168,14 @@ files:
 - lib/data/ca-certificates.crt
 - lib/klaviyo.rb
 - lib/klaviyo/client.rb
+- lib/klaviyo/client_dsl.rb
+- lib/klaviyo/errors.rb
 - lib/klaviyo/event.rb
 - lib/klaviyo/lists.rb
 - lib/klaviyo/lists/api_operations.rb
-- lib/klaviyo/lists/collection.rb
-- lib/klaviyo/lists/entry.rb
 - lib/klaviyo/people.rb
 - lib/klaviyo/people/api_operations.rb
+- lib/klaviyo/resource.rb
 - lib/klaviyo/templates.rb
 - lib/klaviyo/templates/api_operations.rb
 - lib/klaviyo/version.rb

data/lib/klaviyo/lists/collection.rb

@@ -1,21 +0,0 @@
-require_relative 'entry'
-module Klaviyo
-  module Lists
-
-    class Collection
-      attr_reader :data
-
-      def initialize(data)
-        @data = data
-      end
-
-      def items
-        @items ||= data.fetch('data') { [] }.map { |j| Entry.new(j) }
-      end
-
-      def meta
-        @meta ||= data.except('data')
-      end
-    end
-  end
-end

data/lib/klaviyo/lists/entry.rb

@@ -1,12 +0,0 @@
-module Klaviyo
-  module Lists
-
-    class Entry
-      attr_reader :data
-
-      def initialize(data)
-        @data = data
-      end
-    end
-  end
-end