smartkiosk-server 0.9.0

data/app/models/provider_group.rb

@@ -0,0 +1,45 @@
+class ProviderGroup < ActiveRecord::Base
+  include Redis::Objects
+
+  mount_uploader :icon, IconUploader
+
+  value :timestamp, :global => true, :marshal => true
+
+  after_save do
+    self.class.timestamp = updated_at
+  end
+
+  after_destroy do
+    self.class.timestamp = DateTime.now
+  end
+
+  belongs_to :provider_group
+  has_many :provider_groups, :order => :title
+  has_many :providers, :order => :priority
+  has_many :terminal_profile_provider_groups, :dependent => :destroy
+
+  accepts_nested_attributes_for :providers
+
+  validates :title, :presence => true
+
+  def self.tree(exclude=nil)
+    result = {}
+
+    inject = lambda{|result, exclude, entry, level|
+      unless entry == exclude
+        result["#{'--'*level}#{' ' if level > 0}#{entry.title}"] = entry.id
+
+        entry.provider_groups.each do |x|
+          inject.call(result, exclude, x, level+1)
+        end
+      end
+    }
+
+    ProviderGroup.where(:provider_group_id => nil).order(:title).
+      select{|x| x.provider_group.blank?}.each do |x|
+        inject.call(result, exclude, x, 0)
+      end
+
+    result
+  end
+end

data/app/models/provider_profile.rb

@@ -0,0 +1,9 @@
+class ProviderProfile < ActiveRecord::Base
+  include Redis::Objects::RMap
+
+  has_rmap({:id => lambda{|x| x.to_s}}, :title)
+
+  has_many :providers
+  has_many :limits
+  has_many :commissions
+end

data/app/models/provider_rebate.rb

@@ -0,0 +1,69 @@
+class ProviderRebate < ActiveRecord::Base
+  belongs_to :rebate, :inverse_of => :provider_rebates
+  belongs_to :provider
+
+  scope :by_provider, lambda { |x|
+    if x.blank?
+      where(:provider_id => nil)
+    else
+      where("provider_id IS NULL OR provider_id = ?", x.id)
+    end
+  }
+  scope :by_commission, lambda { |x|
+    where("requires_commission IS NULL OR requires_commission = ?", !x.blank?)
+  }
+  scope :by_payment_type, lambda { |x|
+    where("payment_type IS NULL OR payment_type = ?", x)
+  }
+
+  validates :rebate, :presence => true
+  validates :provider, :presence => true
+  validates :min, :presence => true
+  validates :max, :presence => true
+  validates :min_percent_amount, :presence => true
+
+  validate do
+    return if min.blank? || max.blank?
+
+    if min > max
+      errors.add(:min, :too_large)
+      return
+    end
+
+    # Conditions intersections
+    neighbors = rebate.provider_rebates.select{|x| x != self}
+
+    if neighbors.select{|x| x.requires_commission.nil? != requires_commission.nil?}.count > 0
+      errors[:base] << I18n.t('activerecord.errors.models.rebate.requires_commission_intersects')
+    end
+
+    if neighbors.select{|x| x.payment_type.nil? != payment_type.nil?}.count > 0
+      errors[:base] << I18n.t('activerecord.errors.models.rebate.payment_type_intersects')
+    end
+
+    # Ranges intersections
+    neighbors.select!{|x| x.provider_id == provider_id}
+
+    neighbors.select! do |x| 
+      x.min.between?(min, max)   ||
+      x.max.between?(min, max)   ||
+      min.between?(x.min, x.max) ||
+      max.between?(x.min, x.max)
+    end
+
+    if neighbors.length > 0
+      errors[:base] << I18n.t('activerecord.errors.models.rebate.conditions_intersect')
+    end
+  end
+
+  def weight
+    return 2 unless provider_id.blank?
+    return 1
+  end
+
+  def fee(amount)
+    percent_amount = amount*(self.percent_fee||0)/100
+    percent_amount = [percent, min_percent_amount].min
+    (self.static_fee||0) + percent_amount
+  end
+end

data/app/models/provider_receipt_template.rb

