harpiya_frontend 4.3.0.alpha

data/app/controllers/concerns/harpiya/checkout/address_book.rb

@@ -0,0 +1,55 @@
+# https://github.com/harpiya-contrib/harpiya_address_book/blob/master/app/controllers/harpiya/checkout_controller_decorator.rb
+module Harpiya
+  module Checkout
+    module AddressBook
+      extend ActiveSupport::Concern
+
+      included do
+        after_action :normalize_addresses, only: :update
+        before_action :set_addresses, only: :update
+      end
+
+      protected
+
+      def set_addresses
+        return unless params[:order] && params[:state] == 'address'
+
+        if params[:order][:ship_address_id].to_i > 0
+          params[:order].delete(:ship_address_attributes)
+
+          Harpiya::Address.find(params[:order][:ship_address_id]).user_id != try_harpiya_current_user&.id && raise('Frontend address forging')
+        else
+          params[:order].delete(:ship_address_id)
+        end
+
+        if params[:order][:bill_address_id].to_i > 0
+          params[:order].delete(:bill_address_attributes)
+
+          Harpiya::Address.find(params[:order][:bill_address_id]).user_id != try_harpiya_current_user&.id && raise('Frontend address forging')
+        else
+          params[:order].delete(:bill_address_id)
+        end
+      end
+
+      def normalize_addresses
+        return unless params[:state] == 'address' && @order.bill_address_id
+
+        if @order.checkout_steps.include?('delivery')
+          return unless @order.ship_address_id
+        end
+
+        bill_address = @order.bill_address
+        ship_address = @order.ship_address
+
+        if params[:save_user_address].present? && try_harpiya_current_user.present?
+          [bill_address, ship_address].each { |address| address&.update_attribute(:user_id, try_harpiya_current_user&.id) }
+        end
+
+        if @order.bill_address_id != @order.ship_address_id && bill_address == ship_address
+          @order.update_column(:bill_address_id, ship_address.id)
+          bill_address.destroy
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/harpiya/locale_urls.rb

@@ -0,0 +1,21 @@
+module Harpiya
+  module LocaleUrls
+    extend ActiveSupport::Concern
+
+    included do
+      before_action :redirect_to_default_locale
+    end
+
+    private
+
+    def default_url_options
+      super.merge(locale: locale_param, currency: currency_param)
+    end
+
+    def redirect_to_default_locale
+      return if params[:locale].blank? || supported_locale?(params[:locale])
+
+      redirect_to url_for(request.parameters.merge(locale: nil))
+    end
+  end
+end

data/app/controllers/harpiya/addresses_controller.rb

@@ -0,0 +1,64 @@
+# https://github.com/harpiya-contrib/harpiya_address_book/blob/master/app/controllers/harpiya/addresses_controller.rb
+module Harpiya
+  class AddressesController < Harpiya::StoreController
+    helper Harpiya::AddressesHelper
+    load_and_authorize_resource class: Harpiya::Address
+
+    def index
+      @addresses = try_harpiya_current_user.addresses
+    end
+
+    def create
+      @address = try_harpiya_current_user.addresses.build(address_params)
+      if @address.save
+        flash[:notice] = I18n.t(:successfully_created, scope: :address_book)
+        redirect_to harpiya.account_path
+      else
+        render action: 'new'
+      end
+    end
+
+    def edit
+      session['harpiya_user_return_to'] = request.env['HTTP_REFERER']
+    end
+
+    def new
+      @address = Harpiya::Address.new(country: current_store.default_country, user: try_harpiya_current_user)
+    end
+
+    def update
+      if @address.editable?
+        if @address.update(address_params)
+          flash[:notice] = Harpiya.t(:successfully_updated, scope: :address_book)
+          redirect_back_or_default(addresses_path)
+        else
+          render :edit
+        end
+      else
+        new_address = @address.clone
+        new_address.attributes = address_params
+        new_address.user_id = @address.user_id
+        @address.update_attribute(:deleted_at, Time.current)
+        if new_address.save
+          flash[:notice] = Harpiya.t(:successfully_updated, scope: :address_book)
+          redirect_back_or_default(addresses_path)
+        else
+          render :edit
+        end
+      end
+    end
+
+    def destroy
+      @address.destroy
+
+      flash[:notice] = Harpiya.t(:successfully_removed, scope: :address_book)
+      redirect_to(request.env['HTTP_REFERER'] || addresses_path) unless request.xhr?
+    end
+
+    private
+
+    def address_params
+      params.require(:address).permit(permitted_address_attributes)
+    end
+  end
+end

data/app/controllers/harpiya/checkout_controller.rb

