workarea-listrak 5.0.1

data/app/assets/javascripts/workarea/storefront/listrak/adapters/listrak_adapter.js

@@ -0,0 +1,110 @@
+/**
+ * @namespace WORKAREA.listrakAdapter
+ */
+WORKAREA.analytics.registerAdapter('listrakAdapter', function () {
+    'use strict';
+
+    if (!WORKAREA.config.listrak.merchantId) {
+        return;
+    }
+
+    var productView = function(payload) {
+            if (_.isUndefined(window._ltk)) { return; }
+
+            /**
+             * browsing activity
+             */
+            _ltk.Activity.AddProductBrowse(payload.sku);
+            _ltk.Activity.Submit();
+        },
+
+        productQuickView = function(payload) {
+            if (_.isUndefined(window._ltk)) { return; }
+
+            /**
+             * browsing activity
+             */
+            _ltk.Activity.AddProductBrowse(payload.sku);
+            _ltk.Activity.Submit();
+        },
+
+        pageView = function() {
+            if (_.isUndefined(window._ltk)) { return; }
+
+            /**
+             * conversion tracking
+             */
+            _ltk.Click.Submit();
+
+            /**
+             * browsing activity
+             */
+            _ltk.Activity.AddPageBrowse();
+            _ltk.Activity.Submit();
+        },
+
+        cartView = function(payload) {
+            if (_.isUndefined(window._ltk)) { return; }
+
+            if (payload.items.length > 0) {
+                if (!_.isEmpty(payload.token)) {
+                    _ltk.SCA.CartLink = WORKAREA.routes.storefront.resumeCartPath(payload.token);
+                }
+                _.each(payload.items, function (item) {
+                    _ltk.SCA.AddItemWithLinks(
+                        item.sku,
+                        item.quantity,
+                        item.price,
+                        item.product_name,
+                        item.image_url,
+                        WORKAREA.routes.storefront.productPath(item.slug)
+                    );
+                });
+                _ltk.SCA.Submit();
+            }
+            else {
+                _ltk.SCA.ClearCart();
+            }
+        },
+
+        orderConfirmation = function(payload) {
+            if (_.isUndefined(window._ltk)) { return; }
+            
+            _ltk.Order.SetCustomer(payload.email, payload.first_name, payload.last_name);
+            _ltk.Order.OrderNumber = payload.number;
+            _ltk.Order.ItemTotal = payload.subtotal_price;
+            _ltk.Order.ShippingTotal = payload.shipping_total;
+            _ltk.Order.TaxTotal = payload.tax_total;
+            _ltk.Order.HandlingTotal = '0.00';
+            _ltk.Order.OrderTotal = payload.total_price;
+            _.each(payload.items, function (item) {
+                _ltk.Order.AddItem(item.sku, item.quantity, item.price.toFixed(2));
+            });
+            _ltk.Order.Submit();
+
+            /**
+             * sca removal
+             */
+            _ltk.SCA.SetCustomer(payload.email, payload.first_name, payload.last_name);
+            _ltk.SCA.OrderNumber = payload.number;
+            _ltk.SCA.Submit();
+        };
+
+    return {
+        'pageView': function() {
+            WORKAREA.listrak.addListrakListener(pageView);
+        },
+        'productView': function(payload) {
+            WORKAREA.listrak.addListrakListener(_.partial(productView, payload));
+        },
+        'productQuickView': function(payload) {
+            WORKAREA.listrak.addListrakListener(_.partial(productQuickView, payload));
+        },
+        'cartView': function(payload) {
+            WORKAREA.listrak.addListrakListener(_.partial(cartView, payload));
+        },
+        'checkoutOrderPlaced': function(payload) {
+            WORKAREA.listrak.addListrakListener(_.partial(orderConfirmation, payload));
+        }
+    };
+});

data/app/assets/javascripts/workarea/storefront/listrak/listrak_config.js.erb

@@ -0,0 +1,13 @@
+/**
+ * @namespace WORKAREA
+ */
+
+(function () {
+    'use strict';
+
+    /**
+     * @namespace WORKAREA.config
+     * @property {object} listrak
+     */
+    WORKAREA.config.listrak = <%= Workarea::Listrak::Analytics.javascript_config %>;
+})();

