gemgento 2.8.0

data/app/controllers/gemgento/user/home_controller.rb

@@ -0,0 +1,9 @@
+module Gemgento
+  class User::HomeController < User::BaseController
+
+    def index
+
+    end
+
+  end
+end

data/app/controllers/gemgento/user/orders_controller.rb

@@ -0,0 +1,17 @@
+module Gemgento
+  class User::OrdersController < User::BaseController
+
+    def index
+      @orders = current_user.orders.where.not(status: [nil, '']).order('created_at DESC')
+
+      respond_with @orders
+    end
+
+    def show
+      @order = Order.find_by(increment_id: params[:id], user: current_user)
+
+      respond_with @order
+    end
+
+  end
+end

data/app/controllers/gemgento/user/passwords_controller.rb

@@ -0,0 +1,18 @@
+module Gemgento
+  class User::PasswordsController < Devise::PasswordsController
+
+    protected
+
+    # The path used after sending reset password instructions
+    def after_sending_reset_password_instructions_path_for(resource_name)
+      if is_navigational_format?
+        if Config[:combined_shipping_payment]
+          user_new_login_path
+        else
+          new_session_path(resource_name)
+        end
+      end
+    end
+
+  end
+end

data/app/controllers/gemgento/user/recurring_profiles_controller.rb

@@ -0,0 +1,31 @@
+module Gemgento
+  class User::RecurringProfilesController < User::BaseController
+
+    def index
+      @recurring_profile = RecurringProfile.where(user: current_user)
+    end
+
+    def destroy
+      recurring_profile = RecurringProfile.find_by!(id: params[:id], user: current_user)
+
+      respond_to do |format|
+        result = recurring_profile.change_state('cancel')
+
+        if result == true
+          format.json { render json: { status: true } }
+          format.html do
+            flash[:notice] = 'The recurring profile has been canceled.'
+            redirect_to action: 'index'
+          end
+        else
+          format.json { render json: { errors: result }, status: 422 }
+          format.html do
+            flash[:warning] = result
+            redirect_to action: 'index'
+          end
+        end
+      end
+    end
+
+  end
+end

data/app/controllers/gemgento/user/registration_session_controller.rb

@@ -0,0 +1,103 @@
+module Gemgento
+  class User::RegistrationSessionController < User::BaseController
+    prepend_before_filter :require_no_authentication
+
+    skip_before_filter :auth_user
+    before_filter :set_user_instances
+
+    respond_to :json, :html
+
+    def new
+      @existing_user = User.new
+      @new_user = User.new
+    end
+
+    def create
+      case params[:activity]
+        when 'sign_in'
+          create_session
+        when 'register'
+          create_registration
+        else
+          raise "Unknown action - #{params[:activity]}"
+      end
+    end
+
+    private
+
+    def set_user_instances
+      @existing_user = User.new
+      @new_user = User.new
+    end
+
+    def create_session
+      @existing_user = User::is_valid_login(user_session_params[:email], user_session_params[:password])
+      result = false
+
+      unless @existing_user.nil?
+        sign_in(:user, @existing_user)
+        result = true
+      end
+
+      respond_to do |format|
+        if result
+          format.html { redirect_to after_sign_in_path }
+          format.json { render json: { result: true, user: current_user } }
+        else
+          @existing_user = User.new(email: user_session_params[:email])
+          flash.keep[:error] = 'Invalid username and password'
+
+          format.html { render 'new' }
+          format.json do
+            render json: {
+                result: false,
+                errors: 'Invalid username and password',
+            }
+          end
+        end
+      end
+    end
+
+    def create_registration
+      @new_user = User.new(user_registration_params)
+      @new_user.stores << current_store
+      @new_user.user_group = UserGroup.where(code: 'General').first
+
+      respond_to do |format|
+        if @new_user.save
+          sign_in(:user, @new_user)
+          Subscriber.add_user(@new_user) if params[:subscribe]
+
+          format.html { redirect_to after_register_path }
+          format.json { render json: { result: true, user: @new_user, order: current_quote } }
+        else
+          format.html { render 'new' }
+          format.json { render json: { result: false, errors: @new_user.errors.full_messages, order: current_quote } }
+        end
+      end
+    end
+
+    def user_session_params
+      params.require(:user).permit(:email, :password)
+    end
+
+    def user_registration_params
+      params.require(:user).permit(:first_name, :last_name, :email, :password, :password_confirmation)
+    end
+
+    def after_sign_in_path
+      session[:return_to] || edit_user_registration_path
+    end
+
+    def after_register_path
+      session[:return_to] || edit_user_registration_path
+    end
+
+    def require_no_authentication
+      if user_signed_in?
+        redirect_to after_sign_in_path, alert: 'Already signed in.'
+      end
+    end
+
+  end
+end

