smartkiosk-client 0.0.1

data/app/models/terminal.rb

@@ -0,0 +1,152 @@
+require 'smartware'
+require 'socket'
+require 'redis'
+require 'redis/objects'
+
+Application.load 'lib/smartkiosk/config/yaml'
+
+class Terminal
+  include Redis::Objects
+
+  value :state, :global => true
+  value :started_at, :global => true, :marshal => true
+  value :modified_at, :global => true, :marshal => true
+  value :payment_in_progress, :global => true
+
+  value :support_phone, :global => true
+  value :providers_updates, :global => true, :marshal => true
+
+  def self.smartguard
+    DRbObject.new_with_uri(Terminal.config.smartguard_host)
+  end
+
+  #
+  # STATES
+  #
+  def self.enable
+    self.state = 'active'
+  end
+
+  def self.disable
+    self.state = 'disabled'
+  end
+
+  def self.payment_in_progress?
+    self.payment_in_progress.value == "true"
+  end
+
+  def self.actual_state
+    self.state.value || 'active'
+  end
+
+  def self.actual_modified_at
+    self.modified_at.value || DateTime.now
+  end
+
+  def self.providers_updated_at
+    self.providers_updates[self.config.host] rescue nil
+  end
+
+  def self.providers_updated_at=(value)
+    self.providers_updates = {self.config.host => value}
+  end
+
+  #
+  # ACTIONS
+  #
+  def self.ping
+    PingWorker.perform_async
+  end
+
+  def self.reload
+    smartguard.restart_async
+  end
+
+  def self.reboot
+    self.state = 'rebooting'
+    StartupWorker.perform_async self.name, :enable
+
+    smartguard.reboot_async
+  end
+
+  #
+  # CONDITON
+  #
+  def self.config
+    @config ||= Smartkiosk::Config::YAML.new(Application.root.join 'config/services/application.yml')
+  end
+
+  def self.keyword
+    config.keyword
+  end
+
+  def self.enabled?
+    self.actual_state == 'active'
+  end
+
+  def self.version
+    '0.1'
+  end
+
+  def self.ip
+    orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true
+
+    UDPSocket.open do |s|
+      s.connect '64.233.187.99', 1
+      s.addr.last
+    end
+  rescue
+    '0.0.0.0'
+  ensure
+    Socket.do_not_reverse_lookup = orig
+  end
+
+  def self.as_json
+    {
+      :started_at => Terminal.started_at.value,
+      :modified_at => Terminal.actual_modified_at,
+      :keyword => Terminal.keyword,
+      :support_phone => Terminal.support_phone.value,
+      :groups => Group.all.map{|x| x.as_json},
+      :providers => Provider.active.map{|x| x.as_json},
+      :promotions => Promotion.order(:priority).limit(6).map{|x| x.provider_id}
+    }
+  end
+
+  def self.condition
+    {
+      :ip => ip,
+      :state => Terminal.actual_state,
+      :banknotes => Payment.merge_banknotes(Payment.uncollected),
+      :cash => Payment.merge_cash(Payment.uncollected),
+      :providers => {
+        :updated_at => Terminal.providers_updated_at,
+        :ids => Provider.select(:foreign_id).map{|x| x.foreign_id} || []
+      },
+      :queues => {
+        :payments => Sidekiq::Queue.new('payments').size,
+        :pings => Sidekiq::Queue.new('pings').size,
+        :orders => Sidekiq::Queue.new('orders').size,
+        :sync => Sidekiq::Queue.new('sync').size
+      },
+      :cash_acceptor => {
+        :error => Smartware.cash_acceptor.error,
+        :model => Smartware.cash_acceptor.model,
+        :version => Smartware.cash_acceptor.version
+      },
+      :printer => {
+        :error => Smartware.printer.error,
+        :model => Smartware.printer.model,
+       :version => Smartware.printer.version
+      },
+      :modem => {
+        :error => Smartware.modem.error,
+        :signal_level => Smartware.modem.signal_level,
+        :balance => Smartware.modem.balance,
+        :model => Smartware.modem.model,
+        :version => Smartware.modem.version
+      },
+      :version => Terminal.version
+    }
+  end
+end

data/app/uploaders/icon_uploader.rb

