harpiya_core 4.3.0.alpha

data/app/models/concerns/harpiya/ransackable_attributes.rb

@@ -0,0 +1,23 @@
+module Harpiya::RansackableAttributes
+  extend ActiveSupport::Concern
+  included do
+    class_attribute :whitelisted_ransackable_associations
+    class_attribute :whitelisted_ransackable_attributes
+    class_attribute :whitelisted_ransackable_scopes
+
+    class_attribute :default_ransackable_attributes
+    self.default_ransackable_attributes = %w[id name updated_at created_at]
+
+    def self.ransackable_associations(*_args)
+      whitelisted_ransackable_associations || []
+    end
+
+    def self.ransackable_attributes(*_args)
+      default_ransackable_attributes | (whitelisted_ransackable_attributes || [])
+    end
+
+    def self.ransackable_scopes(*_args)
+      whitelisted_ransackable_scopes || []
+    end
+  end
+end

data/app/models/concerns/harpiya/user_address.rb

@@ -0,0 +1,51 @@
+module Harpiya
+  module UserAddress
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :bill_address, foreign_key: :bill_address_id, class_name: 'Harpiya::Address',
+                                optional: true
+      alias_attribute :billing_address, :bill_address
+
+      belongs_to :ship_address, foreign_key: :ship_address_id, class_name: 'Harpiya::Address',
+                                optional: true
+      alias_attribute :shipping_address, :ship_address
+
+      accepts_nested_attributes_for :ship_address, :bill_address
+
+      has_many :addresses, -> { where(deleted_at: nil).order('updated_at DESC') },
+                           class_name: 'Harpiya::Address', foreign_key: :user_id
+
+      validate :address_not_associated_with_other_user, :address_not_deprecated_in_completed_order
+
+      def persist_order_address(order)
+        b_address = bill_address || build_bill_address
+        b_address.attributes = order.bill_address.value_attributes
+        b_address.save
+        update(bill_address_id: b_address.id)
+
+        # May not be present if delivery step has been removed
+        if order.ship_address
+          s_address = ship_address || build_ship_address
+          s_address.attributes = order.ship_address.value_attributes
+          s_address.save
+          update(ship_address_id: s_address.id)
+        end
+      end
+
+      private
+
+      def address_not_associated_with_other_user
+        errors.add(:bill_address_id, :belongs_to_other_user) if bill_address&.user_id && self != bill_address&.user
+        errors.add(:ship_address_id, :belongs_to_other_user) if ship_address&.user_id && self != ship_address&.user
+      end
+
+      def address_not_deprecated_in_completed_order
+        errors.add(:bill_address_id, :deprecated_in_completed_order) if
+          orders.complete.with_deleted_bill_address.where(bill_address: bill_address_id).any?
+        errors.add(:ship_address_id, :deprecated_in_completed_order) if
+          orders.complete.with_deleted_ship_address.where(ship_address: ship_address_id).any?
+      end
+    end
+  end
+end

data/app/models/concerns/harpiya/user_methods.rb

