smartkiosk-server 0.9.0

data/app/models/terminal.rb

@@ -0,0 +1,126 @@
+require_dependency 'terminal_ping'
+
+class Terminal < ActiveRecord::Base
+  include Redis::Objects::RMap
+
+  HARDWARE = %w(cash_acceptor modem printer)
+  ORDERS   = %w(reload reboot disable enable upgrade)
+
+  has_rmap({:id => lambda{|x| x.to_s}}, :keyword)
+  has_paper_trail :ignore => [:incomplete_orders_count]
+
+  #
+  # RELATIONS
+  #
+  belongs_to :terminal_profile
+  belongs_to :agent
+  has_many :collections, :order => 'id DESC'
+  has_many :payments, :order => 'id DESC'
+  has_many :terminal_orders, :order => 'id DESC'
+
+  list :pings, :marshal => true, :maxlength => 480
+
+  scope :ok,      where(:condition => 'ok')
+  scope :warning, where(:condition => 'warning')
+  scope :error,   where(:condition => 'error')
+
+  #
+  # VALIDATIONS
+  #
+  validates :terminal_profile, :presence => true
+  validates :title, :presence => true
+  validates :keyword, :presence => true, :uniqueness => true
+  validates :agent, :presence => true
+
+  #
+  # METHODS
+  #
+  def providers_dump(after=nil)
+    providers = Provider.includes(:provider_fields).after(after)
+
+    return [] if providers.blank?
+
+    overload  = Hash[*terminal_profile.terminal_profile_providers.map{|x| [x.provider_id, x]}.flatten]
+
+    providers.map do |x|
+      icon = overload[x.id].icon
+
+      if icon.blank?
+        icon = x.icon.try(:url)
+      else
+        icon = icon.url
+      end
+
+      {
+        :id             => x.id,
+        :title          => x.title,
+        :keyword        => x.keyword,
+        :icon           => icon,
+        :priority       => overload[x.id].try(:priority),
+        :fields         => x.fields_dump,
+        :group_id       => x.provider_group_id,
+        :requires_print => x.requires_print
+      }
+    end
+  end
+
+  def promotions_dump
+    terminal_profile.terminal_profile_promotions.map{|x| x.provider_id}
+  end
+
+  def provider_groups_dump
+    overload = Hash[*terminal_profile.terminal_profile_provider_groups.map{|x| [x.provider_group_id, x]}.flatten]
+
+    ProviderGroup.all.map do |x|
+      icon = overload[x.id].icon
+
+      if icon.blank?
+        icon = x.icon.try(:url)
+      else
+        icon = icon.url
+      end
+
+      {
+        :id        => x.id,
+        :title     => x.title,
+        :icon      => icon,
+        :priority  => overload[x.id].try(:priority),
+        :parent_id => x.provider_group_id
+      }
+    end
+  end
+
+  def title
+    keyword
+  end
+
+  def ping!(data)
+    raise ActiveRecord::RecordInvalid unless data.valid?
+    pings.unshift data
+
+    update = {
+      :state       => data.state,
+      :condition   => data.condition,
+      :notified_at => data.created_at,
+      :version     => data.version
+    }
+
+    HARDWARE.each do |device|
+      update["#{device}_error"] = data.error(device)
+    end
+
+    if data.ok?
+      update[:issues_started_at] = nil
+    else
+      update[:issues_started_at] = DateTime.now if issues_started_at.blank?
+    end
+
+    self.without_versioning do
+      update_attributes update
+    end
+  end
+
+  def order!(keyword, *args)
+    TerminalOrder.create!(:terminal_id => id, :keyword => keyword, :args => args)
+  end
+end

data/app/models/terminal_build.rb

