glysellin 0.4.1

data/app/controllers/glysellin/cart/discount_code_controller.rb

@@ -0,0 +1,10 @@
+module Glysellin
+  module Cart
+    class DiscountCodeController < CartController
+      def update
+        current_cart.discount_code = params[:code]
+        render json: totals_hash
+      end
+    end
+  end
+end

data/app/controllers/glysellin/cart/payment_method_controller.rb

@@ -0,0 +1,17 @@
+module Glysellin
+  module Cart
+    class PaymentMethodController < CartController
+      def update
+        current_cart.update(params[:glysellin_cart_basket])
+
+        if current_cart.valid?
+          current_cart.payment_method_chosen!
+          redirect_to cart_path
+        else
+          current_cart.state = "choose_payment_method"
+          render "glysellin/cart/show"
+        end
+      end
+    end
+  end
+end

data/app/controllers/glysellin/cart/products_controller.rb

@@ -0,0 +1,37 @@
+module Glysellin
+  module Cart
+    class ProductsController < CartController
+      def create
+        current_cart.add(params[:cart])
+        current_cart.products_added!
+        @product_added_to_cart = true
+        render_cart_partial
+      end
+
+      def update
+        current_cart.set_quantity(params[:id], params[:quantity], override: true)
+
+        product = current_cart.product(params[:id])
+        variant, quantity = product.variant, product.quantity
+
+        render json: {
+          quantity: quantity,
+          eot_price: number_to_currency(quantity * variant.eot_price),
+          price: number_to_currency(quantity * variant.price)
+        }.merge(totals_hash)
+      end
+
+      def destroy
+        current_cart.remove(params[:id])
+        redirect_to cart_path
+      end
+
+      def validate
+        current_cart.update(params[:glysellin_cart_basket])
+        current_cart.validated! if current_cart.valid?
+        current_cart.customer = current_user
+        redirect_to cart_path
+      end
+    end
+  end
+end

data/app/controllers/glysellin/cart/shipping_method_controller.rb

@@ -0,0 +1,18 @@
+module Glysellin
+  module Cart
+    class ShippingMethodController < CartController
+      def update
+        current_cart.update(params[:glysellin_cart_basket])
+
+        if current_cart.valid?
+          current_cart.shipping_method_chosen!
+          redirect_to cart_path
+        else
+          current_cart.state = "choose_shipping_method"
+          current_cart.valid?
+          render "glysellin/cart/show"
+        end
+      end
+    end
+  end
+end

data/app/controllers/glysellin/cart/state_controller.rb

@@ -0,0 +1,15 @@
+module Glysellin
+  module Cart
+    class StateController < CartController
+      def show
+        state = params[:state]
+
+        if current_cart.available_states.include?(state)
+          current_cart.state = state.to_sym
+        end
+
+        redirect_to cart_path
+      end
+    end
+  end
+end

data/app/controllers/glysellin/cart_controller.rb

@@ -0,0 +1,53 @@
+module Glysellin
+  class CartController < ApplicationController
+    include ActionView::Helpers::NumberHelper
+
+    before_filter :set_cart
+    after_filter :update_cart_in_session
+
+    def show
+      current_cart.update_quantities!
+    end
+
+    def destroy
+      reset_cart!
+      redirect_to cart_path
+    end
+
+    protected
+
+    def render_cart_partial
+      render partial: 'cart', locals: { cart: current_cart }
+    end
+
+    def set_cart
+      @states = current_cart.available_states
+    end
+
+    # Helper method to set cookie value
+    def update_cart_in_session options = {}
+      if current_cart.errors.any?
+        flash[:error] =
+          t("glysellin.errors.cart.state_transitions.#{ current_cart.state }")
+      end
+
+      session["glysellin.cart"] = current_cart.serialize
+    end
+
+    def totals_hash
+      adjustment = current_cart.discount
+
+      discount_name = adjustment.name rescue nil
+      discount_value = number_to_currency(adjustment.value) rescue nil
+
+      {
+        discount_name: discount_name,
+        discount_value: discount_value,
+        total_eot_price: number_to_currency(current_cart.total_eot_price),
+        total_price: number_to_currency(current_cart.total_price),
+        eot_subtotal: number_to_currency(current_cart.eot_subtotal),
+        subtotal: number_to_currency(current_cart.subtotal)
+      }
+    end
+  end
+end

data/app/controllers/glysellin/orders_controller.rb