@@ -0,0 +1,210 @@
+module Harpiya
+  # This is somewhat contrary to standard REST convention since there is not
+  # actually a Checkout object. There's enough distinct logic specific to
+  # checkout which has nothing to do with updating an order that this approach
+  # is waranted.
+  class CheckoutController < Harpiya::StoreController
+    include Harpiya::Checkout::AddressBook
+
+    before_action :set_cache_header, only: [:edit]
+    before_action :set_current_order
+    before_action :load_order_with_lock
+    before_action :ensure_valid_state_lock_version, only: [:update]
+    before_action :set_state_if_present
+
+    before_action :ensure_order_not_completed
+    before_action :ensure_checkout_allowed
+    before_action :ensure_sufficient_stock_lines
+    before_action :ensure_valid_state
+
+    before_action :associate_user
+    before_action :check_authorization
+
+    before_action :setup_for_current_state
+    before_action :add_store_credit_payments, :remove_store_credit_payments, only: [:update]
+
+    helper 'harpiya/orders'
+
+    rescue_from Harpiya::Core::GatewayError, with: :rescue_from_harpiya_gateway_error
+
+    layout 'harpiya/layouts/checkout'
+
+    # Updates the order and advances to the next state (when possible.)
+    def update
+      if @order.update_from_params(params, permitted_checkout_attributes, request.headers.env)
+        @order.temporary_address = !params[:save_user_address]
+        unless @order.next
+          flash[:error] = @order.errors.full_messages.join("\n")
+          redirect_to(harpiya.checkout_state_path(@order.state)) && return
+        end
+
+        if @order.completed?
+          @current_order = nil
+          flash['order_completed'] = true
+          redirect_to completion_route
+        else
+          redirect_to harpiya.checkout_state_path(@order.state)
+        end
+      else
+        render :edit
+      end
+    end
+
+    private
+
+    def unknown_state?
+      (params[:state] && !@order.has_checkout_step?(params[:state])) ||
+        (!params[:state] && !@order.has_checkout_step?(@order.state))
+    end
+
+    def insufficient_payment?
+      params[:state] == 'confirm' &&
+        @order.payment_required? &&
+        @order.payments.valid.sum(:amount) != @order.total
+    end
+
+    def correct_state
+      if unknown_state?
+        @order.checkout_steps.first
+      elsif insufficient_payment?
+        'payment'
+      else
+        @order.state
+      end
+    end
+
+    def ensure_valid_state
+      if @order.state != correct_state && !skip_state_validation?
+        flash.keep
+        @order.update_column(:state, correct_state)
+        redirect_to harpiya.checkout_state_path(@order.state)
+      end
+    end
+
+    # Should be overriden if you have areas of your checkout that don't match
+    # up to a step within checkout_steps, such as a registration step
+    def skip_state_validation?
+      false
+    end
+
+    def load_order_with_lock
+      @order = current_order(lock: true)
+      redirect_to(harpiya.cart_path) && return unless @order
+    end
+
+    def ensure_valid_state_lock_version
+      if params[:order] && params[:order][:state_lock_version]
+        changes = @order.changes if @order.changed?
+        @order.reload.with_lock do
+          unless @order.state_lock_version == params[:order].delete(:state_lock_version).to_i
+            flash[:error] = Harpiya.t(:order_already_updated)
+            redirect_to(checkout_state_path(@order.state)) && return
+          end
+          @order.increment!(:state_lock_version)
+        end
+        @order.assign_attributes(changes) if changes
+      end
+    end
+
+    def set_state_if_present
+      if params[:state]
+        redirect_to harpiya.checkout_state_path(@order.state) if @order.can_go_to_state?(params[:state]) && !skip_state_validation?
+        @order.state = params[:state]
+      end
+    end
+
+    def ensure_checkout_allowed
+      redirect_to harpiya.cart_path unless @order.checkout_allowed?
+    end
+
+    def ensure_order_not_completed
+      redirect_to harpiya.cart_path if @order.completed?
+    end
+
+    def ensure_sufficient_stock_lines
+      if @order.insufficient_stock_lines.present?
+        flash[:error] = Harpiya.t(:inventory_error_flash_for_insufficient_quantity)
+        redirect_to harpiya.cart_path
+      end
+    end
+
+    # Provides a route to redirect after order completion
+    def completion_route(custom_params = {})
+      harpiya.order_path(@order, custom_params.merge(locale: locale_param))
+    end
+
+    def setup_for_current_state
+      method_name = :"before_#{@order.state}"
+      send(method_name) if respond_to?(method_name, true)
+    end
+
+    def before_address
+      # if the user has a default address, a callback takes care of setting
+      # that; but if he doesn't, we need to build an empty one here
+      @order.bill_address ||= Address.new(country: current_store.default_country, user: try_harpiya_current_user)
+      @order.ship_address ||= Address.new(country: current_store.default_country, user: try_harpiya_current_user) if @order.checkout_steps.include?('delivery')
+    end
+
+    def before_delivery
+      return if params[:order].present?
+
+      packages = @order.shipments.map(&:to_package)
+      @differentiator = Harpiya::Stock::Differentiator.new(@order, packages)
+    end
+
+    def before_payment
+      if @order.checkout_steps.include? 'delivery'
+        packages = @order.shipments.map(&:to_package)
+        @differentiator = Harpiya::Stock::Differentiator.new(@order, packages)
+        @differentiator.missing.each do |variant, quantity|
+          Harpiya::Dependencies.cart_remove_item_service.constantize.call(order: @order, variant: variant, quantity: quantity)
+        end
+      end
+
+      @payment_sources = try_harpiya_current_user.payment_sources if try_harpiya_current_user&.respond_to?(:payment_sources)
+    end
+
+    def add_store_credit_payments
+      if params.key?(:apply_store_credit)
+        add_store_credit_service.call(order: @order)
+
+        # Remove other payment method parameters.
+        params[:order].delete(:payments_attributes)
+        params[:order].delete(:existing_card)
+        params.delete(:payment_source)
+
+        # Return to the Payments page if additional payment is needed.
+        redirect_to harpiya.checkout_state_path(@order.state) and return if @order.payments.valid.sum(:amount) < @order.total
+      end
+    end
+
+    def remove_store_credit_payments
+      if params.key?(:remove_store_credit)
+        remove_store_credit_service.call(order: @order)
+        redirect_to harpiya.checkout_state_path(@order.state) and return
+      end
+    end
+
+    def rescue_from_harpiya_gateway_error(exception)
+      flash.now[:error] = Harpiya.t(:harpiya_gateway_error_flash_for_checkout)
+      @order.errors.add(:base, exception.message)
+      render :edit
+    end
+
+    def check_authorization
+      authorize!(:edit, current_order, cookies.signed[:token])
+    end
+
+    def set_cache_header
+      response.headers['Cache-Control'] = 'no-store'
+    end
+
+    def add_store_credit_service
+      Harpiya::Dependencies.checkout_add_store_credit_service.constantize
+    end
+
+    def remove_store_credit_service
+      Harpiya::Dependencies.checkout_remove_store_credit_service.constantize
+    end
+  end
+end

