glysellin 0.4.1

data/lib/glysellin/cart/customer.rb

@@ -0,0 +1,36 @@
+module Glysellin
+  module Cart
+    class Customer
+      include ModelWrapper
+      wraps :user, class_name: "::User",
+        attributes: [
+          :id, :email, :password, :password_confirmation, :billing_address,
+          :shipping_address, :use_another_address_for_shipping
+        ]
+
+      def initialize attributes = {}
+        if attributes.is_a?(User) && attributes.id
+          @id = attributes.id
+          @user = attributes
+        elsif (id = attributes["id"].presence)
+          @id = id
+          @user = User.find(id)
+        else
+          super attributes
+        end
+      end
+
+      def as_json
+        # raise "As json on customer = #{ id.inspect }" if id
+        if id
+          { id: user.id }
+        else
+          %w(email password password_confirmation).reduce({}) do |hash, attr|
+            hash[attr] = public_send(attr)
+            hash
+          end
+        end
+      end
+    end
+  end
+end

data/lib/glysellin/cart/model_wrapper.rb

@@ -0,0 +1,90 @@
+module Glysellin
+  module Cart
+    module ModelWrapper
+      extend ActiveSupport::Concern
+      include ActiveModel::Model
+
+      def initialize attrs = {}
+        assign_fields(attrs) if attrs.length > 0
+      end
+
+      def assign_fields attributes
+        if attributes.class.to_s == model.model_name
+          self.wrapped_model = attributes
+        elsif (id = attributes[:id].presence)
+          @id = id
+          self.wrapped_model = model.find(id)
+        else
+          attributes.each do |field, value|
+            key = field.to_s
+            if attribute_names.include?(key)
+              self.public_send(:"#{ key }=", value)
+            end
+          end
+        end
+      end
+
+      def method_missing method, *args, &block
+        reader_method = method.to_s.gsub(/\=$/, "")
+
+        # If method is an attribute of the wrapped object
+        if attribute_names.include?(reader_method) || reader_method == "id"
+          wrapped_model.send(method, *args, &block)
+        else
+          super(method, *args, &block)
+        end
+      end
+
+      def valid?
+        wrapped_model.valid?
+      end
+
+      def errors
+        wrapped_model.errors
+      end
+
+      module ClassMethods
+        def wraps object_name, options = {}
+          key = object_name.to_s
+          # Try infer model_name if not given
+          model_name = options[:class_name] || key.camelize
+          attrs = (options[:attributes] || []).map(&:to_s)
+
+          class_eval <<-EVAL, __FILE__, __LINE__ + 1
+            attr_writer :#{ key }
+
+            # Fetch wanted attributes to be serialized
+            def attribute_names
+              #{ attrs.inspect }.presence ||
+                model._accessible_attributes[:default].select do |attr|
+                  attr.presence
+                end
+            end
+
+            def #{ key }
+              @#{ key } ||= model.new
+            end
+
+            def model
+              #{ model_name }
+            end
+
+            def attributes
+              attribute_names.reduce({}) do |attrs, attr|
+                begin
+                  attrs[attr] = public_send("\#{ attr }")
+                rescue NoMethodError
+                end
+                attrs
+              end
+            end
+
+            # Key agnostic accessor
+            def wrapped_model() #{ key } end
+            def wrapped_model=(val) self.#{ key } = val end
+          EVAL
+        end
+      end
+    end
+  end
+end

data/lib/glysellin/cart/nested_resource.rb

@@ -0,0 +1,39 @@
+module Glysellin
+  module Cart
+    module NestedResource
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def nested_resource name, options = {}
+          key = name.to_s
+          model_name = options[:class_name] || key.camelize
+
+          class_eval <<-EVAL, __FILE__, __LINE__ + 1
+            def #{ key }_attributes=(attributes)
+              self.#{ key }.assign_fields(attributes)
+            end
+
+            def #{ key }
+              @#{ key } ||= #{ model_name }.new
+            end
+
+            def #{ key }=(attributes)
+              if attributes.is_a? Hash
+                if (id = attributes.with_indifferent_access[:id].presence)
+                  @#{ key } = #{ model_name }.new(id: id)
+                else
+                  self.#{ key }_attributes = attributes
+                end
+              elsif attributes.is_a? #{ model_name }
+                @#{ key } = #{ model_name }.new(attributes)
+              else
+                @#{ key } = attributes
+              end
+            end
+          EVAL
+        end
+
+      end
+    end
+  end
+end

data/lib/glysellin/cart/payment_method.rb

@@ -0,0 +1,8 @@
+module Glysellin
+  module Cart
+    class PaymentMethod
+      include ModelWrapper
+      wraps :payment_method, class_name: "Glysellin::PaymentMethod"
+    end
+  end
+end

data/lib/glysellin/cart/product.rb

@@ -0,0 +1,16 @@
+module Glysellin
+  module Cart
+    class Product
+      attr_accessor :variant, :quantity
+
+      def initialize attrs
+        @variant = Glysellin::Variant.find(attrs[:id])
+        @quantity = attrs[:quantity]
+      end
+
+      def as_json
+        { id: variant.id, quantity: quantity }
+      end
+    end
+  end
+end

