smartkiosk-server 0.9.0

data/app/models/gateway.rb

@@ -0,0 +1,99 @@
+class Gateway < ActiveRecord::Base
+
+  has_paper_trail
+
+  #
+  # RELATIONS
+  #
+  has_many :provider_gateways
+  has_many :providers, :through => :provider_gateways
+  has_many :payments, :order => 'id DESC'
+  has_many :gateway_settings
+  has_many :gateway_attachments
+  has_many :gateway_switches
+  has_many :rebates
+
+  accepts_nested_attributes_for :gateway_settings
+  accepts_nested_attributes_for :gateway_attachments
+  accepts_nested_attributes_for :gateway_switches
+
+  scope :enabled, where(:enabled => true)
+
+  #
+  # METHODS
+  #
+  def librarize(instantiate=true)
+    klass = ("Payzilla::Gateways::"+payzilla.camelize).constantize
+    return instantiate ? klass.new(self) : klass
+  end
+
+  def available_settings
+    librarize(false)::available_settings
+  end
+
+  def available_attachments
+    librarize(false)::available_attachments
+  end
+
+  def available_switches
+    librarize(false)::available_switches
+  end
+
+  def serialize_options
+    options = {}
+    sources = {
+      "setting" => available_settings, 
+      "attachment" => available_attachments,
+      "switch" => available_switches
+    }
+
+    sources.each do |prefix, source|
+      source.each do |element|
+        keyword = "#{prefix}_#{element}"
+        options[keyword] = send keyword
+      end
+    end
+
+    options
+  end
+
+  def respond_to?(key, include_private=false)
+    return true if key.to_s.starts_with?('setting_') || key.to_s.starts_with?('attachment_') || key.to_s.starts_with?('switch_')
+    super(key, include_private)
+  end
+
+  def method_missing(name, *args, &block)
+    assign = name[-1] == '='
+    name   = name[0, name.length-1] if assign
+
+    if name.to_s.starts_with?('setting_')
+      source = gateway_settings
+      klass  = GatewaySetting
+      name   = name.to_s.gsub('setting_', '')
+    elsif name.to_s.starts_with?('attachment_')
+      source = gateway_attachments
+      klass  = GatewayAttachment
+      name   = name.to_s.gsub('attachment_', '')
+    elsif name.to_s.starts_with?('switch_')
+      source = gateway_switches
+      klass  = GatewaySwitch
+      name   = name.to_s.gsub('switch_', '')
+    else
+      return super
+    end
+
+    if assign
+      data = source.select{|x| x.keyword == name}.first
+
+      if data.blank?
+        source << klass.new(:keyword => name, :gateway_id => id, :value => args[0])
+      else
+        data.value = args[0]
+      end
+    else
+      result = source.select{|x| x.keyword == name}.first.try(:value)
+      result = false if result.blank? && klass == GatewaySwitch
+      result
+    end
+  end
+end

data/app/models/gateway_attachment.rb

@@ -0,0 +1,9 @@
+class GatewayAttachment < ActiveRecord::Base
+
+  #
+  # RELATIONS
+  #
+  belongs_to :gateway
+
+  mount_uploader :value, FileUploader
+end

data/app/models/gateway_setting.rb

@@ -0,0 +1,7 @@
+class GatewaySetting < ActiveRecord::Base
+
+  #
+  # RELATIONS
+  #
+  belongs_to :gateway
+end

data/app/models/gateway_switch.rb

@@ -0,0 +1,7 @@
+class GatewaySwitch < ActiveRecord::Base
+
+  #
+  # RELATIONS
+  #
+  belongs_to :gateway
+end

data/app/models/limit.rb

