harpiya_core 4.3.0.alpha

data/app/models/harpiya/store.rb

@@ -0,0 +1,165 @@
+module Harpiya
+  class Store < Harpiya::Base
+    MAILER_LOGO_CONTENT_TYPES = ['image/png', 'image/jpg', 'image/jpeg'].freeze
+    FAVICON_CONTENT_TYPES = ['image/png', 'image/x-icon', 'image/vnd.microsoft.icon'].freeze
+
+    has_many :orders, class_name: 'Harpiya::Order'
+    has_many :payment_methods, class_name: 'Harpiya::PaymentMethod'
+
+    has_many :menus
+
+    has_many :store_products, class_name: 'Harpiya::StoreProduct', dependent: :destroy
+    has_many :products, through: :store_products, class_name: 'Harpiya::Product'
+
+    belongs_to :default_country, class_name: 'Harpiya::Country'
+    belongs_to :checkout_zone, class_name: 'Harpiya::Zone'
+
+    with_options presence: true do
+      validates :name, :url, :mail_from_address, :default_currency, :code
+    end
+
+    validates :code, uniqueness: true
+
+    if !ENV['HARPIYA_DISABLE_DB_CONNECTION'] &&
+        connected? &&
+        table_exists? &&
+        connection.column_exists?(:harpiya_stores, :new_order_notifications_email)
+      validates :new_order_notifications_email, email: { allow_blank: true }
+    end
+
+    has_one_attached :logo
+    has_one_attached :mailer_logo
+    has_one_attached :favicon_image
+
+    validates :mailer_logo, content_type: MAILER_LOGO_CONTENT_TYPES
+    validates :favicon_image, content_type: FAVICON_CONTENT_TYPES,
+                              dimension: { max: 256..256 },
+                              aspect_ratio: :square,
+                              size: { less_than_or_equal_to: 1.megabyte }
+
+    before_save :ensure_default_exists_and_is_unique
+    before_save :ensure_supported_currencies, :ensure_supported_locales, :ensure_default_country
+    before_destroy :validate_not_default
+
+    scope :by_url, ->(url) { where('url like ?', "%#{url}%") }
+
+    after_commit :clear_cache
+
+    alias_attribute :contact_email, :customer_support_email
+
+    def self.current(domain = nil)
+      current_store = domain ? Store.by_url(domain).first : nil
+      current_store || Store.default
+    end
+
+    def self.default
+      Rails.cache.fetch('default_store') do
+        where(default: true).first_or_initialize
+      end
+    end
+
+    def self.available_locales
+      Rails.cache.fetch('stores_available_locales') do
+        Harpiya::Store.all.map(&:supported_locales_list).flatten.uniq
+      end
+    end
+
+    def default_menu(location)
+      menu = menus.find_by(location: location, locale: default_locale) || menus.find_by(location: location)
+
+      menu.root if menu.present?
+    end
+
+    def supported_currencies_list
+      @supported_currencies_list ||= (read_attribute(:supported_currencies).to_s.split(',') << default_currency).sort.map(&:to_s).map do |code|
+        ::Money::Currency.find(code.strip)
+      end.uniq.compact
+    end
+
+    def supported_locales_list
+      # TODO: add support of multiple supported languages to a single Store
+      @supported_locales_list ||= (read_attribute(:supported_locales).to_s.split(',') << default_locale).compact.uniq.sort
+    end
+
+    def unique_name
+      @unique_name ||= "#{name} (#{code})"
+    end
+
+    def formatted_url
+      return if url.blank?
+
+      @formatted_url ||= if url.match(/http:\/\/|https:\/\//)
+                           url
+                         else
+                           Rails.env.development? ? "http://#{url}" : "https://#{url}"
+                         end
+    end
+
+    def countries_available_for_checkout
+      @countries_available_for_checkout ||= checkout_zone_or_default.try(:country_list) || Harpiya::Country.all
+    end
+
+    def states_available_for_checkout(country)
+      checkout_zone_or_default.try(:state_list_for, country) || country.states
+    end
+
+    def checkout_zone_or_default
+      @checkout_zone_or_default ||= checkout_zone || Harpiya::Zone.default_checkout_zone
+    end
+
+    def favicon
+      return unless favicon_image.attached?
+
+      favicon_image.variant(resize: '32x32')
+    end
+
+    private
+
+    def ensure_default_exists_and_is_unique
+      if default
+        Store.where.not(id: id).update_all(default: false)
+      elsif Store.where(default: true).count.zero?
+        self.default = true
+      end
+    end
+
+    def ensure_supported_locales
+      return unless attributes.keys.include?('supported_locales')
+      return if supported_locales.present?
+      return if default_locale.blank?
+
+      self.supported_locales = default_locale
+    end
+
+    def ensure_supported_currencies
+      return unless attributes.keys.include?('supported_currencies')
+      return if supported_currencies.present?
+      return if default_currency.blank?
+
+      self.supported_currencies = default_currency
+    end
+
+    def validate_not_default
+      if default
+        errors.add(:base, :cannot_destroy_default_store)
+        throw(:abort)
+      end
+    end
+
+    def clear_cache
+      Rails.cache.delete('default_store')
+      Rails.cache.delete('stores_available_locales')
+    end
+
+    def ensure_default_country
+      return unless has_attribute?(:default_country_id)
+      return if default_country.present? && (checkout_zone.blank? || checkout_zone.country_list.blank? || checkout_zone.country_list.include?(default_country))
+
+      self.default_country = if checkout_zone.present? && checkout_zone.country_list.any?
+                               checkout_zone.country_list.first
+                             else
+                               Country.find_by(iso: 'US') || Country.first
+                             end
+    end
+  end
+end

data/app/models/harpiya/store_credit.rb

@@ -0,0 +1,249 @@
+module Harpiya
+  class StoreCredit < Harpiya::Base
+    acts_as_paranoid
+
+    VOID_ACTION       = 'void'.freeze
+    CANCEL_ACTION     = 'cancel'.freeze
+    CREDIT_ACTION     = 'credit'.freeze
+    CAPTURE_ACTION    = 'capture'.freeze
+    ELIGIBLE_ACTION   = 'eligible'.freeze
+    AUTHORIZE_ACTION  = 'authorize'.freeze
+    ALLOCATION_ACTION = 'allocation'.freeze
+
+    DEFAULT_CREATED_BY_EMAIL = 'harpiya@example.com'.freeze
+
+    belongs_to :user, class_name: Harpiya.user_class.to_s, foreign_key: 'user_id'
+    belongs_to :category, class_name: 'Harpiya::StoreCreditCategory'
+    belongs_to :created_by, class_name: Harpiya.user_class.to_s, foreign_key: 'created_by_id'
+    belongs_to :credit_type, class_name: 'Harpiya::StoreCreditType', foreign_key: 'type_id'
+    has_many :store_credit_events
+
+    validates :user, :category, :credit_type, :created_by, :currency, presence: true
+    validates :amount, numericality: { greater_than: 0 }
+    validates :amount_used, numericality: { greater_than_or_equal_to: 0 }
+    validate :amount_used_less_than_or_equal_to_amount
+    validate :amount_authorized_less_than_or_equal_to_amount
+
+    delegate :name, to: :category, prefix: true
+    delegate :email, to: :created_by, prefix: true
+
+    scope :order_by_priority, -> { includes(:credit_type).order('harpiya_store_credit_types.priority ASC') }
+
+    before_validation :associate_credit_type
+    after_save :store_event
+    before_destroy :validate_no_amount_used
+
+    attr_accessor :action, :action_amount, :action_originator, :action_authorization_code
+
+    extend Harpiya::DisplayMoney
+    money_methods :amount, :amount_used
+
+    def amount_remaining
+      amount - amount_used - amount_authorized
+    end
+
+    def authorize(amount, order_currency, options = {})
+      authorization_code = options[:action_authorization_code]
+      if authorization_code
+        if store_credit_events.find_by(action: AUTHORIZE_ACTION, authorization_code: authorization_code)
+          # Don't authorize again on capture
+          return true
+        end
+      else
+        authorization_code = generate_authorization_code
+      end
+      if validate_authorization(amount, order_currency)
+        update!(
+          action: AUTHORIZE_ACTION,
+          action_amount: amount,
+          action_originator: options[:action_originator],
+          action_authorization_code: authorization_code,
+          amount_authorized: amount_authorized + amount
+        )
+        authorization_code
+      else
+        errors.add(:base, Harpiya.t('store_credit_payment_method.insufficient_authorized_amount'))
+        false
+      end
+    end
+
+    def validate_authorization(amount, order_currency)
+      if BigDecimal(amount_remaining, 3) < BigDecimal(amount, 3)
+        errors.add(:base, Harpiya.t('store_credit_payment_method.insufficient_funds'))
+      elsif currency != order_currency
+        errors.add(:base, Harpiya.t('store_credit_payment_method.currency_mismatch'))
+      end
+      errors.blank?
+    end
+
+    def capture(amount, authorization_code, order_currency, options = {})
+      return false unless authorize(amount, order_currency, action_authorization_code: authorization_code)
+
+      if amount <= amount_authorized
+        if currency != order_currency
+          errors.add(:base, Harpiya.t('store_credit_payment_method.currency_mismatch'))
+          false
+        else
+          update!(
+            action: CAPTURE_ACTION,
+            action_amount: amount,
+            action_originator: options[:action_originator],
+            action_authorization_code: authorization_code,
+            amount_used: amount_used + amount,
+            amount_authorized: amount_authorized - amount
+          )
+          authorization_code
+        end
+      else
+        errors.add(:base, Harpiya.t('store_credit_payment_method.insufficient_authorized_amount'))
+        false
+      end
+    end
+
+    def void(authorization_code, options = {})
+      if auth_event = store_credit_events.find_by(action: AUTHORIZE_ACTION, authorization_code: authorization_code)
+        update!(
+          action: VOID_ACTION,
+          action_amount: auth_event.amount,
+          action_authorization_code: authorization_code,
+          action_originator: options[:action_originator],
+          amount_authorized: amount_authorized - auth_event.amount
+        )
+        true
+      else
+        errors.add(:base, Harpiya.t('store_credit_payment_method.unable_to_void', auth_code: authorization_code))
+        false
+      end
+    end
+
+    def credit(amount, authorization_code, order_currency, options = {})
+      # Find the amount related to this authorization_code in order to add the store credit back
+      capture_event = store_credit_events.find_by(action: CAPTURE_ACTION, authorization_code: authorization_code)
+
+      if currency != order_currency # sanity check to make sure the order currency hasn't changed since the auth
+        errors.add(:base, Harpiya.t('store_credit_payment_method.currency_mismatch'))
+        false
+      elsif capture_event && amount <= capture_event.amount
+        action_attributes = {
+          action: CREDIT_ACTION,
+          action_amount: amount,
+          action_originator: options[:action_originator],
+          action_authorization_code: authorization_code
+        }
+        create_credit_record(amount, action_attributes)
+        true
+      else
+        errors.add(:base, Harpiya.t('store_credit_payment_method.unable_to_credit', auth_code: authorization_code))
+        false
+      end
+    end
+
+    def actions
+      [CAPTURE_ACTION, VOID_ACTION, CREDIT_ACTION]
+    end
+
+    def can_capture?(payment)
+      payment.pending? || payment.checkout?
+    end
+
+    def can_void?(payment)
+      payment.pending? || (payment.checkout? && !payment.order.completed?)
+    end
+
+    def can_credit?(payment)
+      payment.completed? && payment.credit_allowed > 0
+    end
+
+    def generate_authorization_code
+      "#{id}-SC-#{Time.now.utc.strftime('%Y%m%d%H%M%S%6N')}"
+    end
+
+    class << self
+      def default_created_by
+        Harpiya.user_class.find_by(email: DEFAULT_CREATED_BY_EMAIL)
+      end
+    end
+
+    private
+
+    def create_credit_record(amount, action_attributes = {})
+      # Setting credit_to_new_allocation to true will create a new allocation anytime #credit is called
+      # If it is not set, it will update the store credit's amount in place
+      credit = if Harpiya::Config.credit_to_new_allocation
+                 Harpiya::StoreCredit.new(create_credit_record_params(amount))
+               else
+                 self.amount_used = amount_used - amount
+                 self
+               end
+
+      credit.assign_attributes(action_attributes)
+      credit.save!
+    end
+
+    def create_credit_record_params(amount)
+      {
+        amount: amount,
+        user_id: user_id,
+        category_id: category_id,
+        created_by_id: created_by_id,
+        currency: currency,
+        type_id: type_id,
+        memo: credit_allocation_memo
+      }
+    end
+
+    def credit_allocation_memo
+      "This is a credit from store credit ID #{id}"
+    end
+
+    def store_event
+      return unless saved_change_to_amount? ||
+        saved_change_to_amount_used? ||
+        saved_change_to_amount_authorized? ||
+        action == ELIGIBLE_ACTION
+
+      event = if action
+                store_credit_events.build(action: action)
+              else
+                store_credit_events.where(action: ALLOCATION_ACTION).first_or_initialize
+              end
+
+      event.update!(
+        amount: action_amount || amount,
+        authorization_code: action_authorization_code || event.authorization_code || generate_authorization_code,
+        user_total_amount: user.total_available_store_credit,
+        originator: action_originator
+      )
+    end
+
+    def amount_used_less_than_or_equal_to_amount
+      return true if amount_used.nil?
+
+      if amount_used > amount
+        errors.add(:amount_used, :cannot_be_greater_than_amount)
+        false
+      end
+    end
+
+    def amount_authorized_less_than_or_equal_to_amount
+      if (amount_used + amount_authorized) > amount
+        errors.add(:amount_authorized, :exceeds_total_credits)
+        false
+      end
+    end
+
+    def validate_no_amount_used
+      if amount_used > 0
+        errors.add(:amount_used, :greater_than_zero_restrict_delete)
+        throw(:abort)
+      end
+    end
+
+    def associate_credit_type
+      unless type_id
+        credit_type_name = category.try(:non_expiring?) ? 'Non-expiring' : 'Expiring'
+        self.credit_type = Harpiya::StoreCreditType.find_by(name: credit_type_name)
+      end
+    end
+  end
+end

data/app/models/harpiya/store_credit_category.rb

@@ -0,0 +1,35 @@
+module Harpiya
+  class StoreCreditCategory < Harpiya::Base
+    validates :name, presence: true
+
+    before_destroy :validate_not_used
+
+    GIFT_CARD_CATEGORY_NAME = 'Gift Card'.freeze
+    DEFAULT_NON_EXPIRING_TYPES = [GIFT_CARD_CATEGORY_NAME]
+
+    def non_expiring?
+      non_expiring_category_types.include? name
+    end
+
+    def non_expiring_category_types
+      DEFAULT_NON_EXPIRING_TYPES | Harpiya::Config[:non_expiring_credit_types]
+    end
+
+    def store_credit_category_used?
+      Harpiya::StoreCredit.exists?(category_id: id)
+    end
+
+    def validate_not_used
+      if store_credit_category_used?
+        errors.add(:base, :cannot_destroy_if_used_in_store_credit)
+        throw(:abort)
+      end
+    end
+
+    class << self
+      def default_reimbursement_category(_options = {})
+        Harpiya::StoreCreditCategory.first
+      end
+    end
+  end
+end