data/app/controllers/gemgento/user/registrations_controller.rb

@@ -0,0 +1,28 @@
+module Gemgento
+  class User::RegistrationsController < Devise::RegistrationsController
+    # POST /resource
+    def create
+      build_resource(sign_up_params)
+      resource.stores << current_store unless resource.stores.include? current_store
+      resource.user_group = UserGroup.find_by(code: 'General')
+      resource.sync_needed = true
+
+      if resource.save
+        yield resource if block_given?
+        if resource.active_for_authentication?
+          set_flash_message :notice, :signed_up if is_flashing_format?
+          sign_up(resource_name, resource)
+          respond_with resource, location: after_sign_up_path_for(resource)
+        else
+          set_flash_message :notice, :"signed_up_but_#{resource.inactive_message}" if is_flashing_format?
+          expire_data_after_sign_in!
+          respond_with resource, location: after_inactive_sign_up_path_for(resource)
+        end
+      else
+        clean_up_passwords resource
+        respond_with resource
+      end
+    end
+
+  end
+end

data/app/controllers/gemgento/user/saved_credit_cards_controller.rb

@@ -0,0 +1,56 @@
+module Gemgento
+  class User::SavedCreditCardsController < User::BaseController
+
+    def index
+      @saved_credit_cards = current_user.saved_credit_cards
+    end
+
+    def new
+      @saved_credit_card = SavedCreditCard.new(user: current_user)
+      @saved_credit_card.build_address(country: Gemgento::Country.find_by(iso2_code: 'us'))
+    end
+
+    def create
+      @saved_credit_card = SavedCreditCard.new(saved_credit_card_params)
+      @saved_credit_card.user = current_user
+
+      respond_to do |format|
+        if @saved_credit_card.save
+          format.html { redirect_to user_saved_credit_cards_path, notice: 'Saved credit card successfully created.' }
+          format.json { render json: { result: true } }
+        else
+          format.html { render 'new' }
+          format.json { render json: { result: false, errors: @saved_credit_card.errors.full_messages }, status: 422 }
+        end
+      end
+    end
+
+    def destroy
+      @saved_credit_card = SavedCreditCard.find_by(user: current_user, id: params[:id])
+
+      respond_to do |format|
+        if @saved_credit_card.destroy
+          format.html { redirect_to user_saved_credit_cards_path, notice: 'Saved credit card successfully destroyed.' }
+          format.json { render json: { result: true } }
+        else
+          format.html { redirect_to user_saved_credit_cards_path, alert: 'Saved credit card could not be destroyed.' }
+          format.json { render json: { result: false, errors: @saved_credit_card.errors.full_messages }, status: 422 }
+        end
+      end
+    end
+
+    private
+
+    def saved_credit_card_params
+      params.require(:saved_credit_card).permit(
+          :id, :cc_type, :cc_number, :exp_month, :exp_year, :cc_cid,
+          address_attributes:
+              [
+                  :id, :first_name, :last_name, :address1, :address2, :country_id, :city, :region_id, :postcode,
+                  :telephone
+              ],
+      )
+    end
+
+  end
+end

data/app/controllers/gemgento/user/sessions_controller.rb