@@ -0,0 +1,77 @@
+class Limit < ActiveRecord::Base
+
+  has_paper_trail
+
+  #
+  # RELATIONS
+  #
+  belongs_to :provider_profile
+  has_many :providers, :through => :provider_profile
+  has_many :limit_sections, :inverse_of => :limit
+
+  accepts_nested_attributes_for :limit_sections, :allow_destroy => true
+
+  default_scope includes(:limit_sections)
+
+  scope :actual, lambda{ 
+    where(arel_table[:start].lteq Date.today).
+    where(arel_table[:finish].gteq Date.today)
+  }
+
+  #
+  # VALIDATIONS
+  #
+  validates :provider_profile, :presence => true
+  validates :start, :presence => true
+  validates :finish, :presence => true
+
+  validate do
+    return if start.blank? || finish.blank?
+
+    if start > finish
+      errors.add(:start, :too_large)
+      return
+    end
+
+    # Conditions intersections
+    neighbors = self.class.where(:provider_profile_id => provider_profile_id)
+    neighbors = neighbors.where("id != ?", id) unless id.blank?
+
+    # Ranges intersections
+    neighbors = neighbors.to_a
+
+    neighbors.select! do |x| 
+      x.start.between?(start, finish)    ||
+      x.finish.between?(start, finish)   ||
+      start.between?(x.start, x.finish)  ||
+      finish.between?(x.start, x.finish)
+    end
+
+    if neighbors.count > 0
+      errors[:base] << I18n.t('activerecord.errors.models.limit.conditions_intersect')
+    end
+  end
+
+  #
+  # METHODS
+  #
+  def self.for(payment, filter_amount=true)
+    limit = payment.provider.limits.actual.first
+    return [] if limit.blank?
+
+    rates = limit.limit_sections.
+      by_terminal_profile_and_agent_ids(payment.terminal.terminal_profile_id, payment.terminal.agent_id).
+      by_payment_type(payment.payment_type)
+
+    rates.select!{|x| 
+      x.min <= payment.paid_amount && 
+      x.max >= payment.paid_amount
+    } if filter_amount
+
+    rates.sort_by(&:weight).reverse
+  end
+
+  def title
+    "##{id}"
+  end
+end

data/app/models/limit_section.rb

@@ -0,0 +1,58 @@
+class LimitSection < ActiveRecord::Base
+
+  #
+  # RELATIONS
+  #
+  belongs_to :limit, :inverse_of => :limit_sections
+  belongs_to :agent
+  belongs_to :terminal_profile
+
+  scope :by_terminal_profile_and_agent_ids, lambda { |p, a|
+    conditions = [
+      '(terminal_profile_id IS NULL AND agent_id IS NULL)',
+      '(agent_id = ? AND terminal_profile_id IS NULL)',
+      'terminal_profile_id = ?'
+    ]
+    where(
+      conditions.join(' OR '),
+      a,
+      p
+    )
+  }
+  scope :by_payment_type, lambda { |x|
+    where("payment_type IS NULL OR payment_type = ?", x)
+  }
+
+  #
+  # VALIDATIONS
+  #
+  validates :min, :presence => true
+  validates :max, :presence => true
+
+  validate do
+    return if min.blank? || max.blank?
+
+    if min > max
+      errors.add(:min, :too_large)
+      return
+    end
+
+    neighbors = limit.limit_sections.select{|x| x != self}
+
+    if neighbors.select{|x| x.payment_type.nil? != payment_type.nil?}.count > 0
+      errors[:base] << I18n.t('activerecord.errors.models.limit.payment_type_intersects')
+    end
+
+    neighbors.select!{|x| x.agent_id == agent_id && x.terminal_profile_id == terminal_profile_id}
+
+    if neighbors.count > 0
+      errors[:base] << I18n.t('activerecord.errors.models.limit.conditions_intersect')
+    end
+  end
+
+  def weight
+    return 3 unless terminal_profile_id.blank?
+    return 2 unless agent_id.blank?
+    return 1
+  end
+end

data/app/models/payment.rb