@@ -0,0 +1,9 @@
+require 'carrierwave'
+
+class IconUploader < CarrierWave::Uploader::Base
+  storage :file
+
+  def store_dir
+    "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
+  end
+end

data/app/views/banners.haml

@@ -0,0 +1,50 @@
+!!!
+%html{:lang => "ru"}
+  %head
+    %meta{:charset => "utf-8"}
+    %meta{:content => "width=device-width, initial-scale=1.0", :name => "viewport"}
+    %title banners
+    %script{:type => 'text/javascript', :src => '/assets/jquery.js'}
+
+    :javascript
+      var playBanner;
+
+      playBanner = function(prev) {
+        if (prev == null) {
+          prev = 0;
+        }
+        return $.get("/banners/playlist?prev=" + prev, function(banner) {
+          var playNext,
+            _this = this;
+          if (banner.filename.substr(banner.filename.length-4) === '.swf') {
+            $('video').hide();
+            $('video').attr('src', '');
+            $('object').show();
+            $('object').attr('data', banner.filename);
+            $('object > embed').attr('src', banner.filename);
+            return playNext = setTimeout(function() {
+              return playBanner(banner.playorder);
+            }, parseInt(parseFloat(banner.duration) * 1000));
+          } else {
+            $('object').hide();
+            $('object').attr('data', '');
+            $('object > embed').attr('src', '');
+            $('video').show();
+            $('video').attr('src', banner.filename);
+            $('video')[0].play();
+            return playNext = setTimeout(function() {
+              $('video')[0].pause();
+              return playBanner(banner.playorder);
+            }, parseInt(parseFloat(banner.duration) * 1000));
+          }
+        });
+      };
+
+      playBanner();
+
+
+  %body{:style => 'margin: 0; padding: 0;'}
+    %video{:width => "1280", :height => "1024", :type => 'video/webm', :style => "max-height: 1019px; max-width: 1280px;" }
+    %object{:height => '1019', :width => '1280', :type => "application/x-shockwave-flash" }
+      %param{:name => "autoplay", :value => "true"}
+      %embed{:height => '1019', :width => '1280' }

data/app/workers/orders/acknowledge_worker.rb

@@ -0,0 +1,22 @@
+require 'rest-client'
+
+Application.load 'lib/sidekiq'
+
+module Orders
+  class AcknowledgeWorker
+    include Sidekiq::Worker
+
+    sidekiq_options :queue => :orders
+
+    def perform(order_id, error=nil, percent=nil)
+      order = Order.find(order_id)
+
+      response = RestClient.post "#{Terminal.config.host}/terminal_orders/#{order.foreign_id}/acknowledge",
+        :terminal => Terminal.keyword,
+        :error    => error,
+        :percent  => percent
+
+      order.acknowledged!
+    end
+  end
+end

data/app/workers/orders/complete_worker.rb

@@ -0,0 +1,20 @@
+require 'rest-client'
+
+Application.load 'lib/sidekiq'
+
+module Orders
+  class CompleteWorker
+    include Sidekiq::Worker
+
+    sidekiq_options :queue => :orders
+
+    def perform(order_id)
+      order = Order.find(order_id)
+
+      response = RestClient.post "#{Terminal.config.host}/terminal_orders/#{order.foreign_id}/complete",
+        :terminal => Terminal.keyword
+
+      Terminal.ping
+    end
+  end
+end

data/app/workers/orders/disable_worker.rb

@@ -0,0 +1,16 @@
+Application.load 'lib/sidekiq'
+
+module Orders
+  class DisableWorker
+    include Sidekiq::Worker
+
+    sidekiq_options :queue => :orders
+
+    def perform(order_id)
+      order = Order.find(order_id)
+
+      Terminal.disable
+      order.complete
+    end
+  end
+end

data/app/workers/orders/enable_worker.rb

@@ -0,0 +1,16 @@
+Application.load 'lib/sidekiq'
+
+module Orders
+  class EnableWorker
+    include Sidekiq::Worker
+
+    sidekiq_options :queue => :orders
+
+    def perform(order_id)
+      order = Order.find(order_id)
+
+      Terminal.enable
+      order.complete
+    end
+  end
+end

data/app/workers/orders/reboot_worker.rb