@@ -0,0 +1,53 @@
+module Glysellin
+  class OrdersController < ApplicationController
+    protect_from_forgery :except => :gateway_response
+
+    def index
+      @orders = Order.from_customer(current_user)
+    end
+
+    def show
+      user_order = if user_signed_in?
+        Order.where('id = ? AND customer_id = ?', params[:id], current_user.id)
+      else
+        []
+      end
+
+      if user_order.length > 0
+        @order = user_order.first
+      else
+        flash[:alert] = t('glysellin.controllers.errors.order_doesnt_exist')
+        redirect_to :action => 'index'
+      end
+    end
+
+    def gateway_response
+      # Get gateway object
+      gateway = if params[:id]
+        PaymentMethod.gateway_from_order_ref(params[:id])
+      else
+        PaymentMethod.gateway_from_raw_post(request.raw_post, params[:gateway])
+      end
+      # Process payment
+      if gateway.process_payment! request.raw_post
+        OrderCustomerMailer.send_order_paid_email(gateway.order).deliver
+        OrderAdminMailer.send_order_paid_email(gateway.order).deliver
+      end
+      # Log errors if existing
+      gateway.errors.each do |msg|
+        logger.error "[ Glysellin ] Gateway Error : #{ msg }"
+      end if gateway.errors.length > 1
+
+      render gateway.response
+    end
+
+    def payment_response
+      if params[:type]
+        @order = nil
+        @response_type = params[:type]
+      else
+        @order = Order.find_by_ref(params[:id])
+      end
+    end
+  end
+end

data/app/controllers/glysellin/products_controller.rb

@@ -0,0 +1,12 @@
+module Glysellin
+  class ProductsController < ApplicationController
+    def index
+      @products = Glysellin::Product.order('created_at DESC').limit(10)
+      @products = @products.with_taxonomy(params[:taxonomy_id]) if params[:taxonomy_id]
+    end
+
+    def show
+      @product = Glysellin::Product.find(params[:id])
+    end
+  end
+end

data/app/helpers/glysellin/application_helper.rb

@@ -0,0 +1,4 @@
+module Glysellin
+  module ApplicationHelper
+  end
+end

data/app/helpers/glysellin/cart_helper.rb

@@ -0,0 +1,21 @@
+module Glysellin
+  module CartHelper
+    def add_to_cart_form product, options = {}
+      # Default to remote form
+      options[:remote] = true unless options[:remote] == false
+      # Render actual form
+      render partial: 'glysellin/products/add_to_cart', locals: {
+        product: product,
+        options: options
+      }
+    end
+
+    def added_to_cart_warning
+      render partial: 'glysellin/cart/added_to_cart_warning'
+    end
+
+    def render_cart cart
+      render partial: "glysellin/cart/cart", locals: { cart: cart }
+    end
+  end
+end

data/app/helpers/glysellin/orders_helper.rb

@@ -0,0 +1,35 @@
+module Glysellin
+  module OrdersHelper
+
+    # Generates Orderer form fields
+    #
+    # @param form Form object to which the fields are added
+    # @param record Optional model object that implements Glysellin::Orderer
+    #
+    def addresses_fields_for form, record = nil
+      # Copy addresses from record to form object
+      if record
+        %w(billing_address shipping_address).each do |addr|
+          if (address = record.send("#{ addr }"))
+            attrs = address.attributes.select do |key, value|
+              Glysellin::Address.accessible_attributes.include?(key)
+            end
+          end
+
+          unless (address = form.object.send(addr).presence) && address.id.present?
+            form.object.send("#{ addr }=", Glysellin::Address.new(attrs))
+          end
+        end
+
+        unless form.object.use_another_address_for_shipping.present?
+          form.object.use_another_address_for_shipping = record.use_another_address_for_shipping
+        end
+      end
+
+      form.object.build_billing_address unless form.object.billing_address
+      form.object.build_shipping_address unless form.object.shipping_address
+
+      render partial: 'glysellin/orders/addresses_fields', locals: { form: form }
+    end
+  end
+end

data/app/helpers/glysellin/products_helper.rb

@@ -0,0 +1,4 @@
+module Glysellin
+  module ProductsHelper
+  end
+end

data/app/mailers/glysellin/order_admin_mailer.rb