@@ -0,0 +1,50 @@
+module Gemgento
+  class User::SessionsController < Devise::SessionsController
+    respond_to :html, :json
+    prepend_before_filter :convert_magento_password, only: :create
+
+    # POST /resource/sign_in
+    def create
+      self.resource = warden.authenticate!(auth_options)
+      set_flash_message(:notice, :signed_in) if is_flashing_format?
+      sign_in(resource_name, resource)
+      yield resource if block_given?
+
+      respond_to do |format|
+        format.html { respond_with resource, location: after_sign_in_path_for(resource) }
+        format.json do
+          render json: {
+              result: true,
+              user: resource,
+              csrfParam: request_forgery_protection_token,
+              csrfToken: form_authenticity_token
+          }
+        end
+      end
+    end
+
+    # DELETE /resource/sign_out
+    def destroy
+      redirect_path = after_sign_out_path_for(resource_name)
+      signed_out = (Devise.sign_out_all_scopes ? sign_out : sign_out(resource_name))
+      set_flash_message :notice, :signed_out if signed_out && is_navigational_format?
+
+      # reset the current quote when user logs out, the current quotes persists between user sessions.
+      current_quote.reset unless current_quote.new_record?
+
+      # We actually need to hardcode this as Rails default responder doesn't
+      # support returning empty response on GET request
+      respond_to do |format|
+        format.all { head :no_content }
+        format.any(*navigational_formats) { redirect_to redirect_path }
+      end
+    end
+
+    private
+
+    def convert_magento_password
+      User.is_valid_login params[:user][:email], params[:user][:password]
+    end
+
+  end
+end

data/app/controllers/gemgento/user/wishlist_items_controller.rb

@@ -0,0 +1,55 @@
+module Gemgento
+  class User::WishlistItemsController < User::BaseController
+    prepend_before_action :set_return_to
+
+    before_action :authenticate_user!
+
+    def index
+      @wishlist_items = current_user.wishlist_items
+      respond_with @wishlist_items
+    end
+
+    def create
+      @wishlist_item = current_user.wishlist_items.new(wishlist_item_params)
+
+      respond_to do |format|
+        if @wishlist_item.save
+          format.html { redirect_to user_wishlist_items_path, notice: "Item sucessfully added to wishlist." }
+          format.json { render json: { result: true, wishlist_item: @wishlist_item } }
+        else
+          format.html { redirect_to user_wishlist_items_path }
+          format.json { render json: { result: false, errors: @wishlist_item.errors.full_messages } }
+        end
+      end
+    end
+
+    def destroy
+      @wishlist_item = current_user.wishlist_items.find(params[:id])
+
+      respond_to do |format|
+        if @wishlist_item.destroy
+          format.html { redirect_to user_wishlist_items_path , notice: "Wishlist item removed." }
+          format.json { render json: { result: true } }
+        else
+          format.html { render user_wishlist_items_path, alert: 'Unable to remove item from wishlist' }
+          format.json { render json: { result: false, errors: @wishlist_item.errors.full_messages } }
+        end
+      end
+    end
+
+    private
+
+    def set_return_to
+      if user_signed_in?
+        session.delete(:return_to)
+      elsif params[:wishlist_item]
+        return_params = { wishlist_item: params[:wishlist_item] }.to_query
+        session[:return_to] = "#{request.fullpath}/add?#{return_params}"
+      end
+    end
+
+    def wishlist_item_params
+      params.require(:wishlist_item).permit(:product_id)
+    end
+  end
+end

data/app/controllers/gemgento/users_controller.rb

@@ -0,0 +1,36 @@
+module Gemgento
+  class UsersController < ApplicationController
+    before_filter :auth_user, except: [:update, :index]
+
+    respond_to :json, :html
+
+    def index
+      @user = current_user
+
+      respond_to do |format|
+        format.html
+        format.json { render json: @user.as_json({ store: current_store }) }
+      end
+    end
+
+    def show
+      @user = current_user
+
+      respond_to do |format|
+        format.html
+        format.json { render json: @user.as_json({ store: current_store }) }
+      end
+    end
+
+    private
+
+    def auth_user
+      redirect_to new_user_session_path unless user_signed_in?
+    end
+
+    def user_params
+      params.require(:user).permit(:first_name, :last_name, :email, :middle_name, :prefix, :suffix, :password, :password_confirmation)
+    end
+
+  end
+end