@@ -0,0 +1,85 @@
+class ProviderReceiptTemplate < ActiveRecord::Base
+  has_many :providers, :conditions => "provider_receipt_template_id IS NOT NULL"
+  accepts_nested_attributes_for :providers
+
+  def self.base
+    ProviderReceiptTemplate.where(:system => true).first
+  end
+
+  def self.sample
+    ProviderReceiptTemplate.new :template => base.template
+  end
+
+  def self.for(payment)
+    payment.provider.provider_receipt_template || base
+  end
+
+  def self.entities
+    {
+      :terminal => terminal_fields,
+      :payment  => payment_fields,
+      :provider => provider_fields
+    }
+  end
+
+  def self.payment_fields
+    [
+      :id,
+      :created_at,
+      :paid_at,
+      :foreign_id,
+      :account,
+      :fields,
+      :paid_amount,
+      :enrolled_amount,
+      :commission_amount
+    ]
+  end
+
+  def self.terminal_fields
+    [
+      :keyword,
+      :address,
+      :version
+    ]
+  end
+
+  def self.provider_fields
+    [
+      :title,
+      :keyword,
+      :juristic_name,
+      :inn,
+      :support_phone
+    ]
+  end
+
+  def self.masks
+    %w(
+      payment_paid_amount
+      payment_enrolled_amount
+      payment_commission_amount
+      payment_paid_at
+    )
+  end
+
+  def title
+    providers.blank? ? "--" : providers.map{|x| x.title}.join(', ')
+  end
+
+  def compile(payment)
+    data  = {}
+    masks = self.class.masks
+
+    self.class.entities.each do |entity, fields|
+      fields.each do |field|
+        model = (entity == :payment) ? payment : payment.send(entity)
+        key   = "#{entity}_#{field}"
+
+        data[key] = masks.include?(key) ? "{{ #{key} }}" : model.send(field)
+      end
+    end
+
+    Liquid::Template.parse(template).render data
+  end
+end

data/app/models/rebate.rb