@@ -0,0 +1,18 @@
+Application.load 'lib/sidekiq'
+
+module Orders
+  class RebootWorker
+    include Sidekiq::Worker
+
+    sidekiq_options :queue => :orders
+
+    def perform(order_id)
+      StartupWorker.perform_async self.class.name, :finish, [order_id]
+      Terminal.reboot
+    end
+
+    def self.finish(order_id)
+      Order.find(order_id).complete
+    end
+  end
+end

data/app/workers/orders/reload_worker.rb

@@ -0,0 +1,18 @@
+Application.load 'lib/sidekiq'
+
+module Orders
+  class ReloadWorker
+    include Sidekiq::Worker
+
+    sidekiq_options :queue => :orders
+
+    def perform(order_id)
+      StartupWorker.perform_async self.class.name, :finish, [order_id]
+      Terminal.reload
+    end
+
+    def self.finish(order_id)
+      Order.find(order_id).complete
+    end
+  end
+end

data/app/workers/orders/upgrade_worker.rb

@@ -0,0 +1,108 @@
+require 'pathname'
+require 'rubygems'
+require 'fileutils'
+
+Application.load 'lib/sidekiq'
+
+module Orders
+  class UpgradeWorker
+    include Sidekiq::Worker
+
+    sidekiq_options :queue => :orders
+
+    def perform(order_id)
+      order = Order.find(order_id)
+
+      @order_id      = order_id
+      @build_version = Gem::Version.new order.args[1]
+      @build_id      = order.args[0]
+      @base_url      = URI.parse(order.args[3]).scheme.nil? ? "#{Terminal.config.host}#{order.args[3]}"
+                                                            : order.args[3]
+
+      @releases_pathname = Terminal.smartguard.releases_path
+      @build_pathname    = @releases_pathname.join @build_version.to_s
+
+      self.sync!
+      Terminal.smartguard.switch_release @build_version.to_s.to_sym do
+        order.complete
+      end
+    end
+
+    def files!
+      FileUtils.mkdir_p @releases_pathname
+
+      nearest_less_release = Dir.glob(@releases_pathname.join('*.*')).select do |v|
+        Gem::Version.new(File.basename(v)) < @build_version
+      end.max
+
+      if !File.directory?(@build_pathname)
+        if nearest_less_release.blank?
+          FileUtils.mkdir_p @build_pathname
+        else
+          FileUtils.cp_r nearest_less_release, @build_pathname
+        end
+      end
+
+      remotes = JSON.parse(RestClient.get "#{Terminal.config.host}/terminal_builds/#{@build_id}/hashes")
+      locals  = Dir[File.join(@build_pathname, '**/**')].select{|x| File.file?(x)}.map{|x|
+        Pathname.new(x).relative_path_from(@build_pathname).to_s
+      }
+
+      download = {}
+      remove   = []
+
+      remotes.each do |remote, data|
+        local = @build_pathname.join(remote)
+
+        if !File.file?(local) || Digest::MD5.file(local).hexdigest != data[0]
+          download[remote] = data[1]
+        end
+      end
+
+      locals.each do |local, hash|
+        remove << local if remotes[local].blank?
+      end
+
+      {:download => download, :remove => remove}
+    end
+
+    def sync!
+      diff = files!
+
+      total_transfer_size = diff[:download].values.inject(0){|sum,x|(sum+=x) unless x.nil?; sum }.to_f
+
+      diff[:download].each do |key,  value|
+        uri  = URI.parse(URI.encode("#{@base_url}/#{key}"))
+        path = @build_pathname.join key
+        FileUtils.mkdir_p File.dirname(path)
+
+        File.open(path, "wb") do |f|
+          Net::HTTP.start(uri.host, uri.port) do |http|
+            http.request_get(uri.path) do |resp|
+              resp.read_body do |segment|
+                f.write(segment)
+              end
+            end
+          end
+        end
+
+        diff[:download][key] = 0
+
+        delta_transfer_size = diff[:download].values.inject(0){|sum,x| (sum+=x) unless x.nil?; sum}.to_f
+
+        current_percentage = (100.0 - (delta_transfer_size / total_transfer_size * 100.0)).round(2)
+        if  current_percentage > (@percentage ||= 0) + 5 || current_percentage == 100
+          @percentage = current_percentage
+          AcknowledgeWorker.perform_async(@order_id, nil, @percentage)
+        end
+
+      end
+
+      diff[:remove].each do |file|
+        fullpath = @build_pathname.join file
+        File.delete(fullpath) if File.exist?(fullpath)
+      end
+    end
+
+  end
+end