data/app/assets/javascripts/workarea/storefront/listrak/modules/listrak.js

@@ -0,0 +1,64 @@
+/**
+ * @namespace WORKAREA.listrak
+ */
+
+WORKAREA.registerModule('listrak', (function () {
+    'use strict';
+
+    var getSdk = _.once(function() {
+            var biJsHost = (("https:" === document.location.protocol) ? "https://" : "http://");
+            (function (d, s, id, tid, vid) {
+            var js, ljs = d.getElementsByTagName(s)[0];
+            if (d.getElementById(id)) return; js = d.createElement(s); js.id = id;
+            js.src = biJsHost + "cdn.listrakbi.com/scripts/script.js?m=" + tid + "&v=" + vid;
+            ljs.parentNode.insertBefore(js, ljs);
+            })(document, 'script', 'ltkSDK', WORKAREA.config.listrak.merchantId, '1');
+        }),
+
+        addListrakListener = function(listener) {
+            if (!WORKAREA.config.listrak.merchantId) { return; }
+
+            if (typeof _ltk === "undefined") {
+                (function(d) { if (document.addEventListener) document.addEventListener('ltkAsyncListener', d);
+                else { var e = document.documentElement; e.ltkAsyncProperty = 0; e.attachEvent('onpropertychange', function (e) {
+                if (e.propertyName === 'ltkAsyncProperty'){d();}});}})( listener );
+            }
+            else {
+                listener();
+            }
+        },
+
+        getEmailSelectors = function () {
+          var emailIds = WORKAREA.config.listrak.emailIds,
+              selectors = _.map(emailIds, function (id) { return '#' + id; });
+
+          selectors.push('input[type="email"]');
+
+          return selectors.join(', ');
+        },
+
+        addEmailCaptures = function($scope) {
+            addListrakListener(function () {
+                var emailSelectors = getEmailSelectors();
+
+                _.each($(emailSelectors, $scope), function(input) {
+                    if (_.isUndefined($(input).attr('id'))) { return; }
+
+                    _ltk.SCA.CaptureEmail($(input).attr('id'));
+                });
+            });
+        },
+
+        init = function ($scope) {
+            addEmailCaptures($scope);
+
+            if (_.isEmpty($('#ltkSDK')) && WORKAREA.config.listrak.merchantId) {
+                getSdk();
+            }
+        };
+
+    return {
+        init: init,
+        addListrakListener: addListrakListener
+    };
+}()));

data/app/controllers/workarea/admin/listrak/configurations_controller.rb

@@ -0,0 +1,30 @@
+module Workarea
+  module Admin
+    module Listrak
+      class ConfigurationsController < Admin::ApplicationController
+        def edit
+          @configuration = ListrakConfigurationViewModel.new(
+            Workarea::Listrak.configuration
+          )
+        end
+
+        def update
+          configuration = Workarea::Listrak.configuration
+          if configuration.update_attributes(configuration_params)
+            redirect_to admin.edit_listrak_configuration_path, flash: { success: t('workarea.admin.listrak_configuration.edit.flash_messages.updated') }
+          else
+            flash[:error] = t('workarea.admin.listrak_configuration.edit.flash_messages.save_error')
+            @configuration = ListrakConfigurationViewModel.new(configuration)
+            render :edit, status: :unprocessable_entity
+          end
+        end
+
+        private
+
+          def configuration_params
+            params.permit(:default_list_id, external_event_ids: [])
+          end
+      end
+    end
+  end
+end

data/app/controllers/workarea/admin/listrak/events_controller.rb

@@ -0,0 +1,17 @@
+module Workarea
+  module Admin
+    module Listrak
+      class EventsController < Admin::ApplicationController
+        def index
+          @events = Workarea::Listrak.email.events.all list_id
+        end
+
+        private
+
+          def list_id
+            params[:list_id]
+          end
+      end
+    end
+  end
+end

data/app/helpers/workarea/listrak/analytics/helper.rb