@@ -0,0 +1,322 @@
+class Payment < ActiveRecord::Base
+  include DateExpander
+  include Stateflow
+
+  SOURCE_INNER  = 0
+  SOURCE_MANUAL = 1
+  SOURCE_IMPORT = 2
+
+  TYPE_CASH         = 0
+  TYPE_INNER_CARD   = 1
+  TYPE_FOREIGN_CARD = 2
+  TYPE_IBANK        = 3
+  TYPE_MBANK        = 4
+  TYPE_PURSE        = 5
+  TYPE_ACCOUNT      = 6
+
+  #
+  # STATEFLOW
+  #
+  stateflow do
+    state :new, :checked, :declined, :queue, :paid, :error, :manual
+
+    event :check do
+      transitions :from => :new, :to => [:checked, :declined], :decide => :check?
+    end
+
+    event :enqueue do
+      transitions :from => [:error, :checked], :to => :queue
+    end
+
+    event :pay do
+      transitions :from => [:checked, :queue], :to => [:paid, :error], :decide => :pay?
+    end
+
+    event :pay_offline do
+      transitions :from => :new, :to => [:paid, :error], :decide => :pay_offline?
+    end
+
+    event :pay_manually do
+      transitions :from => :error, :to => :manual
+    end
+
+    event :requeue do
+      transitions :from => :error, :to => :queue
+    end
+  end
+
+  def pay_manually!(user)
+    pay_manually
+    save!
+
+    Version.create!(
+      :item_type => self.class.to_s,
+      :item_id   => self.id,
+      :event     => "payment.paid_manually",
+      :whodunnit => user.id
+    )
+  end
+
+  def requeue!(user)
+    requeue
+    save!
+
+    PayWorker.perform_async(self.id)
+    Version.create!(
+      :item_type => self.class.to_s,
+      :item_id   => self.id,
+      :event     => "payment.requeued",
+      :whodunnit => user.id
+    )
+  end
+
+  def enqueue!(attributes={})
+    [ :paid_amount, :receipt_number, :card_track1, :card_track2 ].each do |key|
+      if attributes.include? key
+        write_attribute key, attributes[key]
+      end
+    end
+
+    enqueue
+    save!
+    PayWorker.perform_async(id)
+  end
+
+  #
+  # RELATIONS
+  #
+  belongs_to :agent
+  belongs_to :terminal
+  belongs_to :provider
+  belongs_to :gateway
+  belongs_to :user
+  belongs_to :corrected_payment, :class_name => 'Payment'
+  has_one    :corrected_by, :foreign_key => 'corrected_payment_id', :class_name => 'Payment'
+
+  scope :queued, where(:state => 'queue')
+  scope :error,  where(:state => 'error')
+  scope :recent, order('created_at DESC')
+
+  #
+  # VALIDATIONS
+  #
+  validates :gateway, :presence => true
+  validates :provider, :presence => true, :if => lambda{|x| x.source == SOURCE_INNER}
+  validates :terminal, :presence => true, :if => lambda{|x| x.source == SOURCE_INNER}
+  validates :agent, :presence => true, :if => lambda{|x| x.source == SOURCE_INNER}
+  validates :commission_amount, :presence => true, :if => lambda{|x| x.source == SOURCE_MANUAL}
+  validates :enrolled_amount, :presence => true, :if => lambda{|x| x.source == SOURCE_MANUAL}
+  validates :session_id, :uniqueness => {:scope => :terminal_id}, :unless => lambda{|x| x.terminal.blank?}
+  validates :user, :presence => true, :if => lambda{|x| x.source == SOURCE_MANUAL}
+  validates :payment_type, :presence => true
+
+  #
+  # MODIFICATIONS
+  #
+  before_validation do
+    self.meta  = {} unless self.meta.is_a?(Hash)
+    self.agent = self.terminal.agent unless self.terminal.blank?
+  end
+
+  before_save do
+    if !self.paid_amount.nil? && (self.enrolled_amount.nil? || self.commission_amount.nil?)
+      self.commission_amount = Commission.for(self).first.try(:fee, paid_amount) || 0
+      self.enrolled_amount = self.paid_amount - self.commission_amount
+    end
+
+    if self.paid_amount.nil? && !self.enrolled_amount.nil? && !self.commission_amount.nil?
+      self.paid_amount = self.enrolled_amount + self.commission_amount
+    end
+
+    if !self.paid_amount.nil? && !self.commission_amount.nil? && self.rebate_amount.nil?
+      rebate = Rebate.for(self)
+      self.rebate_amount = rebate.try(:fee, paid_amount) || 0
+    end
+  end
+
+  after_create do
+    if source == SOURCE_MANUAL
+      Version.create!(
+        :item_type => self.class.to_s,
+        :item_id   => self.id,
+        :event     => "create",
+        :whodunnit => user.id
+      )
+    end
+  end
+
+  serialize :fields
+  serialize :raw_fields
+  serialize :meta
+
+  #
+  # METHODS
+  #
+  def self.acquirer(payment_type)
+    unless @acquiring_settings
+      @acquiring_settings = YAML::load File.read(Rails.root.join 'config/acquiring.yml')
+      @acquiring_settings.each do |x|
+        x['type'] = x['type'].split(',').map do |t|
+          Payment.const_get "TYPE_#{t.strip.upcase}"
+        end
+        x['class'] = x['class'].constantize
+      end
+    end
+
+    acquirer = @acquiring_settings.find{|x| x['type'].include?(payment_type)}
+    raise "unsupported payment type: #{payment_type}" unless acquirer
+
+    acquirer['class'].new(acquirer)
+  end
+
+  def self.plogger
+    return @plogger if @plogger
+
+    @plogger ||= Logger.new(Rails.root.join('log/payments.log'), 10, 1024000)
+
+    separator = ' | '
+
+    @plogger.formatter = proc { |severity, datetime, data, message|
+      data ||= {}
+
+      header = "~~ " + [
+        severity,
+        datetime.iso8601(12),
+        data[:progname],
+        data[:payment_id],
+        data[:payment_state],
+        data[:session_id],
+        data[:terminal_id],
+        data[:gateway_id],
+        message
+      ].join(separator) + "\n"
+    }
+
+    @plogger
+  end
+
+  def self.plog(severity, progname, message, data={})
+    data[:progname] = progname
+
+    unless block_given?
+      plogger.send(severity, data){ message }
+    else
+      begin
+        yield
+      rescue Exception => e
+        plogger.error(data){ e }
+        raise e
+      else
+        plogger.send(severity, data){ message }
+      end
+    end
+  end
+
+  def plog(severity, progname, message, &block)
+    data = {
+      :payment_id    => self.id,
+      :payment_state => self.state,
+      :session_id    => self.session_id,
+      :terminal_id   => self.terminal_id,
+      :gateway_id    => self.gateway_id
+    }
+
+    self.class.plog(severity, progname, message, data, &block)
+  end
+
+  def manual?
+    source == SOURCE_MANUAL
+  end
+
+  def complete?
+    %w(paid manual).include? state
+  end
+
+  def cash?
+    payment_type == TYPE_CASH
+  end
+
+  def cashless?
+    !cash?
+  end
+
+  def self.build!(terminal, provider, attributes)
+    payment = new(attributes)
+    provider_gateway = provider.provider_gateways.enabled.order(:priority).first
+
+    return false if provider_gateway.blank?
+
+    payment.terminal = terminal
+    payment.provider_gateway = provider_gateway
+    payment.raw_fields = payment.fields
+    payment.fields = provider_gateway.map(payment.account, payment.fields)
+
+    payment.save!
+    payment
+  end
+
+  def provider_gateway=(pg)
+    self.gateway = pg.gateway
+    self.provider = pg.provider
+    self.gateway_provider_id = pg.gateway_provider_id
+  end
+
+  def title
+    "##{id}: #{provider.try(:title)} (#{account || '--'})"
+  end
+
+  def human_fields=(value)
+    self.fields = value.gsub("\r", '').split("\n").map{|x| x.split('=')}
+    self.fields = Hash[*self.fields.select{|x| x.length > 1}.flatten]
+  end
+
+  def human_fields
+    return '' if self.fields.blank?
+    self.fields.collect{|k,v| "#{k}=#{v}"}.join("\n")
+  end
+
+  def check?
+    result = self.gateway.librarize.check(self)
+
+    if result[:success]
+      self.gateway_error      = nil
+      self.gateway_payment_id = result[:gateway_payment_id] unless result[:gateway_payment_id].blank?
+      self.save!
+      return :checked
+    else
+      self.update_attribute(:gateway_error, result[:error])
+      return :declined
+    end
+  end
+
+  def pay?
+    acquirer      = Payment.acquirer(self.payment_type)
+    authorization = acquirer.authorize(self)
+
+    if authorization.success?
+      result = self.gateway.librarize.pay(self)
+
+      if result[:success]
+        self.gateway_error      = nil
+        self.gateway_payment_id = result[:gateway_payment_id] unless result[:gateway_payment_id].blank?
+        self.paid_at            = DateTime.now
+        self.meta[:gateway]     = self.gateway.serialize_options
+
+        self.save!
+        authorization.confirm
+        return :paid
+      else
+        self.update_attribute(:gateway_error, result[:error])
+        authorization.reverse
+        return :error
+      end
+    else
+      self.update_attribute(:gateway_error, authorization.error)
+      return :error
+    end
+  end
+
+  def approved?
+    !['new', 'declined'].include?(state)
+  end
+end