@@ -0,0 +1,62 @@
+require 'digest/md5'
+
+class TerminalBuild < ActiveRecord::Base
+  mount_uploader :source, ZipUploader
+
+  validates :source, :presence => true
+  serialize :hashes
+
+  validate do
+    errors[:base] << I18n.t('activerecord.errors.models.terminal_build.no_version') if version.blank?
+  end
+
+  before_validation do
+    self.version = read_version
+  end
+
+  after_create do
+    Zip::ZipFile.open(source.path) do |zip_file|
+      zip_file.each do |f|
+        destination = File.join(self.path, f.name)
+        FileUtils.mkdir_p File.dirname(destination)
+        zip_file.extract(f, destination) unless File.exist?(destination)
+      end
+    end
+
+    self.update_attributes :hashes => build_hashes
+  end
+
+  after_destroy do
+    FileUtils.rm_rf path
+  end
+
+  def path
+    Rails.root.join("public/builds/#{id}").to_s
+  end
+
+  def url
+    "/builds/#{id}"
+  end
+
+  def read_version
+    return unless source.present?
+
+    Zip::ZipFile.open(source.path) do |zip_file|
+      return zip_file.read('VERSION').strip rescue nil
+    end
+  end
+
+  def build_hashes
+    files  = Dir.glob("#{path}/**/**", File::FNM_DOTMATCH).select{|x| File.file? x}.map!{|x| x.gsub path+'/', ''}
+    hashes = {}
+
+    files.each do |file|
+      hashes[file] = [
+        Digest::MD5.file("#{path}/#{file}").hexdigest,
+        File.size?("#{path}/#{file}")
+      ]
+    end
+
+    hashes
+  end
+end

data/app/models/terminal_order.rb

@@ -0,0 +1,42 @@
+class TerminalOrder < ActiveRecord::Base
+
+  has_paper_trail
+
+  belongs_to :terminal
+
+  scope :unsent, where(:state => 'new')
+  scope :incomplete, where("state != ?", 'complete')
+
+  validates :terminal, :presence => true
+
+  serialize :args
+
+  after_save do
+    terminal.update_attribute :incomplete_orders_count,
+      terminal.terminal_orders.incomplete.count
+  end
+
+  def title
+    I18n.t "smartkiosk.terminal_orders.#{keyword}"
+  end
+
+  def error?
+    !error.blank?
+  end
+
+  def sent?
+    state == 'sent'
+  end
+
+  def complete?
+    state == 'complete'
+  end
+
+  def sent!(percent=nil, error=nil)
+    update_attributes(:state => (complete? ? 'complete' : 'sent'), :percent => [percent.to_i, self.percent.to_i].max, :error => error)
+  end
+
+  def complete!
+    update_attribute(:state, 'complete')
+  end
+end

data/app/models/terminal_ping.rb

@@ -0,0 +1,120 @@
+class TerminalPing
+  include ActiveAttr::Model
+  include ActiveModel::Translation
+  include ActiveModel::Callbacks
+  extend Machinist::Machinable
+
+  def self.i18n_scope
+    :activerecord
+  end
+
+  attribute :state, :type => String, :default => 'unknown'
+  attribute :condition, :type => String
+  attribute :version
+  attribute :ip, :type => String
+
+  # '100' => 1, '1000' => 5
+  attribute :banknotes, :default => {}    
+
+  # :error => '...', :version => '...'
+  attribute :cash_acceptor, :default => {}
+
+  # :error => '', :version => ''
+  attribute :printer, :default => {}
+
+  # :error => '', :version => '', :signal_level => 4, :balance => 54.5
+  attribute :modem, :default => {}
+
+  # :payments => 5, :orders => 4
+  attribute :queues, :default => {}
+
+  attribute :created_at, :type => DateTime, :default => proc { DateTime.now }
+
+  def value(field, hardware)
+    source = (send(hardware) || {}) rescue {}
+    source[field].blank? ? nil : source[field]
+  end
+
+  def error(*hardware)
+    if hardware.count == 1
+      v = value('error', hardware.first)
+      return v.nil? ? nil : v.to_i
+    else
+      return hardware.map do |x|
+        v = value('error', x)
+        v.nil? ? nil : v.to_i
+      end
+    end
+  end
+
+  def valid?(*args)
+    codes = error(*Terminal::HARDWARE).compact
+
+    self.condition = 
+      if codes.blank?
+        'ok'
+      elsif codes.min >= 1000
+        'warning'
+      else
+        'error'
+      end
+
+    super
+  end
+
+  def ok?
+    condition == 'ok'
+  end
+
+  def cash_sum
+    banknotes.collect{|k,v| k.to_i*v.to_i}.sum
+  end
+
+  def cash_count
+    banknotes.values.map{|x| x.to_i}.sum
+  end
+
+  def cash_acceptor_error
+    error(:cash_acceptor)
+  end
+
+  def cash_acceptor_version
+    value 'version', :cash_acceptor
+  end
+
+  def cash_acceptor_model
+    value 'model', :cash_acceptor
+  end
+
+  def printer_error
+    error(:printer)
+  end
+
+  def printer_version
+    value 'version', :printer
+  end
+
+  def printer_model
+    value 'model', :printer
+  end
+
+  def modem_error
+    error(:modem)
+  end
+
+  def modem_version
+    value 'version', :modem
+  end
+
+  def modem_balance
+    modem['balance']
+  end
+
+  def modem_signal_level
+    modem['signal_level']
+  end
+
+  def modem_model
+    value 'model', :modem
+  end
+end