@@ -0,0 +1,44 @@
+module Workarea
+  module Listrak
+    module Analytics
+      module Helper
+        def order_analytics_data(order)
+          super.merge(
+            user_id: order.user_id,
+            email: order.email,
+            subtotal_price: order.subtotal_price.to_f,
+            first_name: order_first_name(order),
+            last_name: order_last_name(order)
+          )
+        end
+
+        def cart_view_analytics_data(order)
+          event = super
+          payload = event[:payload].merge(
+            token: order.token
+          )
+          event.merge(payload: payload)
+        end
+
+        def order_item_analytics_data(item)
+          super.merge(
+            image_url: product_image_url(item.image, :large_thumb),
+            slug: item.product.to_param
+          )
+        end
+
+        private
+
+          def order_first_name(order)
+            order.shipping_address.try(:first_name) ||
+              order.try(:user).try(:first_name)
+          end
+
+          def order_last_name(order)
+            order.shipping_address.try(:last_name) ||
+              order.try(:user).try(:last_name)
+          end
+      end
+    end
+  end
+end

data/app/models/workarea/listrak/configuration.rb

@@ -0,0 +1,19 @@
+module Workarea
+  module Listrak
+    class Configuration
+      include ApplicationDocument
+
+      # @!attribute default_list_id
+      #   @return [Integer] list id customers are subscribed to
+      #
+      field :default_list_id, type: String
+
+      # @!attribute external_event_ids
+      #   @return [Array<Integer>] event ids to trigger when subscribing a customer
+      #
+      field :external_event_ids, type: Array
+
+      validates_presence_of :default_list_id
+    end
+  end
+end

data/app/queries/workarea/categorization.decorator

@@ -0,0 +1,7 @@
+module Workarea
+  decorate Categorization, with: :listrak do
+    def secondary_model
+      to_models.sort_by(&:created_at).second
+    end
+  end
+end

data/app/services/workarea/listrak/data_api/customers.rb

@@ -0,0 +1,26 @@
+module Workarea
+  module Listrak
+    class DataApi::Customers
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+      end
+
+      # Starts a new import using the supplied customer collection.
+      #
+      # @param [Array<Workarea::Listrak::Models::CustomerForm>] customers array of customers to import
+      #
+      # @return [String] resource_id
+      #
+      def import(customers)
+        request = Net::HTTP::Post.new("/data/v1/Customer").tap do |post|
+          post.body = customers.to_json
+        end
+        response = client.request request
+        body = JSON.parse(response.body)
+        body["resourceId"]
+      end
+    end
+  end
+end

data/app/services/workarea/listrak/data_api/orders.rb

@@ -0,0 +1,26 @@
+module Workarea
+  module Listrak
+    class DataApi::Orders
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+      end
+
+      # Starts a new import using the supplied order collection.
+      #
+      # @param [Array<Workarea::Listrak::Models::OrderForm>] orders array of orders to import
+      #
+      # @return [String] resource id
+      #
+      def import(orders)
+        request = Net::HTTP::Post.new("/data/v1/Order").tap do |post|
+          post.body = orders.to_json
+        end
+        response = client.request request
+        body = JSON.parse(response.body)
+        body["resourceId"]
+      end
+    end
+  end
+end

data/app/services/workarea/listrak/data_api/products.rb

@@ -0,0 +1,26 @@
+module Workarea
+  module Listrak
+    class DataApi::Products
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+      end
+
+      # Starts a new import using the supplied product collection.
+      #
+      # @param [Array<Workarea::Listrak::Models::ProductForm>] products array of products to import
+      #
+      # @return [String] resource id
+      #
+      def import(products)
+        request = Net::HTTP::Post.new("/data/v1/Product").tap do |post|
+          post.body = products.to_json
+        end
+        response = client.request request
+        body = JSON.parse(response.body)
+        body["resourceId"]
+      end
+    end
+  end
+end

data/app/services/workarea/listrak/data_api.rb