data/app/models/provider.rb

@@ -0,0 +1,59 @@
+class Provider < ActiveRecord::Base
+  include Redis::Objects::RMap
+
+  value :timestamp, :global => true, :marshal => true
+
+  has_rmap({:id => lambda{|x| x.to_s}}, :title)
+  has_paper_trail
+
+  mount_uploader :icon, IconUploader
+
+  after_save do
+    self.class.timestamp = updated_at
+  end
+
+  after_destroy do
+    self.class.timestamp = DateTime.now
+  end
+
+  #
+  # RELATIONS
+  #
+  belongs_to :provider_profile
+  belongs_to :provider_group
+  belongs_to :provider_receipt_template
+  has_many   :provider_gateways
+  has_many   :gateways, :through => :provider_gateways
+  has_many   :payments, :order => 'id DESC'
+  has_many   :commissions, :through => :provider_profile
+  has_many   :limits, :through => :provider_profile
+  has_many   :provider_fields, :dependent => :destroy, :order => :priority
+  has_many   :terminal_profile_providers, :dependent => :destroy, :order => :priority
+  has_many   :terminal_profile_promotions, :dependent => :destroy, :order => :priority
+
+  accepts_nested_attributes_for :provider_gateways, :allow_destroy => true
+  accepts_nested_attributes_for :provider_fields, :allow_destroy => true
+
+  scope :gateway_ids_eq, lambda{|x| includes(:gateways).where(:gateways => {:id => x})}
+  search_method :gateway_ids_eq
+
+  scope :after, lambda{|x| 
+    x.blank? ? scoped 
+             : where(arel_table[:updated_at].gt x)
+  }
+
+  #
+  # VALIDATIONS
+  #
+  validates :provider_profile, :presence => true
+  validates :provider_group, :presence => true
+  validates :keyword, :presence => true
+  validates :keyword, :uniqueness => true
+
+  #
+  # METHODS
+  #
+  def fields_dump
+    provider_fields.as_json(:only => [:keyword, :title, :kind, :mask, :values, :priority])
+  end
+end