data/app/workers/payments/check_worker.rb

@@ -0,0 +1,35 @@
+require 'rest-client'
+
+Application.load 'lib/sidekiq'
+
+module Payments
+  class CheckWorker
+    include Sidekiq::Worker
+
+    sidekiq_options :queue => :payments
+
+    def perform(payment_id)
+      payment  = Payment.find(payment_id)
+      response = RestClient.post "#{Terminal.config.host}/payments",
+                  :provider => payment.provider.keyword,
+                  :terminal => Terminal.config.keyword,
+                  :payment  => { 
+                    :account => payment.account,
+                    :fields => payment.fields,
+                    :session_id => payment.id
+                  }
+
+      answer = JSON.parse(response.to_s, :symbolize_names => true)
+
+      unless answer[:id].nil?
+        payment.update_attributes :foreign_id  => answer[:id],
+                                  :limit       => answer[:limits].sort_by(&:weight).last,
+                                  :commissions => (answer[:commissions].empty? ? nil : answer[:commissions]),
+                                  :receipt_template => answer[:receipt_template],
+                                  :checked     => true
+      end
+    rescue => e
+      Payment.find(payment_id).update_attributes :error => true
+    end
+  end
+end

data/app/workers/payments/collect_worker.rb

@@ -0,0 +1,23 @@
+Application.load 'lib/sidekiq'
+
+module Payments
+  class CollectWorker
+    include Sidekiq::Worker
+
+    sidekiq_options :queue => :payments
+
+    def perform(collection_id)
+      collection = Collection.find(collection_id)
+
+      response = RestClient.post "#{Terminal.config.host}/collections",
+        :terminal => Terminal.config.keyword,
+        :collection => {
+          :banknotes => collection.banknotes,
+          :collected_at => collection.created_at,
+          :session_ids => collection.payment_ids
+        }
+
+      collection.update_attribute(:reported_at, DateTime.now)
+    end
+  end
+end

data/app/workers/payments/pay_worker.rb

@@ -0,0 +1,21 @@
+require 'rest-client'
+
+Application.load 'lib/sidekiq'
+
+module Payments
+  class PayWorker
+    include Sidekiq::Worker
+
+    sidekiq_options :queue => :payments
+
+    def perform(payment_id)
+      payment = Payment.find(payment_id)
+      response = RestClient.post "#{Terminal.config.host}/payments/#{payment.foreign_id}/pay",
+                                 :provider => payment.provider.keyword,
+                                 :terminal => Terminal.config.keyword,
+                                 :payment => { :paid_amount => payment.paid_amount }
+      Sidekiq::Logging.logger.debug "Pay response: #{response.to_s}"
+      payment.update_attributes(:processed => true) if response
+    end
+  end
+end

data/app/workers/ping_worker.rb

