harpiya_core 4.3.0.alpha

data/app/presenters/harpiya/variant_presenter.rb

@@ -0,0 +1,80 @@
+module Harpiya
+  class VariantPresenter
+    include Rails.application.routes.url_helpers
+    include Harpiya::BaseHelper
+    include Harpiya::ProductsHelper
+
+    attr_reader :current_currency, :current_price_options, :current_store
+
+    def initialize(opts = {})
+      @variants = opts[:variants]
+      @is_product_available_in_currency = opts[:is_product_available_in_currency]
+      @current_currency = opts[:current_currency]
+      @current_price_options = opts[:current_price_options]
+      @current_store = opts[:current_store]
+    end
+
+    def call
+      @variants.map do |variant|
+        {
+          display_price: display_price(variant),
+          price: variant.price_in(current_currency),
+          display_compare_at_price: display_compare_at_price(variant),
+          should_display_compare_at_price: should_display_compare_at_price?(variant),
+          is_product_available_in_currency: @is_product_available_in_currency,
+          backorderable: backorderable?(variant),
+          in_stock: in_stock?(variant),
+          images: images(variant),
+          option_values: option_values(variant),
+        }.merge(
+          variant_attributes(variant)
+        )
+      end
+    end
+
+    def images(variant)
+      variant.images.map do |image|
+        {
+          alt: image.alt,
+          url_product: rails_representation_url(image.url(:product), only_path: true)
+        }
+      end
+    end
+
+    def option_values(variant)
+      variant.option_values.map do |option_value|
+        {
+          id: option_value.id,
+          name: option_value.name,
+          presentation: option_value.presentation,
+        }
+      end
+    end
+
+    private
+
+    def backorderable?(variant)
+      backorderable_variant_ids.include?(variant.id)
+    end
+
+    def backorderable_variant_ids
+      @backorderable_variant_ids ||= Harpiya::Variant.where(id: @variants.map(&:id)).backorderable.ids
+    end
+
+    def in_stock?(variant)
+      in_stock_variant_ids.include?(variant.id)
+    end
+
+    def in_stock_variant_ids
+      @in_stock_variant_ids ||= Harpiya::Variant.where(id: @variants.map(&:id)).in_stock.ids
+    end
+
+    def variant_attributes(variant)
+      {
+        id: variant.id,
+        sku: variant.sku,
+        purchasable: variant.purchasable?
+      }
+    end
+  end
+end

data/app/presenters/harpiya/variants/option_types_presenter.rb

@@ -0,0 +1,87 @@
+module Harpiya
+  module Variants
+    class OptionTypesPresenter
+      def initialize(option_types, variants, product)
+        @option_types = option_types
+        @variant_ids = variants.map(&:id)
+        @product = product
+      end
+
+      def default_variant
+        default_variant_data[:variant]
+      end
+
+      def options
+        option_types.map do |option_type|
+          {
+            id: option_type.id,
+            name: option_type.name,
+            presentation: option_type.presentation,
+            position: option_type.position,
+            option_values: option_values_options(option_type.option_values)
+          }
+        end
+      end
+
+      private
+
+      attr_reader :option_types
+
+      def default_variant_data
+        return {} if option_types.empty?
+
+        @default_variant_data ||= begin
+          try_default_variant || find_in_stock_variant_data || find_backorderable_variant_data || find_first_variant_data
+        end
+      end
+
+      def find_in_stock_variant_data
+        find_variant_data(&:in_stock?)
+      end
+
+      def find_backorderable_variant_data
+        find_variant_data(&:backorderable?)
+      end
+
+      def find_variant_data(&block)
+        option_types.first.option_values.each do |option_value|
+          variant = option_value.variants.where(id: @variant_ids).order(:position).find(&block)
+
+          return { variant: variant, option_value: option_value } if variant
+        end
+
+        nil
+      end
+
+      def try_default_variant
+        option_types.first.option_values.each do |option_value|
+          variant = option_value.variants.where(id: @product.default_variant_id).first
+
+          return { variant: variant, option_value: option_value } if variant
+        end
+
+        nil
+      end
+
+      def find_first_variant_data
+        option_value = option_types.first.option_values.first
+        variant = option_value.variants.where(id: @variant_ids).order(:position).first
+
+        { variant: variant, option_value: option_value }
+      end
+
+      def option_values_options(option_values)
+        option_values.map do |option_value|
+          {
+            id: option_value.id,
+            position: option_value.position,
+            presentation: option_value.presentation,
+            name: option_value.name,
+            variant_id: option_value.variants.where(id: @variant_ids).order(:position).first.id,
+            is_default: option_value == default_variant_data[:option_value]
+          }
+        end
+      end
+    end
+  end
+end