@@ -0,0 +1,63 @@
+module Workarea
+  module Listrak
+    class DataApi
+      def initialize(client_id:, client_secret:, open_timeout: nil, read_timeout: nil)
+        @client_id = client_id
+        @client_secret = client_secret
+        @open_timeout = open_timeout
+        @read_timeout = read_timeout
+      end
+
+      def request(http_request)
+        token = Listrak::Oauth.token(client_id: client_id, client_secret: client_secret)
+
+        http_request.add_field 'Authorization', "Bearer #{token}"
+        http_request.add_field 'Content-Type', 'application/json'
+        http_request['Accept'] = 'application/json'
+
+        response = http.start do |conn|
+          conn.request http_request
+        end
+
+        case response
+        when ::Net::HTTPSuccess
+          response
+        else
+          raise Listrak::HttpError, response
+        end
+      end
+
+      def customers
+        Customers.new self
+      end
+
+      def orders
+        Orders.new self
+      end
+
+      def products
+        Products.new self
+      end
+
+      private
+
+        attr_reader :client_id, :client_secret, :open_timeout, :read_timeout
+
+        def http
+          Net::HTTP.new(uri.host, uri.port).tap do |conn|
+            conn.use_ssl = true
+            conn.read_timeout = read_timeout if read_timeout
+            conn.open_timeout = open_timeout if open_timeout
+          end
+        end
+
+        def base_url
+          "https://api.listrak.com/email/"
+        end
+
+        def uri
+          URI base_url
+        end
+    end
+  end
+end

data/app/services/workarea/listrak/email_api/contacts.rb

@@ -0,0 +1,73 @@
+module Workarea
+  module Listrak
+    class EmailApi::Contacts
+
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+      end
+
+      # @param [String] list_id the list to add this contact to
+      # @param [Workarea::Listrak::Models::ContactForm] contact to create or update
+      # @param [Hash] options extra options when upserting the contact
+      # @option options [String] eventIds Comma-separated list of event identifiers that should be raised after the contact is created or updated.
+      # @option options [Boolean] overrideUnsubscribe Whether a contact in an unsubscribed state should be forced to a subscribed state. The default value is false
+      # @option options [Boolean] subscribedByContact Whether the subscribe was initiated by the contact. The default value is false.
+      # @option options [Boolean] sendDoubleOptIn Whether a double opt-in email should be sent if a new contact is being created. The default value is false.
+      # @option options [String] updateType If updating an existing contact, the type of update that will be performed on any submitted segmentation fields. Allowed values are Update, Append, and Overwrite. The default value is Update.
+      # @option options [String] newEmailAddress If updating an existing contact, the contact's email address will be changed to this value. Provide the original email address in the emailAddress body field to select the existing contact.
+      def upsert(list_id, contact, options = {})
+        params = validate_query_params(options, upsert_params)
+        path = ["/email/v1/List/#{list_id}/Contact", params].compact.join '?'
+        request = Net::HTTP::Post.new(path).tap do |post|
+          post.body = contact.to_json
+        end
+        response = client.request request
+        body = JSON.parse(response.body)
+        body["data"]
+      end
+
+      # @param [String] list_id Identifier used to locate the list.
+      # @param [String] contactIdentifier dentifier used to locate the contact. You may specify either an email address or a Listrak email key.
+      # @param [Hash] options extra options when getting the contact
+      # @option options [String] segmentationFieldIds Comma-separated list of segmentation field IDs to retrieve. Up to 30 fields may be included.
+      #
+      # @return [Workarea::Listrak::Models::Contact]
+      def get(list_id, contactIdentifier, options = {})
+        params = validate_query_params(options, get_params)
+        path = [
+          "/email/v1/List/#{list_id}/Contact/#{contactIdentifier}",
+          params
+        ].compact.join '?'
+        request = Net::HTTP::Get.new(path)
+        response = client.request request
+        body = JSON.parse response.body
+        Listrak::Models::Contact.new(body["data"])
+      end
+
+      private
+
+        def validate_query_params(hash, valid_params)
+          hash.select do |key, value|
+            valid_params[key] && value.is_a?(valid_params[key])
+          end.to_param.presence
+        end
+
+        def upsert_params
+          {
+            eventIds:            String,
+            overrideUnsubscribe: Boolean,
+            subscribedByContact: Boolean,
+            sendDoubleOptIn:     Boolean,
+            updateType:          String,
+            newEmailAddress:     String
+          }
+        end
+
+        def get_params
+          { 'segmentationFieldIds' => String }
+        end
+    end
+  end
+end

data/app/services/workarea/listrak/email_api/events.rb