@@ -0,0 +1,180 @@
+require 'rest-client'
+
+Application.load 'lib/sidekiq'
+
+class PingWorker
+  include Sidekiq::Worker
+
+  sidekiq_options :retry => false, :queue => :pings
+
+  SEMAPHORE = ConnectionPool.new(:size => 1, :timeout => 5) { true }
+
+  def perform
+    begin
+      SEMAPHORE.with do |glory|
+        condition = Terminal.condition
+
+        Sidekiq::Logging.logger.info "Requesting with updated_at: #{Terminal.providers_updated_at}"
+
+        begin
+          response = RestClient::Request.execute(
+            :method       => :post,
+            :url          => "#{Terminal.config.host}/terminal_pings",
+            :timeout      => 40,
+            :open_timeout => 60,
+            :payload      => {
+              :terminal => Terminal.keyword,
+              :terminal_ping => condition
+            }
+          )
+        rescue Exception => e
+          Sidekiq::Logging.logger.warn e.to_s
+          return
+        end
+
+        begin
+          response = JSON.parse(response.to_s, :symbolize_names => true)
+        rescue Exception => e
+          Sidekiq::Logging.logger.warn "Unable to parse JSON: #{e.to_s}"
+          return
+        end
+
+        unless Terminal.support_phone.value == response[:support_phone]
+          Terminal.support_phone = response[:support_phone]
+          Terminal.modified_at = DateTime.now
+        end
+
+        Sidekiq::Logging.logger.info "Response: #{response.inspect}"
+
+        #
+        # ORDERS
+        #
+        response[:orders].each do |order|
+          next unless Order.find_by_foreign_id(order[:id]).blank?
+
+          order[:foreign_id] = order.delete(:id)
+          order = Order.create!(order)
+
+          order.acknowledge
+          order.perform
+        end
+
+        #
+        # PROVIDERS
+        #
+        unless response[:providers].blank?
+          syncs = []
+
+          Provider.transaction do
+            #
+            # GROUPS
+            #
+            unless response[:providers][:groups].nil?
+              remote     = response[:providers][:groups]
+              remote_ids = response[:providers][:groups].map{|x| x[:id]}
+              local      = Group.all
+
+              local.select{|x| !remote_ids.include?(x.id)}.each do |x|
+                Sidekiq::Logging.logger.info "Group removal: ##{x.id}, #{x.title}"
+                x.destroy
+              end
+
+              remote.each do |r|
+                entry   = local.find{|x| x.id == r[:id]}
+                entry ||= Group.new :foreign_id => r[:id]
+
+                entry.title = r[:title]
+                entry.priority = r[:priority]
+                entry.group_id = r[:parent_id]
+
+                Sidekiq::Logging.logger.info "Group replace: #{entry.title}"
+
+                entry.save!
+
+                unless r[:icon].blank?
+                  syncs << ['Group', entry.id, r[:icon]]
+                end
+              end
+            end
+
+            #
+            # PROVIDERS REMOVAL
+            #
+            unless response[:providers][:remove].blank?
+              Sidekiq::Logging.logger.info "Providers removal: #{response[:providers][:remove]}"
+              Provider.where(:foreign_id => response[:providers][:remove]).destroy_all
+            end
+
+            #
+            # PROVIDERS UPDATES
+            #
+            unless response[:providers][:updated_at].blank?
+              response[:providers][:update].each do |provider|
+                local = Provider.find_or_initialize_by_foreign_id(provider[:id])
+
+                attributes = {
+                  :title          => provider[:title],
+                  :keyword        => provider[:keyword],
+                  :priority       => provider[:priority],
+                  :fields         => provider[:fields],
+                  :group_id       => provider[:group_id],
+                  :requires_print => provider[:requires_print]
+                }
+
+                if provider[:icon].blank?
+                  attributes[:icon] = nil
+                end
+
+                local.assign_attributes attributes
+
+                Sidekiq::Logging.logger.info "Provider replace: #{local.keyword}"
+
+                local.save!
+
+                unless provider[:icon].blank?
+                  syncs << ['Provider', local.id, provider[:icon]]
+                end
+              end
+            end
+
+            #
+            # PROMOTIONS
+            #
+            unless response[:providers][:promotions].nil?
+              providers = Provider.to_hash(:foreign_id, response[:providers][:promotions], :invert => true)
+              remote = response[:providers][:promotions].map{|x| providers[x]}.compact
+              local  = Promotion.all
+
+              local.select{|x| !remote.include?(x.provider_id)}.each do |x|
+                Sidekiq::Logging.logger.info "Promotion removal: #{x.provider_id}"
+                x.destroy
+              end
+
+              remote.each_with_index do |r, i|
+                entry   = local.find{|x| x.provider_id == r}
+                entry ||= Promotion.new :provider_id => r
+
+                Sidekiq::Logging.logger.info "Promotion replace: #{r}"
+
+                entry.priority = i
+                entry.save!
+              end
+            end
+          end
+
+          unless response[:providers][:updated_at].blank?
+            Terminal.providers_updated_at = response[:providers][:updated_at]
+          end
+
+          Sidekiq::Logging.logger.info "Icons to sync: #{syncs}"
+
+          syncs.each do |args|
+            Sync::IconsWorker.perform_async *args
+          end
+        end
+      end
+    rescue Timeout::Error => e
+      Sidekiq::Logging.logger.warn "Semaphore timeout. #{e.to_s}"
+    end
+  end
+end