@@ -0,0 +1,84 @@
+class Rebate < ActiveRecord::Base
+
+  has_paper_trail
+
+  #
+  # RELATIONS
+  #
+  belongs_to :gateway
+  has_many   :provider_rebates, :inverse_of => :rebate
+  has_many   :providers, :through => :provider_rebates
+
+  accepts_nested_attributes_for :provider_rebates, :allow_destroy => true
+
+  default_scope includes(:provider_rebates)
+
+  scope :actual, lambda{ 
+    where(arel_table[:start].lteq Date.today).
+    where(arel_table[:finish].gteq Date.today)
+  }
+
+  scope :active, lambda{
+    where(arel_table[:finish].gteq Date.today)
+  }
+
+  scope :outdated, lambda{
+    where(arel_table[:finish].lteq Date.today)
+  }
+
+  #
+  # VALIDATIONS
+  #
+  validates :gateway, :presence => true
+  validates :start, :presence => true
+  validates :finish, :presence => true
+  validates :period_kind, :presence => true, :if => lambda{|x| !x.period_fee.blank?}
+
+  validate do
+    return if gateway.blank? || start.blank? || finish.blank?
+
+    if start > finish
+      errors.add(:start, :too_large)
+      return
+    end
+
+    # Conditions intersections
+    neighbors = self.class.where(:gateway_id => gateway_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.rebate.conditions_intersect')
+    end
+  end
+
+  #
+  # METHODS
+  #
+  def self.for(payment)
+    rebate = payment.gateway.rebates.actual.first
+    return nil if rebate.blank?
+
+    rates = rebate.provider_rebates.
+      by_provider(payment.provider).
+      by_commission(payment.commission_amount).
+      by_payment_type(payment.payment_type)
+    rates.select{|x| 
+      x.min <= payment.paid_amount && 
+      x.max >= payment.paid_amount
+    }.sort_by(&:weight).reverse.first
+  end
+
+  def title
+    "##{id}"
+  end
+end

data/app/models/report.rb

@@ -0,0 +1,71 @@
+class Report < ActiveRecord::Base
+  include Stateflow
+
+  #
+  # STATEFLOW
+  #
+  stateflow do
+    initial :new
+
+    state :new, :queue, :done, :error
+
+    event :enqueue do
+      transitions :from => [:error, :new, :done], :to => :queue
+    end
+
+    event :build do
+      transitions :from => :queue, :to => [:done, :error], :decide => :build?
+    end
+  end
+
+  def enqueue!
+    enqueue
+    save!
+    ReportWorker.perform_async(id)
+  end
+
+  #
+  # RELATIONS
+  #
+  belongs_to :report_template
+  belongs_to :user
+  has_many :report_results, :order => 'id DESC'
+
+  #
+  # VALIDATIONS
+  #
+  validates :report_template, :presence => true
+  validates :user, :presence => true
+  validates :start, :presence => true, :if => lambda{|x| x.report_builder.try(:requires_dates?)}
+  validates :finish, :presence => true, :if => lambda{|x| x.report_builder.try(:requires_dates?)}
+
+  #
+  # MODIFICATIONS
+  #
+  after_create :enqueue!
+
+  #
+  # METHODS
+  #
+  def title
+    "##{id} (#{report_template.title})"
+  end
+
+  def report_builder
+    return nil if report_template.blank?
+    @report_builder ||= report_template.report_builder(self)
+  end
+
+  def build?
+    query  = report_builder.query
+
+    begin
+      data = ActiveRecord::Base.connection.exec_query(query).to_hash
+      ReportResult.create! :report_id => id, :rows => data.length, :data => data
+      return :done
+    rescue Exception => e
+      update_attribute :error, e.to_s
+      return :error
+    end
+  end
+end

data/app/models/report_result.rb

@@ -0,0 +1,11 @@
+class ReportResult < ActiveRecord::Base
+  #
+  # RELATIONS
+  #
+  belongs_to :report
+
+  #
+  # MODIFICATIONS
+  #
+  serialize :data
+end

data/app/models/report_template.rb

@@ -0,0 +1,56 @@
+class ReportTemplate < ActiveRecord::Base
+
+  attr_accessor :report_builder_instance
+
+  has_paper_trail
+
+  #
+  # RELATIONS
+  #
+  belongs_to :user
+  has_many :reports, :dependent => :destroy
+
+  #
+  # VALIDATIONS
+  #
+  validates :title, :presence => true
+
+  #
+  # MODIFCIATIONS
+  #
+  serialize :groupping
+  serialize :fields
+  serialize :calculations
+  serialize :conditions
+
+  #
+  # METHODS
+  #
+  def report_builder(report=nil)
+    return report_builder_instance unless report_builder_instance.nil?
+
+    report_builder_instance = ReportBuilder.constantize(kind)
+    report_builder_instance = report_builder_instance.new(report) if report_builder_instance
+
+    return report_builder_instance
+  end
+
+  def respond_to?(key, include_private=false)
+    return true if key.to_s.starts_with?('condition_')
+    super(key, include_private)
+  end
+
+  def method_missing(name, *args, &block)
+    return super unless name.to_s.starts_with?('condition_')
+
+    self.conditions ||= {}
+    name = name.to_s.gsub('condition_', '')
+
+    if name[-1] == '='
+      name = name[0, name.length-1]
+      self.conditions[name] = (args[0].is_a?(Array) ? args[0].select{|x| !x.blank?} : args[0])
+    else
+      self.conditions[name]
+    end
+  end
+end

data/app/models/revision.rb

@@ -0,0 +1,104 @@
+require 'string_file'
+
+class Revision < ActiveRecord::Base
+  include Redis::Objects
+  include Stateflow
+
+  #
+  # STATEFLOW
+  #
+  stateflow do
+    initial :new
+
+    state :new, :queue, :done, :error
+
+    event :enqueue do
+      transitions :from => [:error, :new], :to => :queue, :if => :moderated?
+      transitions :from => :new, :to => :new
+    end
+
+    event :perform do
+      transitions :from => :queue, :to => [:done, :error], :decide => :perform?
+    end
+  end
+
+  def enqueue!
+    enqueue
+    save!
+    ReviseWorker.perform_async(id)
+  end
+
+  #
+  # RELATIONS
+  #
+  belongs_to :gateway
+  has_many :payments, :dependent => :nullify
+
+  mount_uploader :data, FileUploader
+
+  scope :unmoderated, where(:moderated => false)
+  scope :error, where(:state => 'error')
+
+  #
+  # VALIDATIONS
+  #
+  validates :gateway, :presence => true
+  validates :date, :uniqueness => {:scope => :gateway_id}
+
+  #
+  # MODIFICATIONS
+  #
+  after_create do
+    # This is `after_create` cause sometimes we have to have the ID of revision at Payzilla
+    # Also we require the id of revision to attach payments
+
+    start  = date.to_datetime.change(:hour => 0)
+    finish = start + 1.day - 1.second
+
+    @payments = Payment.where(:gateway_id => gateway.id, :paid_at => start..finish)
+
+    @payments.update_all(:revision_id => self.id)
+
+    sum_query = @payments.arel; sum_query.projections = []
+    sum_query = sum_query.project(Payment.arel_table[:paid_amount].sum.as("paid"))
+    sum_query = sum_query.project(Payment.arel_table[:enrolled_amount].sum.as("enrolled"))
+    sum_query = connection.select_all(sum_query.to_sql).first
+
+    self.payments_count = @payments.count
+    self.paid_sum       = sum_query['paid'] || 0
+    self.enrolled_sum   = sum_query['enrolled'] || 0
+    self.commission_sum = self.paid_sum - self.enrolled_sum
+    self.moderated      = !gateway.requires_revisions_moderation
+
+    data = gateway.librarize.generate_revision(self)
+    self.data = StringFile.new("data.#{data[0]}", data[1])
+
+    enqueue if moderated?
+
+    save!
+  end
+
+  #
+  # METHODS
+  #
+  def title
+    "#{gateway.title}: #{I18n.l date}"
+  end
+
+  def moderate!
+    return if moderated?
+    update_attribute(:moderated, true)
+    enqueue!
+  end
+
+  def perform?
+    result = gateway.librarize.send_revision(self, data.read)
+
+    if result[:success]
+      return :done
+    else
+      self.update_attribute(:error, result[:error])
+      return :error
+    end
+  end
+end

data/app/models/role.rb

@@ -0,0 +1,48 @@
+class Role < ActiveRecord::Base
+  def self.entries
+    @entries ||= %w(
+      users versions reports report_templates 
+      payments providers commissions limits
+      provider_receipt_templates terminals
+      agents collections terminal_profiles system_receipt_templates
+      gateways rebates revisions
+    )
+  end
+
+  def self.actions
+    @actions ||= {
+      'terminals' => %w(reload reboot disable enable upgrade)
+    }
+  end
+
+  def self.entries_actions
+    return @result unless @result.blank?
+
+    @result = {}
+    entries.each do |x|
+      @result[x] = {}
+
+      %w(read create edit destroy).each do |a|
+        @result[x][a] = I18n.t("smartkiosk.role_priveleges.basic.#{a}")
+      end
+
+      actions[x].each do |a|
+        @result[x][a] = I18n.t("smartkiosk.role_priveleges.#{x}.#{a}")
+      end unless actions[x].blank?
+    end
+
+    @result
+  end
+
+  def title
+    I18n.t "activerecord.models.#{keyword.singularize}.other"
+  end
+
+  def actions
+    self.class.entries_actions[keyword]
+  end
+
+  def modelize
+    keyword.singularize.camelize.constantize
+  end
+end

data/app/models/system_receipt_template.rb

@@ -0,0 +1,13 @@
+class SystemReceiptTemplate < ActiveRecord::Base
+  belongs_to :provider
+
+  validates :template, :presence => true
+
+  scope :new_from, lambda{|x|
+    where(arel_table[:updated_at].gteq x)
+  }
+
+  def title
+    I18n.t "smartkiosk.system_receipt_templates.#{keyword}"
+  end
+end