data/app/models/terminal_profile.rb

@@ -0,0 +1,51 @@
+class TerminalProfile < ActiveRecord::Base
+  include Redis::Objects::RMap
+
+  has_rmap({:id => lambda{|x| x.to_s}}, :keyword)
+  has_paper_trail
+
+  has_many :terminals, :conditions => "terminal_profile_id IS NOT NULL"
+  has_many :terminal_profile_promotions, :dependent => :destroy, :order => :priority
+  has_many :terminal_profile_providers, :dependent => :destroy, :order => :priority
+  has_many :terminal_profile_provider_groups, :dependent => :destroy, :order => :priority
+
+  mount_uploader :logo, FileUploader
+
+  accepts_nested_attributes_for :terminal_profile_promotions, :allow_destroy => true
+  accepts_nested_attributes_for :terminal_profile_providers
+  accepts_nested_attributes_for :terminal_profile_provider_groups
+
+  def terminal_profile_provider_groups(parent=false)
+    data = TerminalProfileProviderGroup.where(:terminal_profile_id => id).
+      includes(:provider_group => :provider_group).order(:priority)
+
+    data  = data.where(:provider_groups => {:provider_group_id => parent}) unless parent === false
+    pgids = data.map{|x| x.provider_group_id}
+
+    ProviderGroup.all.each do |pg|
+      unless pgids.include?(pg.id)
+        data << TerminalProfileProviderGroup.new(:provider_group_id => pg.id, :terminal_profile_id => id)
+      end
+    end
+
+    data
+  end
+
+  def terminal_profile_providers(category=nil)
+    category = category.id if !category.blank? && category.respond_to?(:id)
+    search   = category.nil? ? {} : {:provider_group_id => category}
+
+    data = TerminalProfileProvider.includes(:provider).
+      where(:terminal_profile_id => id, :providers => search).
+      order("terminal_profile_providers.priority")
+    pids = data.map{|x| x.provider_id}
+
+    Provider.where(search).all.each do |p|
+      unless pids.include?(p.id)
+        data << TerminalProfileProvider.new(:provider_id => p.id, :terminal_profile_id => id)
+      end
+    end
+
+    data
+  end
+end

data/app/models/terminal_profile_promotion.rb

@@ -0,0 +1,18 @@
+class TerminalProfilePromotion < ActiveRecord::Base
+  include Redis::Objects::RMap
+
+  value :timestamp, :global => true, :marshal => true
+
+  belongs_to :terminal_profile
+  belongs_to :provider
+
+  validates :provider, :presence => true
+
+  after_save do
+    self.class.timestamp = updated_at
+  end
+
+  after_destroy do
+    self.class.timestamp = DateTime.now
+  end
+end

data/app/models/terminal_profile_provider.rb

@@ -0,0 +1,11 @@
+class TerminalProfileProvider < ActiveRecord::Base
+
+  mount_uploader :icon, IconUploader
+
+  belongs_to :provider
+  belongs_to :terminal_profile, :inverse_of => :terminal_profile_providers
+
+  validates :provider_id, :uniqueness => {:scope => :terminal_profile_id}
+  validates :provider, :presence => true
+  validates :terminal_profile, :presence => true
+end

data/app/models/terminal_profile_provider_group.rb

@@ -0,0 +1,19 @@
+class TerminalProfileProviderGroup < ActiveRecord::Base
+
+  self.table_name = 'term_prof_provider_groups'
+
+  mount_uploader :icon, IconUploader
+
+  belongs_to :provider_group
+  belongs_to :terminal_profile, :inverse_of => :terminal_profile_provider_groups
+
+  validates :provider_group_id, :uniqueness => {:scope => :terminal_profile_id}
+  validates :provider_group, :presence => true
+  validates :terminal_profile, :presence => true
+
+  delegate :title, :to => :terminal_profile
+
+  def terminal_profile_providers
+    terminal_profile.terminal_profile_providers(provider_group_id)
+  end
+end

data/app/models/user.rb