@@ -0,0 +1,90 @@
+module Harpiya
+  module UserMethods
+    extend ActiveSupport::Concern
+
+    include Harpiya::UserPaymentSource
+    include Harpiya::UserReporting
+    include Harpiya::RansackableAttributes
+
+    included do
+      # we need to have this callback before any dependent: :destroy associations
+      # https://github.com/rails/rails/issues/3458
+      before_validation :clone_billing_address, if: :use_billing?
+      before_destroy :check_completed_orders
+      after_destroy :nullify_approver_id_in_approved_orders
+
+      attr_accessor :use_billing
+
+      has_many :role_users, class_name: 'Harpiya::RoleUser', foreign_key: :user_id, dependent: :destroy
+      has_many :harpiya_roles, through: :role_users, class_name: 'Harpiya::Role', source: :role
+
+      has_many :promotion_rule_users, class_name: 'Harpiya::PromotionRuleUser', foreign_key: :user_id, dependent: :destroy
+      has_many :promotion_rules, through: :promotion_rule_users, class_name: 'Harpiya::PromotionRule'
+
+      has_many :orders, foreign_key: :user_id, class_name: 'Harpiya::Order'
+      has_many :store_credits, foreign_key: :user_id, class_name: 'Harpiya::StoreCredit'
+
+      belongs_to :ship_address, class_name: 'Harpiya::Address', optional: true
+      belongs_to :bill_address, class_name: 'Harpiya::Address', optional: true
+
+      self.whitelisted_ransackable_associations = %w[bill_address ship_address addresses]
+      self.whitelisted_ransackable_attributes = %w[id email]
+
+      def self.with_email(query)
+        where("#{table_name}.email LIKE ?", "%#{query}%")
+      end
+
+      def self.with_address(query, address = :ship_address)
+        left_outer_joins(address).
+          where("#{Harpiya::Address.table_name}.firstname like ?", "%#{query}%").
+          or(left_outer_joins(address).where("#{Harpiya::Address.table_name}.lastname like ?", "%#{query}%"))
+      end
+
+      def self.with_email_or_address(email, address)
+        left_outer_joins(:addresses).
+          where("#{Harpiya::Address.table_name}.firstname LIKE ? or #{Harpiya::Address.table_name}.lastname LIKE ? or #{table_name}.email LIKE ?",
+                "%#{address}%", "%#{address}%", "%#{email}%")
+      end
+    end
+
+    # has_harpiya_role? simply needs to return true or false whether a user has a role or not.
+    def has_harpiya_role?(role_in_question)
+      harpiya_roles.any? { |role| role.name == role_in_question.to_s }
+    end
+
+    def last_incomplete_harpiya_order(store, options = {})
+      orders.where(store: store).incomplete.
+        includes(options[:includes]).
+        order('created_at DESC').
+        first
+    end
+
+    def total_available_store_credit(currency = nil)
+      currency ||= Harpiya::Config[:currency]
+      store_credits.where(currency: currency).reload.to_a.sum(&:amount_remaining)
+    end
+
+    private
+
+    def check_completed_orders
+      raise Harpiya::Core::DestroyWithOrdersError if orders.complete.present?
+    end
+
+    def nullify_approver_id_in_approved_orders
+      Harpiya::Order.where(approver_id: id).update_all(approver_id: nil)
+    end
+
+    def clone_billing_address
+      if bill_address && ship_address.nil?
+        self.ship_address = bill_address.clone
+      else
+        ship_address.attributes = bill_address.attributes.except('id', 'updated_at', 'created_at')
+      end
+      true
+    end
+
+    def use_billing?
+      use_billing.in?([true, 'true', '1'])
+    end
+  end
+end

data/app/models/concerns/harpiya/user_payment_source.rb

@@ -0,0 +1,21 @@
+module Harpiya
+  module UserPaymentSource
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :credit_cards, class_name: 'Harpiya::CreditCard', foreign_key: :user_id
+      def default_credit_card
+        credit_cards.default.first
+      end
+
+      def payment_sources
+        credit_cards.with_payment_profile.not_expired.where(payment_method: Harpiya::PaymentMethod.active)
+      end
+
+      def drop_payment_source(source)
+        gateway = source.payment_method
+        gateway.disable_customer_profile(source)
+      end
+    end
+  end
+end

data/app/models/concerns/harpiya/user_reporting.rb

@@ -0,0 +1,22 @@
+module Harpiya
+  module UserReporting
+    extend DisplayMoney
+    money_methods :lifetime_value, :average_order_value
+
+    def lifetime_value
+      orders.complete.sum(:total)
+    end
+
+    def order_count
+      orders.complete.size
+    end
+
+    def average_order_value
+      if order_count > 0
+        lifetime_value / order_count
+      else
+        BigDecimal('0.00')
+      end
+    end
+  end
+end

data/app/models/concerns/harpiya/vat_price_calculation.rb