@@ -0,0 +1,44 @@
+module Workarea
+  module Listrak
+    class EmailApi::Events
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+      end
+
+      # Returns the collection of events associated with the specified list.
+      #
+      # @param [Integer] list_id the list id to get the events from
+      #
+      # @raise [OauthError] raised if generating an Oauth token is unsucessful
+      #
+      # @return [Array<Workarea::Listrak::Models::Event>] Litrak events for the list
+      #
+      def all(list_id)
+        request = Net::HTTP::Get.new("/email/v1/List/#{list_id}/Event")
+        response = client.request request
+        body = JSON.parse(response.body)
+        body["data"].map { |event| Listrak::Models::Event.new event }
+      end
+
+      # Creates a new event on the specified list.
+      #
+      # @param [Integer] list_id the list id to create the event under
+      # @param [Workarea::Listrak::Models::EventForm] event to create
+      #
+      # @raise [OauthError] raised if generating an Oauth token is unsucessful
+      #
+      # @return [String] resource id
+      #
+      def create(list_id, event)
+        request = Net::HTTP::Post.new("/email/v1/List/#{list_id}/Event").tap do |post|
+          post.body = event.to_json
+        end
+        response = client.request request
+        body = JSON.parse(response.body)
+        body["resourceId"]
+      end
+    end
+  end
+end

data/app/services/workarea/listrak/email_api/lists.rb

@@ -0,0 +1,21 @@
+module Workarea
+  module Listrak
+    class EmailApi::Lists
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+      end
+
+      # Get all lists in Listrak
+      #
+      # @return [Array<Workarea::Listrak::Models::List>] Listrak lists
+      def all
+        request = Net::HTTP::Get.new("/email/v1/List")
+        response = client.request request
+        body = JSON.parse(response.body)
+        body["data"].map { |list| Listrak::Models::List.new list }
+      end
+    end
+  end
+end

data/app/services/workarea/listrak/email_api/messages.rb

@@ -0,0 +1,50 @@
+module Workarea
+  module Listrak
+    class EmailApi::Messages
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+      end
+
+      # Sends a new message on the specified list.
+      #
+      # @param [String] list_id the list to send the message
+      # @param [Workarea::Listrak::Models::MessageForm] message to send
+      # @param [Hash] options extra options when sending the message
+      # @option options [String] sendDate the send date for the message
+      # @option options [Boolean] sendTestMessage whether a test message should be sent. default false
+      # @option options [Boolean] sendReviewMessage whether a review message should be sent. default false
+      # @option options [String] testEmailAddress test email address that will be used to preview the scheduled message
+      #
+      def create(list_id, message, **options)
+        params = validate_query_params(options, create_params)
+        params = {}.to_param
+        path = ["/email/v1/List/#{list_id}/Message", params].compact.join '?'
+        request = Net::HTTP::Post.new(path).tap do |post|
+          post.body = message.to_json
+        end
+        response = client.request request
+        body = JSON.parse(response.body)
+        body["resourceId"]
+      end
+
+      private
+
+        def validate_query_params(hash, valid_params)
+          hash.select do |key, value|
+            valid_params[key] && value.is_a?(valid_params[key])
+          end.to_param.presence
+        end
+
+        def create_params
+          {
+            sendDate: String,
+            sendTestMessage: Boolean,
+            sendReviewMessage: Boolean,
+            testEmailAddress: String
+          }
+        end
+    end
+  end
+end

data/app/services/workarea/listrak/email_api/transactional_messages.rb

@@ -0,0 +1,32 @@
+module Workarea
+  module Listrak
+    # A Transactional Message resource provides a way to access transactional
+    # messages that have been created on a list.
+    #
+    class EmailApi::TransactionalMessages
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+      end
+
+      # Sends a message based on a previously-created transactional message.
+      #
+      # @param [Integer] list_id Identifier used to locate the list
+      # @param [Integer] message_id Identifier used to locate the transactional message.
+      # @param [Workarea::Listrak::Models::TransactionalMessageForm] transactional_message_form
+      #
+      # @return [String] resource id
+      #
+      def create(list_id, message_id, transactional_message_form)
+        path = "/email/v1/List/#{list_id}/TransactionalMessage/#{message_id}/Message"
+        request = Net::HTTP::Post.new(path).tap do |post|
+          post.body = transactional_message_form.to_json
+        end
+        response = client.request request
+        body = JSON.parse(response.body)
+        body["resourceId"]
+      end
+    end
+  end
+end