@@ -0,0 +1,38 @@
+class User < ActiveRecord::Base
+  
+  has_paper_trail
+
+  devise :database_authenticatable, 
+         :recoverable, :rememberable, :trackable, :validatable
+
+  #
+  # RELATIONS
+  #
+  has_many :user_roles
+  has_many :roles, :through => :user_roles
+
+  accepts_nested_attributes_for :user_roles, :allow_destroy => true
+
+  #
+  # VALIDATIONS
+  #
+  validates :full_name, :presence => true
+
+  #
+  # METHODS
+  #
+  def role?(role)
+    return true if root
+    return roles.map{|x| x.keyword}.include? role.to_s
+  end
+
+  def priveleged?(role, action)
+    return true if root
+    ur = user_roles.includes(:role).find{|x| x.role.keyword == role.to_s}
+    ur.blank? ? false : ur.priveleged?(action)
+  end
+
+  def title
+    email
+  end
+end

data/app/models/user_role.rb

@@ -0,0 +1,45 @@
+class UserRole < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :role
+
+  serialize :priveleges
+
+  validates :role, :presence => true
+
+  def method_missing(method, *args)
+    method = method.to_s
+
+    if method.starts_with? 'can_'
+      role_keyword = method[method.index('_')+1..method.rindex('_')-1]
+      privelege    = method[method.rindex('_')+1..-1]
+
+      self.priveleges = [] unless self.priveleges.is_a?(Array)
+
+      if method.ends_with? '='
+        privelege = privelege[0..-2]
+
+        if role && role.keyword == role_keyword
+          if args[0] && args[0] != 'false'
+            self.priveleges = (self.priveleges + [privelege]).uniq
+          else
+            self.priveleges = self.priveleges.select{|x| x != privelege}
+          end
+        end
+      else
+        return false if !role || role.keyword != role_keyword
+        self.priveleges.include?(privelege)
+      end
+    else
+      super(method.to_sym, *args)
+    end
+  end
+
+  def respond_to?(method, *args)
+    return true if method.to_s.starts_with? 'can_'
+    super
+  end
+
+  def priveleged?(privelege)
+    priveleges.include?(privelege.to_s)
+  end
+end

data/app/reports/agents_report.rb

@@ -0,0 +1,81 @@
+# coding: utf-8
+
+class AgentsReport < ReportBuilder::Base
+  def tables
+    @tables ||= {
+      :agent => Arel::Table.new(:agents),
+      :parent_agent => Arel::Table.new(:agents).alias("parent_agents")
+    }.with_indifferent_access
+  end
+
+  def context(start, finish)
+    context = tables[:agent]
+    context = context.join(tables[:parent_agent], Arel::Nodes::OuterJoin).on(tables[:agent][:agent_id].eq tables[:parent_agent][:id])
+    context = context.where(tables[:agent][:created_at].in(start..finish)) if !start.blank? || !finish.blank?
+    context
+  end
+
+  def groupping
+    %w(
+      agent.agent_id
+    )
+  end
+
+  def fields
+    {
+      '' => %w(
+          agent.title
+          agent.juristic_name
+          agent.juristic_address_city
+          agent.juristic_address_street
+          agent.juristic_address_home
+          agent.physical_address_city
+          agent.physical_address_district
+          agent.physical_address_subway
+          agent.physical_address_street
+          agent.physical_address_home
+          agent.contact_name
+          agent.contact_info
+          agent.director_name
+          agent.director_contact_info
+          agent.bookkeeper_name
+          agent.bookkeeper_contact_info
+          agent.inn
+          agent.support_phone
+        ),
+      'agent.agent_id' => %w(
+          agent.agent_id
+          parent_agent.title
+          parent_agent.juristic_name
+          parent_agent.juristic_address_city
+          parent_agent.juristic_address_street
+          parent_agent.juristic_address_home
+          parent_agent.physical_address_city
+          parent_agent.physical_address_district
+          parent_agent.physical_address_subway
+          parent_agent.physical_address_street
+          parent_agent.physical_address_home
+          parent_agent.contact_name
+          parent_agent.contact_info
+          parent_agent.director_name
+          parent_agent.director_contact_info
+          parent_agent.bookkeeper_name
+          parent_agent.bookkeeper_contact_info
+          parent_agent.inn
+          parent_agent.support_phone
+        )
+    }
+  end
+
+  def calculations
+    {
+      :quantity => lambda{|q, t| t.groupping.blank? ? q : q.project('COUNT(*) AS "calculations.quantity"').where(tables[:agent][:agent_id].not_eq nil) }
+    }.with_indifferent_access
+  end
+
+  def conditions
+    {
+      'agent.agent_id' => proc{ Agent.rmap.invert }
+    }
+  end
+end