data/app/controllers/harpiya/cms_pages_controller.rb

@@ -0,0 +1,29 @@
+module Harpiya
+  class CmsPagesController < Harpiya::StoreController
+    before_action :load_cms_page, only: [:show]
+
+    include Harpiya::FrontendHelper
+    include Harpiya::CacheHelper
+
+    def show
+      if @page&.visible?
+        @cms_page = @page
+      elsif @page&.draft_mode? && try_harpiya_current_user&.admin?
+        @cms_page = @page
+        @edit_mode = true
+      else
+        raise ActiveRecord::RecordNotFound
+      end
+    end
+
+    private
+
+    def accurate_title
+      @page&.seo_title || super
+    end
+
+    def load_cms_page
+      @page = Harpiya::CmsPage.by_store(current_store).by_locale(I18n.locale).find_by(slug: params[:slug])
+    end
+  end
+end

data/app/controllers/harpiya/content_controller.rb

@@ -0,0 +1,18 @@
+module Harpiya
+  class ContentController < Harpiya::StoreController
+    # Don't serve local files or static assets
+    after_action :fire_visited_path, except: :cvv
+
+    respond_to :html
+
+    def test; end
+
+    def cvv
+      render layout: false
+    end
+
+    def fire_visited_path
+      Harpiya::PromotionHandler::Page.new(current_order, params[:action]).activate
+    end
+  end
+end

data/app/controllers/harpiya/currency_controller.rb

@@ -0,0 +1,17 @@
+module Harpiya
+  class CurrencyController < StoreController
+    def set
+      new_currency = params[:switch_to_currency]&.upcase
+
+      if new_currency.present? && supported_currency?(new_currency)
+        current_order&.update(currency: new_currency)
+        session[:currency] = new_currency
+      end
+
+      respond_to do |format|
+        format.html { redirect_back fallback_location: harpiya.root_path(currency: new_currency) }
+        format.json { head :ok }
+      end
+    end
+  end
+end

data/app/controllers/harpiya/home_controller.rb

@@ -0,0 +1,46 @@
+module Harpiya
+  class HomeController < Harpiya::StoreController
+    include Harpiya::CacheHelper
+
+    before_action :load_homepage, only: [:index]
+
+    respond_to :html
+
+    def index
+      if @cms_home_page&.visible?
+        @homepage = @cms_home_page
+      elsif try_harpiya_current_user&.admin?
+        @homepage = @cms_home_page
+        @edit_mode = true
+      end
+
+      if http_cache_enabled?
+        fresh_when etag: store_etag, last_modified: last_modified_index, public: true
+      end
+    end
+
+    private
+
+    def etag_index
+      [
+        store_etag,
+        last_modified_index,
+      ]
+    end
+
+    def last_modified_index
+      page_last_modified = @cms_home_page&.maximum(:updated_at)&.utc if @cms_home_page.respond_to?(:maximum)
+      current_store_last_modified =current_store.updated_at.utc
+
+      [page_last_modified, current_store_last_modified].compact.max
+    end
+
+    def accurate_title
+      @cms_home_page&.seo_title || super
+    end
+
+    def load_homepage
+      @cms_home_page = current_store.homepage(I18n.locale)
+    end
+  end
+end