@@ -0,0 +1,48 @@
+module Harpiya
+  module VatPriceCalculation
+    def gross_amount(amount, price_options)
+      return amount unless outside_default_vat_zone?(price_options)
+
+      round_to_two_places(add_foreign_vat_for(amount, price_options))
+    end
+
+    private
+
+    def add_foreign_vat_for(amount, price_options)
+      amount = net_amount(amount, price_options[:tax_category])
+      amount_with_foreign_vat(amount, price_options)
+    end
+
+    def net_amount(amount, tax_category)
+      amount / (1 + default_vat(tax_category))
+    end
+
+    def default_vat(tax_category)
+      included_tax_amount(tax_zone: default_zone, tax_category: tax_category)
+    end
+
+    def foreign_vat(price_options)
+      included_tax_amount(price_options)
+    end
+
+    def amount_with_foreign_vat(amount, price_options)
+      amount * (1 + foreign_vat(price_options))
+    end
+
+    def outside_default_vat_zone?(price_options)
+      price_options[:tax_zone] && default_zone && price_options[:tax_zone] != default_zone
+    end
+
+    def included_tax_amount(price_options)
+      Harpiya::TaxRate.included_tax_amount_for(price_options).to_f
+    end
+
+    def default_zone
+      @_default_zone ||= Harpiya::Zone.default_tax
+    end
+
+    def round_to_two_places(amount)
+      BigDecimal(amount.to_s).round(2, BigDecimal::ROUND_HALF_UP)
+    end
+  end
+end

data/app/models/friendly_id/slug_decorator.rb

@@ -0,0 +1,9 @@
+module FriendlyId
+  module SlugDecorator
+    def self.prepended(base)
+      base.acts_as_paranoid
+    end
+  end
+end
+
+FriendlyId::Slug.prepend FriendlyId::SlugDecorator

data/app/models/harpiya/ability.rb

@@ -0,0 +1,93 @@
+# Implementation class for Cancan gem.  Instead of overriding this class, consider adding new permissions
+# using the special +register_ability+ method which allows extensions to add their own abilities.
+#
+# See http://github.com/ryanb/cancan for more details on cancan.
+require 'cancan'
+module Harpiya
+  class Ability
+    include CanCan::Ability
+
+    class_attribute :abilities
+    self.abilities = Set.new
+
+    # Allows us to go beyond the standard cancan initialize method which makes it difficult for engines to
+    # modify the default +Ability+ of an application.  The +ability+ argument must be a class that includes
+    # the +CanCan::Ability+ module.  The registered ability should behave properly as a stand-alone class
+    # and therefore should be easy to test in isolation.
+    def self.register_ability(ability)
+      abilities.add(ability)
+    end
+
+    def self.remove_ability(ability)
+      abilities.delete(ability)
+    end
+
+    def initialize(user)
+      alias_cancan_delete_action
+
+      user ||= Harpiya.user_class.new
+
+      if user.respond_to?(:has_harpiya_role?) && user.has_harpiya_role?('admin')
+        apply_admin_permissions(user)
+      else
+        apply_user_permissions(user)
+      end
+
+      # Include any abilities registered by extensions, etc.
+      # this is legacy behaviour and should be removed in Harpiya 5.0
+      Ability.abilities.merge(abilities_to_register).each do |clazz|
+        merge clazz.new(user)
+      end
+
+      protect_admin_role
+    end
+
+    protected
+
+    # you can override this method to register your abilities
+    # this method has to return array of classes
+    def abilities_to_register
+      []
+    end
+
+    def alias_cancan_delete_action
+      alias_action :delete, to: :destroy
+      alias_action :create, :update, :destroy, to: :modify
+    end
+
+    def apply_admin_permissions(user)
+      can :manage, :all
+    end
+
+    def apply_user_permissions(user)
+      can :read, ::Harpiya::Country
+      can :read, ::Harpiya::Menu
+      can :read, ::Harpiya::OptionType
+      can :read, ::Harpiya::OptionValue
+      can :create, ::Harpiya::Order
+      can :show, ::Harpiya::Order do |order, token|
+        order.user == user || order.token && token == order.token
+      end
+      can :update, ::Harpiya::Order do |order, token|
+        !order.completed? && (order.user == user || order.token && token == order.token)
+      end
+      can :manage, ::Harpiya::Address, user_id: user.id
+      can :read, ::Harpiya::CreditCard, user_id: user.id
+      can :read, ::Harpiya::Product
+      can :read, ::Harpiya::ProductProperty
+      can :read, ::Harpiya::Property
+      can :create, ::Harpiya.user_class
+      can [:show, :update, :destroy], ::Harpiya.user_class, id: user.id
+      can :read, ::Harpiya::State
+      can :read, ::Harpiya::Store
+      can :read, ::Harpiya::Taxon
+      can :read, ::Harpiya::Taxonomy
+      can :read, ::Harpiya::Variant
+      can :read, ::Harpiya::Zone
+    end
+
+    def protect_admin_role
+      cannot [:update, :destroy], ::Harpiya::Role, name: ['admin']
+    end
+  end
+end