@@ -0,0 +1,17 @@
+class Glysellin::OrderAdminMailer < ActionMailer::Base
+  default from: Glysellin.contact_email, to: Glysellin.admin_email
+
+  def send_order_paid_email order
+    @order = order
+    mail(
+      subject: Glysellin.mailer_subjects.call[:admin][:send_order_paid_email]
+    )
+  end
+
+  def send_check_order_created_email order
+    @order = order
+    mail(
+      subject: Glysellin.mailer_subjects.call[:admin][:send_check_order_created_email]
+    )
+  end
+end

data/app/mailers/glysellin/order_customer_mailer.rb

@@ -0,0 +1,27 @@
+class Glysellin::OrderCustomerMailer < ActionMailer::Base
+  default from: Glysellin.contact_email
+
+  def send_order_created_email order
+    @order = order
+    mail(
+      to: @order.email,
+      subject: Glysellin.mailer_subjects.call[:customer][:send_order_created_email]
+    )
+  end
+
+  def send_order_paid_email order
+    @order = order
+    mail(
+      to: @order.email,
+      subject: Glysellin.mailer_subjects.call[:customer][:send_order_paid_email]
+    )
+  end
+
+  def send_order_shipped_email order
+    @order = order
+    mail(
+      to: @order.email,
+      subject: Glysellin.mailer_subjects.call[:customer][:send_order_shipped_email]
+    )
+  end
+end

data/app/models/glysellin/address.rb

@@ -0,0 +1,35 @@
+module Glysellin
+  class Address < ActiveRecord::Base
+    self.table_name = 'glysellin_addresses'
+
+    # Additional fields can be added through Glysellin.config.additional_address_fields in an app initializer
+    store :additional_fields, :accessors => Glysellin.additional_address_fields
+    attr_accessible *Glysellin.additional_address_fields
+    # Relations
+    #
+    # And address can be used as shipping or billing address
+    belongs_to :shipped_addressable, polymorphic: true
+    belongs_to :billed_addressable, polymorphic: true
+
+    attr_accessible :activated, :first_name, :last_name, :address, :zip, :city,
+      :country, :tel, :fax, :company, :company_name, :vat_number,
+      :address_details, :additional_fields, :shipped_addressable_type,
+      :shipped_addressable_id, :billed_addressable_type, :billed_addressable_id
+
+    # Validations
+    #
+    # Validates presence of the fields defined in the config file or the glysellin initializer
+    validates_presence_of *Glysellin.address_presence_validation_keys
+
+    def same_as?(other)
+      clone_attributes == other.clone_attributes
+    end
+
+    def clone_attributes
+      clone.attributes.select do |key, value|
+        self.class.accessible_attributes.include?(key) &&
+          !key.to_s.match(/_addressable_(type|id)$/)
+      end
+    end
+  end
+end

data/app/models/glysellin/brand.rb

@@ -0,0 +1,14 @@
+module Glysellin
+  class Brand < ActiveRecord::Base
+    self.table_name = "glysellin_brands"
+
+    has_many :products
+
+    attr_accessible :name, :image, :products
+
+    has_attached_file :image,
+      styles: {
+        thumb: '150x150#'
+      }
+  end
+end

data/app/models/glysellin/discount_code.rb

@@ -0,0 +1,36 @@
+module Glysellin
+  class DiscountCode < ActiveRecord::Base
+    self.table_name = 'glysellin_discount_codes'
+
+    attr_accessible :code, :discount_type_id, :expires_on, :name, :value
+
+    belongs_to :discount_type, inverse_of: :discount_codes
+    has_many :order_adjustments, as: :adjustment
+
+    validates_presence_of :name, :code, :discount_type, :value
+
+    def code=(val)
+      super(val.downcase)
+    end
+
+    def applicable?
+      !expires_on || expires_on > Time.now
+    end
+
+    def to_adjustment order
+      calculator = Glysellin.discount_type_calculators[discount_type.identifier].new(order, value)
+
+      {
+        name: name,
+        value: -calculator.calculate,
+        adjustment: self
+      }
+    end
+
+    class << self
+      def from_code code
+        find_by_code(code.downcase)
+      end
+    end
+  end
+end

data/app/models/glysellin/discount_type.rb

@@ -0,0 +1,9 @@
+module Glysellin
+  class DiscountType < ActiveRecord::Base
+    self.table_name = 'glysellin_discount_types'
+
+    attr_accessible :identifier, :name
+
+    has_many :discount_codes, inverse_of: :discount_type
+  end
+end