data/app/models/provider_field.rb

@@ -0,0 +1,7 @@
+class ProviderField < ActiveRecord::Base
+  belongs_to :provider
+
+  validates :title, :presence => true
+  validates :kind, :presence => true
+  validates :values, :presence => true, :if => lambda{|x| x.kind == 'select'}
+end

data/app/models/provider_gateway.rb

@@ -0,0 +1,47 @@
+class ProviderGateway < ActiveRecord::Base
+  #
+  # RELATIONS
+  #
+  belongs_to :provider, :counter_cache => true
+  belongs_to :gateway
+
+  scope :enabled, includes(:gateway).where(:gateways => {:enabled => true})
+
+  #
+  # MODIFICATIONS
+  #
+  serialize :fields_mapping
+
+  #
+  # METHODS
+  #
+  def human_fields_mapping=(value)
+    self.fields_mapping = value.gsub("\r", '').split("\n").map{|x| x.split('=')}
+    self.fields_mapping = Hash[*self.fields_mapping.select{|x| x.length > 1}.flatten]
+  end
+
+  def human_fields_mapping
+    return '' if self.fields_mapping.blank?
+    self.fields_mapping.collect{|k,v| "#{k}=#{v}"}.join("\n")
+  end
+
+  def map(account, raw_fields)
+    fields = {}
+
+    if !account.blank? && !account_mapping.blank?
+      fields[account_mapping] = account
+    end
+
+    unless raw_fields.blank?
+      unless fields_mapping.blank?
+        fields_mapping.each do |k, v|
+          fields[v] = raw_fields[k] unless raw_fields[k].blank?
+        end
+      else
+        fields.merge!(raw_fields)
+      end
+    end
+
+    fields
+  end
+end