data/app/models/harpiya/address.rb

@@ -0,0 +1,245 @@
+module Harpiya
+  class Address < Harpiya::Base
+    require 'validates_zipcode'
+
+    if Rails::VERSION::STRING >= '6.1'
+      serialize :preferences, Hash, default: {}
+    end
+
+    NO_ZIPCODE_ISO_CODES ||= [
+      'AO', 'AG', 'AW', 'BS', 'BZ', 'BJ', 'BM', 'BO', 'BW', 'BF', 'BI', 'CM', 'CF', 'KM', 'CG',
+      'CD', 'CK', 'CUW', 'CI', 'DJ', 'DM', 'GQ', 'ER', 'FJ', 'TF', 'GAB', 'GM', 'GH', 'GD', 'GN',
+      'GY', 'HK', 'IE', 'KI', 'KP', 'LY', 'MO', 'MW', 'ML', 'MR', 'NR', 'AN', 'NU', 'KP', 'PA',
+      'QA', 'RW', 'KN', 'LC', 'ST', 'SC', 'SL', 'SB', 'SO', 'SR', 'SY', 'TZ', 'TL', 'TK', 'TG',
+      'TO', 'TV', 'UG', 'AE', 'VU', 'YE', 'ZW'
+    ].freeze
+
+    # The required states listed below match those used by PayPal and Shopify.
+    STATES_REQUIRED = [
+      'AU', 'AE', 'BR', 'CA', 'CN', 'ES', 'HK', 'IE', 'IN',
+      'IT', 'MY', 'MX', 'NZ', 'PT', 'RO', 'TH', 'US', 'ZA'
+    ].freeze
+
+    # we're not freezing this on purpose so developers can extend and manage
+    # those attributes depending of the logic of their applications
+    ADDRESS_FIELDS = %w(firstname lastname company address1 address2 city state zipcode country phone)
+    EXCLUDED_KEYS_FOR_COMPARISION = %w(id updated_at created_at deleted_at label user_id)
+
+    scope :not_deleted, -> { where(deleted_at: nil) }
+
+    belongs_to :country, class_name: 'Harpiya::Country'
+    belongs_to :state, class_name: 'Harpiya::State', optional: true
+    belongs_to :user, class_name: Harpiya.user_class.name, optional: true
+
+    has_many :shipments, inverse_of: :address
+
+    before_validation :clear_invalid_state_entities, if: -> { country.present? }, on: :update
+
+    with_options presence: true do
+      validates :firstname, :lastname, :address1, :city, :country
+      validates :zipcode, if: :require_zipcode?
+      validates :phone, if: :require_phone?
+    end
+
+    validate :state_validate, :postal_code_validate
+
+    validates :label, uniqueness: { conditions: -> { where(deleted_at: nil) },
+                                    scope: :user_id,
+                                    case_sensitive: false,
+                                    allow_blank: true,
+                                    allow_nil: true }
+
+    delegate :name, :iso3, :iso, :iso_name, to: :country, prefix: true
+    delegate :abbr, to: :state, prefix: true, allow_nil: true
+
+    alias_attribute :first_name, :firstname
+    alias_attribute :last_name, :lastname
+
+    self.whitelisted_ransackable_attributes = ADDRESS_FIELDS
+    self.whitelisted_ransackable_associations = %w[country state user]
+
+    def self.build_default
+      ActiveSupport::Deprecation.warn(<<-DEPRECATION, caller)
+        `Address#build_default` is deprecated and will be removed in Harpiya 5.0.
+        Please use standard rails `Address.new(country: current_store.default_country)`
+      DEPRECATION
+      new(country: Harpiya::Country.default)
+    end
+
+    def self.default(user = nil, kind = 'bill')
+      ActiveSupport::Deprecation.warn(<<-DEPRECATION, caller)
+        `Address#default` is deprecated and will be removed in Harpiya 5.0.
+      DEPRECATION
+      if user && user_address = user.public_send(:"#{kind}_address")
+        user_address.clone
+      else
+        build_default
+      end
+    end
+
+    def self.required_fields
+      Harpiya::Address.validators.map do |v|
+        v.is_a?(ActiveModel::Validations::PresenceValidator) ? v.attributes : []
+      end.flatten
+    end
+
+    def full_name
+      "#{firstname} #{lastname}".strip
+    end
+
+    def state_text
+      state.try(:abbr) || state.try(:name) || state_name
+    end
+
+    def state_name_text
+      state_name.present? ? state_name : state&.name
+    end
+
+    def to_s
+      [
+        full_name,
+        company,
+        address1,
+        address2,
+        "#{city}, #{state_text} #{zipcode}",
+        country.to_s
+      ].reject(&:blank?).map { |attribute| ERB::Util.html_escape(attribute) }.join('<br/>')
+    end
+
+    def clone
+      self.class.new(value_attributes)
+    end
+
+    def ==(other)
+      return false unless other&.respond_to?(:value_attributes)
+
+      value_attributes == other.value_attributes
+    end
+
+    def value_attributes
+      attributes.except(*EXCLUDED_KEYS_FOR_COMPARISION)
+    end
+
+    def empty?
+      attributes.except('id', 'created_at', 'updated_at', 'country_id').all? { |_, v| v.nil? }
+    end
+
+    # Generates an ActiveMerchant compatible address hash
+    def active_merchant_hash
+      {
+        name: full_name,
+        address1: address1,
+        address2: address2,
+        city: city,
+        state: state_text,
+        zip: zipcode,
+        country: country.try(:iso),
+        phone: phone
+      }
+    end
+
+    def require_phone?
+      Harpiya::Config[:address_requires_phone]
+    end
+
+    def require_zipcode?
+      country ? country.zipcode_required? : true
+    end
+
+    def editable?
+      new_record? || (shipments.empty? && !Order.complete.where('bill_address_id = ? OR ship_address_id = ?', id, id).exists?)
+    end
+
+    def can_be_deleted?
+      shipments.empty? && !Order.where('bill_address_id = ? OR ship_address_id = ?', id, id).exists?
+    end
+
+    def check
+      attrs = attributes.except('id', 'updated_at', 'created_at')
+      the_same_address = user&.addresses&.find_by(attrs)
+      the_same_address || self
+    end
+
+    def destroy
+      if can_be_deleted?
+        super
+      else
+        update_column :deleted_at, Time.current
+        assign_new_default_address_to_user
+      end
+    end
+
+    private
+
+    def clear_state
+      self.state = nil
+    end
+
+    def clear_state_name
+      self.state_name = nil
+    end
+
+    def clear_invalid_state_entities
+      if state.present? && (state.country != country)
+        clear_state
+      elsif state_name.present? && !country.states_required? && country.states.empty?
+        clear_state_name
+      end
+    end
+
+    def state_validate
+      # Skip state validation without country (also required)
+      # or when disabled by preference
+      return if country.blank? || !Harpiya::Config[:address_requires_state]
+      return unless country.states_required
+
+      # ensure associated state belongs to country
+      if state.present?
+        if state.country == country
+          clear_state_name # not required as we have a valid state and country combo
+        elsif state_name.present?
+          clear_state
+        else
+          errors.add(:state, :invalid)
+        end
+      end
+
+      # ensure state_name belongs to country without states, or that it matches a predefined state name/abbr
+      if state_name.present?
+        if country.states.present?
+          states = country.states.find_all_by_name_or_abbr(state_name)
+
+          if states.size == 1
+            self.state = states.first
+            clear_state_name
+          else
+            errors.add(:state, :invalid)
+          end
+        end
+      end
+
+      # ensure at least one state field is populated
+      errors.add :state, :blank if state.blank? && state_name.blank?
+    end
+
+    def postal_code_validate
+      return if country.blank? || country_iso.blank? || !require_zipcode?
+      return unless ::ValidatesZipcode::CldrRegexpCollection::ZIPCODES_REGEX.keys.include?(country_iso.upcase.to_sym)
+
+      formatted_zip = ::ValidatesZipcode::Formatter.new(
+        zipcode: zipcode.to_s.strip,
+        country_alpha2: country_iso.upcase
+      ).format
+
+      errors.add(:zipcode, :invalid) unless ::ValidatesZipcode.valid?(formatted_zip, country_iso.upcase)
+    end
+
+    def assign_new_default_address_to_user
+      return unless user
+
+      user.bill_address = user.addresses.last if user.bill_address == self
+      user.ship_address = user.addresses.last if user.ship_address == self
+      user.save!
+    end
+  end
+end