data/app/helpers/gemgento/application_helper.rb

@@ -0,0 +1,125 @@
+module Gemgento
+  module ApplicationHelper
+
+    def set_store
+      session[:store_id] = Store.current.id if session[:store_id].nil?
+    end
+
+    def current_store
+      @current_store ||= begin
+        if session[:store_id].nil?
+          Store.current
+        else
+          Store.find(session[:store_id])
+        end
+      end
+    end
+
+    def current_quote
+      @current_quote ||= Quote.current(current_store, session[:quote], current_user) if @current_quote.nil?
+      session[:quote] = @current_quote.id
+      return @current_quote
+    end
+
+    def current_category
+      @current_category ||= begin
+        if @category
+          @category
+
+        elsif @product
+          @product.current_category
+
+        else
+          Gemgento::Category.root
+        end
+      end
+    end
+
+    def not_found
+      raise ActiveRecord::RecordNotFound
+    end
+
+    # Determine if a given category is the current category or a child.
+    #
+    # @param c [Gemgento::Category]\
+    # @return [Boolean]
+    def nav_category_is_active(c)
+      @curent_category == c or @current_category.children.include?(c)
+    end
+
+    def set_layout(html_layout = nil, pjax_layout = false)
+      html_layout = Config[:layout] if html_layout.nil?
+
+      if request.url # Check if we are redirected
+        response.headers['X-PJAX-URL'] = request.url
+      end
+
+      if request.headers['X-PJAX']
+        pjax_layout
+      elsif request.format == 'json'
+        false
+      else
+        html_layout
+      end
+    end
+
+    def json_options
+      @json_options ||= {
+          include_products: params[:include_products] ||= false,
+          include_simple_products: params[:include_simple_products] ||= false,
+          active: params[:active] ||= true
+      }
+    end
+
+    def product_asset(product, asset_type_code)
+      asset = Gemgento::Asset.find_by_code(product, asset_type_code)
+
+      if asset.nil? && product.magento_type == 'simple' && product.configurable_products.active.any? # check the configurable if the simple doesn't have images.
+        asset = Gemgento::Asset.find_by_code(product.configurable_products.active.first, asset_type_code)
+      elsif asset.nil?
+        asset = product.assets.first.image
+      end
+
+      return asset
+    end
+
+    # Get the product price for the given session
+    #
+    # @param product [Gemgento::Product]
+    # @param quantity [Float]
+    # @return [BigDecimal]
+    def product_price(product, quantity = 1.0)
+      user_group = current_user ? current_user.user_group : nil
+      product.price(user_group, current_store, quantity)
+    end
+
+    # Determine if a product is on sale in the given session.
+    #
+    # @param product [Gemgento::Product]
+    # @param quantity [Float]
+    # @return [Boolean]
+    def product_on_sale?(product, quantity = 1.0)
+      user_group = current_user ? current_user.user_group : nil
+      product.magento_type != 'giftvoucher' && product.on_sale?(user_group, current_store, quantity)
+    end
+
+    # Get a breadcrumb trail from root to current category, not including root.
+    #
+    # @param category [Gemgento::Category]
+    # @param separator [String]
+    # @param link_options [Hash] options hash for link_to
+    def breadcrumbs(category, separator = '/', link_options = {})
+      breadcrumbs = ''
+      trail = category.heirarchy
+      trail << category
+
+      trail.each do |parent|
+        breadcrumbs += " #{separator} " unless breadcrumbs.blank? # don't add separator to first link
+        breadcrumbs += link_to(parent.name, category_path(parent), link_options)
+      end
+
+      return breadcrumbs
+    end
+
+  end
+end