data/app/presenters/harpiya/variants/options_presenter.rb

@@ -0,0 +1,49 @@
+module Harpiya
+  module Variants
+    class OptionsPresenter
+      WORDS_CONNECTOR = ', '.freeze
+
+      attr_reader :variant
+
+      delegate :option_values, to: :variant
+
+      def initialize(variant)
+        @variant = variant
+      end
+
+      def to_sentence
+        options = option_values
+        options = sort_options(options)
+        options = present_options(options)
+
+        join_options(options)
+      end
+
+      private
+
+      def sort_options(options)
+        options.sort_by { |o| o.option_type.position }
+      end
+
+      def present_options(options)
+        options.map do |ov|
+          method = "present_#{ov.option_type.name}_option"
+
+          respond_to?(method, true) ? send(method, ov) : present_option(ov)
+        end
+      end
+
+      def present_color_option(option)
+        "#{option.option_type.presentation}: #{option.name}"
+      end
+
+      def present_option(option)
+        "#{option.option_type.presentation}: #{option.presentation}"
+      end
+
+      def join_options(options)
+        options.to_sentence(words_connector: WORDS_CONNECTOR, two_words_connector: WORDS_CONNECTOR)
+      end
+    end
+  end
+end

data/app/services/harpiya/account/addresses/create.rb

@@ -0,0 +1,24 @@
+module Harpiya
+  module Account
+    module Addresses
+      class Create
+        prepend Harpiya::ServiceModule::Base
+        include Harpiya::Account::Addresses::Helper
+
+        attr_accessor :country
+
+        def call(user:, address_params:)
+          fill_country_and_state_ids(address_params)
+
+          address = user.addresses.new(address_params)
+          if address.save
+            assign_to_user_as_default(user: user, address_id: address.id)
+            success(address)
+          else
+            failure(address)
+          end
+        end
+      end
+    end
+  end
+end

data/app/services/harpiya/account/addresses/helper.rb

@@ -0,0 +1,43 @@
+module Harpiya
+  module Account
+    module Addresses
+      module Helper
+        private
+
+        attr_accessor :country
+
+        def fill_country_and_state_ids(params)
+          replace_country_iso_with_id(params)
+          fill_state_id(params)
+        end
+
+        def replace_country_iso_with_id(params)
+          iso = params[:country_iso]
+          return params unless iso.present?
+
+          country = Harpiya::Country.by_iso(iso)
+          params[:country_id] = country&.id
+          params.delete(:country_iso)
+          params
+        end
+
+        def fill_state_id(params)
+          state_name = params[:state_name]
+          return params unless state_name.present?
+
+          country ||= Harpiya::Country.find(params[:country_id]) if params[:country_id].present?
+          return params unless country
+
+          params[:state_id] = country.states.find_by(name: state_name)&.id
+          params
+        end
+
+        def assign_to_user_as_default(user:, address_id:)
+          if user.addresses.pluck(:id) == [address_id] # check if it's user first address
+            user.update(bill_address_id: address_id, ship_address_id: address_id)
+          end
+        end
+      end
+    end
+  end
+end

data/app/services/harpiya/account/addresses/update.rb

@@ -0,0 +1,23 @@
+module Harpiya
+  module Account
+    module Addresses
+      class Update
+        prepend Harpiya::ServiceModule::Base
+        include Harpiya::Account::Addresses::Helper
+
+        attr_accessor :country
+
+        def call(address:, address_params:)
+          address_params[:country_id] ||= address.country_id
+          fill_country_and_state_ids(address_params)
+
+          if address.update(address_params)
+            success(address)
+          else
+            failure(address)
+          end
+        end
+      end
+    end
+  end
+end

data/app/services/harpiya/account/create.rb

