radiant-shop-extension 0.9.3 → 0.10.0

data/README.md

@@ -1,16 +1,22 @@
 # Radiant Shop
 
+ps: [wiki](http://github.com/squaretalent/radiant-shop-extension/wiki)
+
+pps: heavily under development means "it might not work out of the box after every commit"
+
+ppps: I am working on the wiki as quickly as I can, but specs are more important at this point in time
+
+pppps: love heart
+
 ## Checkout
 
 ### Form Configuration
 
     checkout:
       gateway:
-        name: PayWay
+        name: Eway
         username: 123456
         password: abcdef
-        merchant: test
-        pem: /var/www/certificate.pem
         
 # Development
 

data/Rakefile

@@ -7,6 +7,7 @@ begin
     gem.email = "dk@dirkkelly.com"
     gem.homepage = "http://github.com/squaretalent/radiant-shop-extension"
     gem.authors = ["Dirk Kelly", "John Barker"]
+    gem.add_dependency 'radiant',                     '>= 0.9.1'
     gem.add_dependency 'radiant-forms-extension',     '>= 3.1.0'
     gem.add_dependency 'radiant-images-extension',    '>= 0.2.0'
     gem.add_dependency 'radiant-layouts-extension',   '>= 0.9.1'

data/VERSION

@@ -1 +1 @@
-0.9.3
+0.10.0

data/app/controllers/admin/shop/customers_controller.rb

@@ -1,137 +1,46 @@
 class Admin::Shop::CustomersController < Admin::ResourceController
   model_class ShopCustomer
   
-  # GET /admin/shop/customers
-  # GET /admin/shop/customers.js
-  # GET /admin/shop/customers.xml
-  # GET /admin/shop/customers.json                                AJAX and HTML
-  #----------------------------------------------------------------------------
-  def index
-    @shop_customers = ShopCustomer.scoped_by_access("front").all
-    @shop_customer = ShopCustomer.scoped_by_access("front").new
-    attr_hash = {}
-    respond_to do |format|
-      format.html { render }
-      format.js { render :partial => '/admin/shop/customers/excerpt', :collection => @shop_customers }
-      format.xml { render :xml => @shop_customers.to_xml(attr_hash) }
-      format.json { render :json => @shop_customers.to_json(attr_hash) }
-    end
-  end
-  
-  # GET /admin/shop/customers/1
-  # GET /admin/shop/customers/1.js
-  # GET /admin/shop/customers/1.xml
-  # GET /admin/shop/customers/1.json                              AJAX and HTML
-  #----------------------------------------------------------------------------
-  def show
-    @shop_customer = ShopCustomer.scoped_by_access("front").find(params[:id])
-    attr_hash = {
-      :include => {:orders => {:only => [:id, :balance, :status, :created_at, :updated_at, :payment_id]} },
-      :only => [:id, :email, :reference, :created_at, :updated_at, :organization, :notes, :name, :login, :access]
-    }
-    respond_to do |format|
-      format.html { render }
-      format.js { render :partial => '/admin/shop/customers/customer', :locals => { :customer => @shop_customer } }
-      format.xml { render :xml => @shop_customer.to_xml(attr_hash) }
-      format.json { render :json => @shop_customer.to_json(attr_hash) }
-    end
-  end
+  before_filter :config_global
+  before_filter :config_new,    :only => [ :new, :create ]
+  before_filter :config_edit,   :only => [ :edit, :update ]
+  before_filter :assets_global
+  before_filter :assets_index,  :only => [ :index ]
+  before_filter :assets_edit,   :only => [ :edit, :update ]
   
-  # POST /admin/shop/customers
-  # POST /admin/shop/customers.js
-  # POST /admin/shop/customers.xml
-  # POST /admin/shop/customers.json                               AJAX and HTML
-  #----------------------------------------------------------------------------
-  def create
-    @shop_customer = ShopCustomer.new(params[:shop_customer])
+  private
     
-    if @shop_customer.save!
-      respond_to do |format|
-        format.html { 
-          flash[:notice] = "Customer created successfully."
-          redirect_to admin_shop_customers_path 
-        }
-        format.js { render :partial => '/admin/shop/customers/excerpt', :locals => { :excerpt => @shop_customer } }
-        format.xml { redirect_to "/admin/shop/customers/#{@shop_customer.id}.xml" }
-        format.json { redirect_to "/admin/shop/customers/#{@shop_customer.id}.json" }
-      end
-    else
-      respond_to do |format|
-        format.html { 
-          flash[:error] = "Unable to create new customer."
-          render
-        }
-        format.js { render :text => @shop_customer.errors.to_json, :status => :unprocessable_entity }
-        format.xml { render :xml => @shop_customer.errors.to_xml, :status => :unprocessable_entity }
-        format.json { render :json => @shop_customer.errors.to_json, :status => :unprocessable_entity }
-      end
+    def config_global
+      @meta     ||= []
+      @buttons  ||= []
+      @parts    ||= []
+      @popups   ||= []
     end
-  end
-  
-  # PUT /admin/shop/customers/1
-  # PUT /admin/shop/customers/1.js
-  # PUT /admin/shop/customers/1.xml
-  # PUT /admin/shop/customers/1.json                              AJAX and HTML
-  #----------------------------------------------------------------------------
-  def update
-    @shop_customer = ShopCustomer.find(params[:id])
-    if @shop_customer.update_attributes!(params[:shop_customer])
-      respond_to do |format|
-        format.html { 
-          flash[:notice] = "Customer updated successfully."
-          redirect_to admin_shop_customers_path 
-        }
-        format.js { render :partial => '/admin/shop/customers/excerpt', :locals => { :excerpt => @shop_customer } }
-        format.xml { redirect_to "/admin/shop/customers/#{@shop_customer.id}.xml" }
-        format.json { redirect_to "/admin/shop/customers/#{@shop_customer.id}.json" }
-      end
-    else
-      respond_to do |format|
-        format.html { 
-          flash[:error] = "Unable to update customer."
-          render
-        }
-        format.js { render :text => @shop_customer.errors.to_s, :status => :unprocessable_entity }
-        format.xml { render :xml => @shop_customer.errors.to_xml, :status => :unprocessable_entity }
-        format.json { render :json => @shop_customer.errors.to_json, :status => :unprocessable_entity }
-      end
+    
+    def config_new
+      @meta  << 'login'
+      @meta  << 'password'
+      @meta  << 'password_confirmation'
     end
-  end
-  
-  # DELETE /admin/shop/customers/1
-  # DELETE /admin/shop/customers/1.js
-  # DELETE /admin/shop/customers/1.xml
-  # DELETE /admin/shop/customers/1.json                           AJAX and HTML
-  #----------------------------------------------------------------------------
-  def destroy
-    # Need to rewrite this method to check for errors and return xml or json.
-    # For some reason the answer isn't obvious to me.
-    @shop_customer = ShopCustomer.find(params[:id])
     
-    if (@shop_customer && @shop_customer.orders.empty?)
-      @message = "Category deleted successfully."
-      @shop_customer.destroy
+    def config_edit
+      @meta  << 'login'
+      @meta  << 'password'
+      @meta  << 'password_confirmation'
       
-      respond_to do |format|
-        format.html {
-          flash[:notice] = @message
-          redirect_to admin_shop_categories_path
-        }
-        format.js { render :text => @message, :status => 200 }
-        format.xml  { render :xml => {:message => @message}, :status => 200 }
-        format.json  { render :json => {:message => @message}, :status => 200 }
-      end
-    else
-      @message = "Unable to delete category."
-      respond_to do |format|
-        format.html {
-          flash[:error] = @message
-        }
-        format.js { render :text => @message, :status => :unprocessable_entity }
-        format.xml  { render :xml => {:message => @message}, :status => :unprocessable_entity }
-        format.json  { render :json => {:message => @message}, :status => :unprocessable_entity }
-      end
+      @parts << 'orders'
+      @parts << 'addresses'
     end
-  end
-  
+    
+    def assets_global
+      include_stylesheet 'admin/extensions/shop/edit'
+      include_stylesheet 'admin/extensions/shop/index'
+    end
+    
+    def assets_index
+    end
+    
+    def assets_edit
+    end
+      
 end

data/app/controllers/shop/categories_controller.rb

@@ -14,8 +14,6 @@ class Shop::CategoriesController < ApplicationController
   # GET /shop/categories/:query.json                              AJAX and HTML
   #----------------------------------------------------------------------------
   def index
-    attr_hash = { :include  => :products, :only => ShopCategory.params }
-    
     @shop_categories = ShopCategory.search(params[:query])
     
     respond_to do |format|
@@ -30,11 +28,9 @@ class Shop::CategoriesController < ApplicationController
   # GET /shop/:handle.json                                        AJAX and HTML
   #----------------------------------------------------------------------------
   def show
-    attr_hash = { :include  => :products, :only => ShopCategory.params }
-    
     if @shop_category = ShopCategory.find(:first, :conditions => { :handle => params[:handle] })
       @title = @shop_category.name
-      @radiant_layout = @shop_category.layout.name
+      @radiant_layout = @shop_category.layout.name rescue (raise "Couldn't find Layout with id #{@shop_category.layout_id}")
 
       respond_to do |format|
         format.html { render }

data/app/controllers/shop/products_controller.rb

@@ -32,7 +32,7 @@ class Shop::ProductsController < ApplicationController
     if @shop_product = ShopProduct.find(:first, :conditions => { :sku => params[:sku] })
       @shop_category = @shop_product.category unless @shop_product.nil?
     
-      @radiant_layout = @shop_product.layout.name
+      @radiant_layout = @shop_product.layout.name rescue (raise "Couldn't find Layout with id #{@shop_product.layout_id}")
       @title = @shop_product.name
     
       respond_to do |format|

data/app/models/form_checkout.rb

@@ -1,245 +1,331 @@
 class FormCheckout
   include Forms::Models::Extension
   
+  attr_accessor :config, :data, :result, :gateway, :card, :billing, :shipping
+  
   def create
-    @result = {
-      :billing  => false,
-      :shipping => false,
-      :gateway  => false,
-      :card     => false,
-      :payment  => false
-    }
-    
-    @success= true
-    @order  = ShopOrder.find(@page.request[:session][:shop_order])
-    
-    if @config[:address].present?
-      # If the form was configured for address
-      build_addresses
-    end
-    
-    if @config[:gateway].present? and card
-      # If the form was configured for gateway
-      build_gateway
-      build_card
+    find_current_order # locate the @order object
+    
+    create_result_object # A default response object
+    
+    create_order_addresses # Create @order.billing and @order.shipping
+    
+    # If the form was configured for gateway and we have a billing address
+    if gateway.present?
+      prepare_gateway # Create the @gateway object
+      prepare_credit_card if card.present?# Create the @card object
       
-      purchase
-    end
+      if @result[:gateway] and @result[:card]
+        purchase! # Use @card to pay through @gateway
+      end
     
-    if @result[:payment]
-      @order.update_attribute(:status, 'paid')
+      # We have a paid for order with a billing address
+      if success?
+        # The form was configured to send a payment email
+        if mail.present?
+          configure_invoice_mail # Create some configuration variables for mailing
+        end
+      else
+        @form.redirect_to = :back
+      end
     end
-    
     @result
   end
   
   private
-  
+    
+    # Uses the page session data to find the current order
+    def find_current_order
+      @order  = ShopOrder.find(@page.request.session[:shop_order])
+    end
+    
+    def create_result_object
+      @result = {
+        :order    => @order.id, # We return the order id so the thank you screen has access to it
+        :billing  => @order.billing.present?,
+        :shipping => @order.shipping.present?,
+        :payment  => false,
+        :card     => false,
+        :gateway  => false,
+        :message  => nil,
+      }
+    end
+    
     # Assigns a shipping and billing address to the @order
-    def build_addresses
+    def create_order_addresses
       if billing.present?
         # We're going to create a billing object
-        build_billing_address
-      
-        unless shipping.present? and @billing.valid?
-          # We're going to assign shipping to billing
+        create_order_billing_address
+        
+        # We're going to assign shipping to billing because they didn't send shipping
+        if !shipping.present? and @billing.present?
           @shipping = @billing
           @order.update_attribute(:shipping_id, @shipping.id)
         end
       end
       
       if shipping.present?
-        build_shipping_address
+        create_order_shipping_address
       end
       
-      @result[:billing]  = @order.billing.present? ? @order.billing : false
-      @result[:shipping] = @order.shipping.present? ? @order.shipping : false
-      
-      unless @order.billing.present? and @order.shipping.present?
+      if @order.billing.nil?
         @form.redirect_to = :back
       end
+      
+      @result[:billing]  = @order.billing.present?
+      @result[:shipping] = @order.shipping.present?
     end
     
-    def build_billing_address
+    # Attaches a billing address to the order (and current customer)
+    def create_order_billing_address
       # Billing Address
-      if billing['id'].present?
-        # Use an existing Address and update its values
-        @billing = ShopAddress.find(billing['id'])
-        @billing.update_attributes(billing)
-        @order.update_attribute(:billing_id, @billing.id)
-
+      if billing[:id]
+        begin
+          # Use an existing Address and update its values
+          @billing = current_customer.billings.find(billing[:id])
+          @billing.update_attributes(billing)
+          @order.update_attribute(:billing_id, @billing.id)
+        rescue
+          # We cant find that address for that user
+        end
+        
       elsif @order.billing.present?
         # Use the current billing and update its values
         @billing = @order.billing
         @billing.update_attributes(billing)
-        
+      
       else
         # Create a new address with these attributes
         @billing = ShopAddress.new(billing)
         if @billing.save
           @order.update_attribute(:billing_id, @billing.id)
         end
-
+        
       end
+      
     end
     
-    def build_shipping_address
+    # Attaches a shipping address to the order (and current customer)
+    def create_order_shipping_address
       # Shipping Address
-      if shipping['id'].present?
+      
+      if shipping[:id]
         # Use an existing Address and update its values
-        @shipping = ShopAddress.find(shipping['id'])
-        if @shipping == @billing and shipping == billing
-          # We have exactly the same shipping and billing data
-          @shipping = @billing
-          @order.update_attribute(:shipping_id, @billing.id)
-        elsif (shipping.reject!{|k,v|k=='id'}).values.all?(&:blank?)
-          # We have just passed the id and not the data
-          @order.update_attribute(:shipping_id, @shipping.id)
-        elsif @shipping == @billing and shipping != billing
-          # We have conflicting data so create a new address
-          # the id is rejected so we'll get a new address
-          @order.update_attributes!({ :shipping_attributes => shipping })
-          @shipping = @order.shipping
+        begin
+          @shipping = current_customer.shippings.find(shipping[:id])
+          if @shipping == @billing and shipping == billing
+            # We have exactly the same shipping and billing data
+            @shipping = @billing
+            @order.update_attribute(:shipping_id, @billing.id)
+            
+          elsif (shipping.reject!{|k,v| k == :id }).values.all?(&:blank?)
+            # We have just passed the id and not the data
+            @order.update_attribute(:shipping_id, @shipping.id)
+            
+          elsif @shipping == @billing and shipping != billing
+            # We have conflicting data so create a new address
+            # the id is rejected so we'll get a new address
+            @order.update_attributes!({ :shipping_attributes => shipping })
+            @shipping = @order.shipping
+          end
+        rescue
+          # We cant find that address for that customer
         end
         
       elsif @order.shipping.present?
         # Use the current shipping and update its values
         @shipping = @order.shipping
         @shipping.update_attributes(shipping)
-        
+      
       elsif shipping.values.all?(&:blank?) or shipping == billing
         # We haven't set a shipping, or we have copied billing, so use billing
         @shipping = @billing
         @order.update_attribute(:shipping_id, @billing.id)
-        
+      
       else
         # Create a new address with these attributes
         @order.update_attributes!({ :shipping_attributes => shipping })
         @shipping = @order.shipping
       end
     end
-
+    
     # Creates a gateway instance variable based off the form configuration
-    def build_gateway
-      ActiveMerchant::Billing::Base.mode = :test if testing
-      
+    def prepare_gateway
+      ActiveMerchant::Billing::Base.mode = gateway_mode
       begin
-        @gateway = ActiveMerchant::Billing.const_get("#{gateway}Gateway").new(gateway_credentials)
+        @gateway = ActiveMerchant::Billing.const_get("#{gateway_name}Gateway").new(gateway_credentials)
         @result[:gateway] = true
       end
     end
-
+    
+    # Creates a payment object attached to the order
+    def create_payment
+      payment = ShopPayment.new({
+        :order      => @order,
+        :gateway    => gateway_name,
+        :amount     => @order.price,
+        :card_type  => card_type,
+        :card_number=> card_number_secure
+      })
+      
+      @order.update_attribute(:status, 'paid')
+      
+      @result[:payment] = payment.save
+    end
+    
     # Builds an ActiveMerchant card using the submitted card information
-    def build_card
-      if card.present?
-        @card = ActiveMerchant::Billing::CreditCard.new({
-          :number             => card_number,
-          :month              => card_month,
-          :year               => card_year,
-          :first_name         => card_first_name,
-          :last_name          => card_last_name,
-          :verification_value => card_verification,
-          :type               => card_type
-        })
-        
-        @result[:card] = {
-          :valid  => @card.valid?
-        }
-      end
+    def prepare_credit_card
+      @card = ActiveMerchant::Billing::CreditCard.new({
+        :number             => card_number,
+        :month              => card_month,
+        :year               => card_year,
+        :first_name         => card_first_name,
+        :last_name          => card_last_name,
+        :verification_value => card_verification,
+        :type               => card_type
+      })
+      
+      @result[:card] = @card.valid?
     end
     
-    def purchase
+    # Sets up mail to send an invoice to the billing email address
+    def configure_invoice_mail
+      @form[:extensions][:mail] ||= {}
+      @form[:extensions][:mail].merge!({
+        :recipient  => @order.billing.email,
+        :to         => @order.billing.email,
+      })
+      @form[:extensions][:mail].merge!(mail)
+    end
+    
+    # Uses the gateway and card objects to carry out an ActiveMerchant purchase
+    def purchase!
       result = @gateway.purchase(amount, @card, options)
       
-      @result[:payment] = {
-        :success  => result.success?,
-        :message  => result.message
-      }
+      @result[:message] = result.message
       
-      unless result.success?
-        @form.redirect_to = :back
+      if result.success?
+        create_payment
       end
     end
     
-    def success?
-      @success
-    end
-  
-    def testing
-      @config[:test].present?
+    # Returns the current logged in ShopCustomer (if it exists)
+    def current_customer
+      return @shop_customer if @shop_customer.present?
+      return current_user if current_user.present?
+      @shop_customer = ShopCustomer.find(current_user.id)
     end
     
+    # Returns an array of billing attributes
     def billing
-      billing   = @data['billing'] # Array of billing attributes      
+      @data[:billing]
     end
     
+    # Returns an array of shipping attributes
     def shipping
-      shipping  = @data['shipping'] # Array of shipping attributes      
+      @data[:shipping]
     end
     
+    # Returns the configured gateway
     def gateway
-      @config[:gateway][:name]
+      @config[:gateway]
+    end
+    
+    # Returns the name of the gateway (Eway)
+    def gateway_name
+      gateway[:name]
     end
     
+    # Returns Gateway username and password etc
     def gateway_credentials
-      @config[:gateway][:credentials]
+      gateway[:credentials]
     end
     
+    # Returns whether the form is configured as testing or production
+    def gateway_mode
+      @config[:test].present? ? :test : :production
+    end
+    
+    # Returns the submitted card attributes
     def card
-      @data['card']
+      @data[:card]
     end
     
+    # Returns card number (1234123412341234)
     def card_number
-      card['number'].to_s.gsub('-', '').to_i
+      card[:number].to_s.gsub('-', '')
+    end
+    
+    # Returns the last 4 card number digits (1234)
+    def card_number_secure
+      @card.display_number
     end
     
+    # Returns card month (02)
     def card_month
-      card['month'].to_i
+      card[:month].to_i
     end
     
+    # Returns card year (2010)
     def card_year
-      card['year'].to_i
+      card[:year].to_i
     end
     
+    # Returns card type (visa)
     def card_type
-      card['type']
+      card[:type]
     end
     
+    # Returns card verification number (123)
     def card_verification
-      card['verification']
+      card[:verification].to_s
     end
     
+    # Splits the card names into an array we can inspect
     def card_names
       return @card_names if @card_names.present?
-      @card_names = @data['card']['name'].split(' ')
+      @card_names = @data[:card][:name].split(' ')
     end
     
+    # Return all the strings bar the last on the card
     def card_first_name
       card_names[0, card_names.length - 1].join(' ') if card_names.present?
     end
     
+    # Return the last string on the card
     def card_last_name
       card_names[-1] if card_names.present?
     end
     
+    # Returns configured mail attributes
+    def mail
+      @config[:mail]
+    end
+    
+    # Returns the amount to be charged, which is $10 on testing gateways
     def amount
       result = 0
-      
-      if testing
+      if gateway_mode === :test
         result = 1000
       else
         result = (@order.price * 100)
       end
-      
       result
     end
     
+    # Options for the gateway are created at config and runtime level
     def options
       @config[:options] ||= {}
       
       @config[:options][:order_id] = @order.id
-      
+      @config[:options].merge!(@data[:options]) if @data[:options].present?
+            
       @config[:options]
     end
     
+    # Will return true if the order is paid for and has a billing address
+    def success?
+      @result[:payment] and @result[:billing]
+    end
+    
 end