data/lib/glysellin/cart/select.rb

@@ -0,0 +1,31 @@
+module Glysellin
+  module Cart
+    module Select
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def select name, options = {}
+          key = name.to_s
+          model_name = options[:class_name] || key.camelize
+
+          class_eval <<-EVAL, __FILE__, __LINE__ + 1
+            attr_accessor :#{ key }_id
+
+            def #{ key }
+              if @#{ key } && @#{ key }.id == #{ key }_id
+                @#{ key }
+              elsif #{ key }_id
+                @#{ key } = #{ model_name }.find(#{ key }_id)
+              end
+            end
+
+            def #{ key }=(object)
+              self.#{ key }_id = object.id
+              @#{ key } = object
+            end
+          EVAL
+        end
+      end
+    end
+  end
+end

data/lib/glysellin/cart/serializable.rb

@@ -0,0 +1,30 @@
+module Glysellin
+  module Cart
+    module Serializable
+      extend ActiveSupport::Concern
+
+      def as_json
+        self.class.attrs.reduce({}) do |hash, attribute|
+          hash[attribute] = send(attribute)
+          hash
+        end
+      end
+
+      module ClassMethods
+        attr_writer :attrs
+
+        def attributes *attrs
+          self.attrs += attrs
+
+          attrs.each do |attribute|
+            attr_accessor attribute
+          end
+        end
+
+        def attrs
+          @attrs ||= []
+        end
+      end
+    end
+  end
+end

data/lib/glysellin/cart/shipping_method.rb

@@ -0,0 +1,8 @@
+module Glysellin
+  module Cart
+    class ShippingMethod
+      include ModelWrapper
+      wraps :shipping_method, class_name: "Glysellin::ShippingMethod"
+    end
+  end
+end

data/lib/glysellin/discount_type_calculator.rb

@@ -0,0 +1,7 @@
+module Glysellin
+  module DiscountTypeCalculator
+  end
+end
+
+require 'glysellin/discount_type_calculator/base'
+require 'glysellin/discount_type_calculator/order_percentage'

data/lib/glysellin/discount_type_calculator/base.rb

@@ -0,0 +1,30 @@
+module Glysellin
+  def self.discount_type_calculators
+    Hash[
+      DiscountTypeCalculator.discount_type_calculators_list.map do |dtc|
+        [dtc[:name], dtc[:discount_type_calculator]]
+      end
+    ]
+  end
+
+  module DiscountTypeCalculator
+    # List of available discount_type_calculators in the app
+    mattr_accessor :discount_type_calculators_list
+    @@discount_type_calculators_list = []
+
+    class Base
+      class << self
+        def register name, discount_type_calculator
+          DiscountTypeCalculator.discount_type_calculators_list << {
+            :name => name,
+            :discount_type_calculator => discount_type_calculator
+          }
+        end
+
+        def config
+          yield self
+        end
+      end
+    end
+  end
+end

data/lib/glysellin/discount_type_calculator/order_percentage.rb

@@ -0,0 +1,16 @@
+module Glysellin
+  module DiscountTypeCalculator
+    class OrderPercentage < Glysellin::DiscountTypeCalculator::Base
+      register 'order-percentage', self
+
+      def initialize order, value
+        @order = order
+        @value = (value.to_f / 100.0) # Convert to percentage
+      end
+
+      def calculate
+        @order.subtotal * @value
+      end
+    end
+  end
+end

data/lib/glysellin/engine.rb

@@ -0,0 +1,14 @@
+require 'glysellin/helpers'
+require 'glysellin/engine/routes'
+
+module Glysellin
+  class Engine < ::Rails::Engine
+
+    initializer "Include Helpers" do |app|
+      ActiveSupport.on_load :action_controller do
+        Helpers.include!
+      end
+    end
+
+  end
+end

data/lib/glysellin/engine/routes.rb

@@ -0,0 +1,61 @@
+module ActionDispatch::Routing
+  class Mapper
+    def glysellin_at(mount_location, options = {})
+
+      controllers = parse_controllers(options)
+
+      scope mount_location do
+        resources :orders, controller: controllers[:orders], :only => [] do
+          collection do
+            get 'payment_response'
+            post 'gateway/:gateway', :action => 'gateway_response', :as => 'named_gateway_response'
+            match 'gateway/response/:type', :action => 'payment_response', :as => 'typed_payment_response'
+          end
+
+          member do
+            post 'gateway-response', :action => 'gateway_response', :as => 'gateway_response'
+            match 'payment_response'
+          end
+        end
+
+        resources :products, controller: controllers[:products] do
+          collection do
+            get 'taxonomy/:id', action: "filter", as: "filter"
+          end
+        end
+
+        resources :taxonomies, only: [] do
+          resources :products, only: [:index]
+        end
+
+        resource :cart, controller: controllers[:cart], only: [:show, :destroy] do
+          resources :products, controller: "glysellin/cart/products", only: [:create, :update, :destroy] do
+            collection do
+              put "contents/validate", action: "validate", as: "validate"
+            end
+          end
+          resource :discount_code, controller: "glysellin/cart/discount_code", only: [:update]
+          resource :addresses, controller: "glysellin/cart/addresses", only: [:update]
+          resource :shipping_method, controller: "glysellin/cart/shipping_method", only: [:update]
+          resource :payment_method, controller: "glysellin/cart/payment_method", only: [:update]
+          resource :state, controller: "glysellin/cart/state", only: [:show] do
+            get "state/:state", action: "show", as: "set"
+          end
+        end
+
+        get '/' => 'glysellin/products#index', as: 'shop'
+      end
+    end
+
+    # Allows user to define app controllers to handle glysellin routes
+    def parse_controllers options
+      defaults = {
+        orders: 'glysellin/orders',
+        products: 'glysellin/products',
+        cart: 'glysellin/cart'
+      }
+
+      defaults.merge(options)
+    end
+  end
+end