@@ -0,0 +1,17 @@
+module Harpiya
+  module Account
+    class Create
+      prepend Harpiya::ServiceModule::Base
+
+      def call(user_params: {})
+        user = Harpiya.user_class.new(user_params)
+
+        if user.save
+          success(user)
+        else
+          failure(user)
+        end
+      end
+    end
+  end
+end

data/app/services/harpiya/account/update.rb

@@ -0,0 +1,15 @@
+module Harpiya
+  module Account
+    class Update
+      prepend Harpiya::ServiceModule::Base
+
+      def call(user:, user_params: {})
+        if user.update(user_params)
+          success(user)
+        else
+          failure(user)
+        end
+      end
+    end
+  end
+end

data/app/services/harpiya/build_localized_redirect_url.rb

@@ -0,0 +1,101 @@
+require 'uri'
+
+module Harpiya
+  class BuildLocalizedRedirectUrl
+    prepend Harpiya::ServiceModule::Base
+
+    LOCALE_REGEX = /^\/[A-Za-z]{2}\/|^\/[A-Za-z]{2}-[A-Za-z]{2}\/|^\/[A-Za-z]{2}$|^\/[A-Za-z]{2}-[A-Za-z]{2}$/.freeze
+
+    SUPPORTED_PATHS_REGEX = /\/(products|t\/|cart|checkout|addresses|content)/.freeze
+
+    # rubocop:disable Lint/UnusedMethodArgument
+    def call(url:, locale:, default_locale: nil)
+      run :initialize_url_object
+      run :generate_new_path
+      run :append_locale_param
+      run :build_url
+    end
+    # rubocop:enable Lint/UnusedMethodArgument
+
+    protected
+
+    def initialize_url_object(url:, locale:, default_locale:)
+      success(
+        url: URI(url),
+        locale: locale,
+        default_locale_supplied: default_locale_supplied?(locale, default_locale)
+      )
+    end
+
+    def generate_new_path(url:, locale:, default_locale_supplied:)
+      unless supported_path?(url.path)
+        return success(
+          url: url,
+          locale: locale,
+          path: cleanup_path(url.path),
+          default_locale_supplied: default_locale_supplied,
+          locale_added_to_path: false
+        )
+      end
+
+      new_path = if default_locale_supplied
+                   maches_locale_regex?(url.path) ? url.path.gsub(LOCALE_REGEX, '/') : url.path
+                 else
+                   maches_locale_regex?(url.path) ? url.path.gsub(LOCALE_REGEX, "/#{locale}/") : "/#{locale}#{url.path}"
+                 end
+
+      success(
+        url: url,
+        locale: locale,
+        path: cleanup_path(new_path),
+        default_locale_supplied: default_locale_supplied,
+        locale_added_to_path: true
+      )
+    end
+
+    def append_locale_param(url:, locale:, path:, default_locale_supplied:, locale_added_to_path:)
+      return success(url: url, path: path, query: url.query) if locale_added_to_path
+
+      query_params = Rack::Utils.parse_nested_query(url.query)
+
+      if default_locale_supplied
+        query_params.delete('locale')
+      else
+        query_params.merge!('locale' => locale)
+      end
+
+      query_string = query_params.any? ? query_params.to_query : nil
+
+      success(url: url, path: path, query: query_string)
+    end
+
+    def build_url(url:, path:, query:)
+      localized_url = builder_class(url).build(host: url.host, port: url.port, path: path, query: query).to_s
+      success(localized_url)
+    end
+
+    private
+
+    def supported_path?(path)
+      return true if path.blank? || path == '/' || maches_locale_regex?(path)
+
+      path.match(SUPPORTED_PATHS_REGEX)
+    end
+
+    def maches_locale_regex?(path)
+      path.match(LOCALE_REGEX)[0].gsub('/', '') if path.match(LOCALE_REGEX)
+    end
+
+    def default_locale_supplied?(locale, default_locale)
+      default_locale.present? && default_locale.to_s == locale.to_s
+    end
+
+    def cleanup_path(path)
+      path.chomp('/').gsub('//', '/')
+    end
+
+    def builder_class(url)
+      url.scheme == 'http' ? URI::HTTP : URI::HTTPS
+    end
+  end
+end