data/lib/glysellin/gateway.rb

@@ -0,0 +1,16 @@
+if File.exists? 'glysellin/engine/routes'
+  require 'glysellin/gateway/base'
+  require 'glysellin/gateway/paypal_integral'
+  require 'glysellin/gateway/atos'
+  require 'glysellin/gateway/check'
+else
+  require File.expand_path('../gateway/base', __FILE__)
+  require File.expand_path('../gateway/paypal_integral', __FILE__)
+  require File.expand_path('../gateway/atos', __FILE__)
+  require File.expand_path('../gateway/check', __FILE__)
+end
+
+module Glysellin
+  module Gateway
+  end
+end

data/lib/glysellin/gateway/atos.rb

@@ -0,0 +1,111 @@
+module Glysellin
+  module Gateway
+    class Atos < Glysellin::Gateway::Base
+      register 'atos', self
+
+      mattr_accessor :bin_path
+      @@bin_path = ''
+
+      mattr_accessor :merchant_id
+      @@merchant_id = ''
+
+      mattr_accessor :pathfile_path
+      @@pathfile_path = ''
+
+      mattr_accessor :merchant_country
+      @@merchant_country = 'fr'
+
+      mattr_accessor :capture_mode
+      @@capture_mode = 'AUTHOR_CAPTURE'
+
+      mattr_accessor :capture_days
+      @@capture_days = nil
+
+      attr_accessor :errors, :order
+
+      def initialize order
+        @order = order
+        @errors = []
+      end
+
+      class << self
+        # Extract order id from response data since it cannot be dynamically given via get URL
+        def parse_order_id data
+          data_param = Rack::Utils.parse_nested_query(data)['DATA']
+          log "Parse id from RAW POST : #{ data }"
+          log "Data param : #{ data_param }"
+          parse_atos_resp(data_param)[32].to_i
+        end
+
+        def parse_atos_resp data
+          # Prepare arguments
+          exec_chain = "message=#{ data } pathfile=#{ @@pathfile_path }"
+          bin_path = "#{ @@bin_path }/response"
+          # Call response program to get exclamation point separated payment response details
+          resp = `#{ bin_path } #{ exec_chain }`.split('!')
+          log "Reponse de atos : #{ resp } / Order id : #{ resp[32] }"
+          resp
+        end
+      end
+
+      def render_request_button
+        exec_chain = {
+          :merchant_id => @@merchant_id,
+          :merchant_country => @@merchant_country,
+          :capture_mode => @@capture_mode,
+          :pathfile => @@pathfile_path,
+          :data => @order.id,
+          :amount => (@order.total_price * 100).to_i,
+          :transaction_id => @order.payment.get_new_transaction_id
+        }.to_a.map { |item| item[0].to_s + '=' + item[1].to_s }.join(' ')
+
+        bin_path = "#{ @@bin_path }/request"
+
+        begin
+          results = `#{bin_path} #{exec_chain}`.split('!')
+        # If OS didn't want to exec program
+        rescue Errno::ENOEXEC => msg
+          results = []
+        end
+
+        if results.length == 0
+          result = "<div style=\"color:red\">#{ bin_path } #{ exec_chain }</div>"
+        # If exit code is 0, render payment buttons
+        elsif results[1].to_i >= 0
+          result = results[3]
+        # Else render debug informations
+        else
+          result = results[2]
+        end
+
+        # Render HTML button
+        { text: result.html_safe }
+      end
+
+      # Launch payment processing
+      def process_payment! post_data
+        results = self.class.parse_atos_resp(Rack::Utils.parse_nested_query(post_data)['DATA'])
+        # Réponse acceptée
+        valid = results[1].to_i == 0 && results[11].to_i == 0
+
+        log "Processing remote payment : #{ valid }"
+
+        result = valid ? @order.paid! : false
+
+        @order.save
+        result
+      end
+
+      # The response returned within "render" method in the OrdersController#gateway_response method
+      def response
+        { nothing: true }
+      end
+
+      protected
+
+      def shell_escape(str)
+        String(str).gsub(/(?=[^a-zA-Z0-9_.\/\-\x7F-\xFF\n])/n, '\\').gsub(/\n/, "'\n'").sub(/^$/, "''")
+      end
+    end
+  end
+end