mrpin-sdk 0.3.141 → 1.0.2

data/lib/mrpin/core/utils/sorter_base.rb

@@ -0,0 +1,344 @@
+class SorterBase
+
+  #
+  # properties
+  #
+
+  attr_accessor :top_size
+  attr_accessor :sort_criteria_non_players
+
+  attr_reader :players_ids
+  #todo:remove for avoid sync errors (can't add key during iteration)
+  attr_reader :player_position_map
+  attr_reader :players_resources_map
+  attr_reader :players_locker
+
+
+  #
+  # events
+  #
+
+  protected
+  def on_player_updated(player, position_old, position_new, resource_count_new)
+    #do nothing
+  end
+
+  protected
+  def on_player_came_to_top(player, position_old, position_new, resource_count_new)
+    #do nothing
+  end
+
+  protected
+  def on_player_left_from_top(player, position_old, position_new, resource_count_new)
+    #do nothing
+  end
+
+  protected
+  def on_player_top_updated(player, position_old, position_new, resource_count_new)
+    #do nothing
+  end
+
+  #
+  # methods
+  #
+
+  public
+  def initialize
+    @top_size = 100
+
+    @sort_criteria_non_players = 0
+
+    # ordered player_ids
+    @players_ids               = []
+    # key player_id, value - position
+    @player_position_map       = {}
+    # key - player_id, value - player specify resource count
+    @players_resources_map     = {}
+
+    @players_locker = Mutex.new
+  end
+
+  # init sorter with start data
+  # sort_criteria_map - map with key - player_id, value - sort criteria
+  public
+  def init_sorter(sort_criteria_map)
+    @players_ids = sort_criteria_map.keys.dup
+
+    @players_ids.sort_by! do |id|
+      sort_criteria_map[id]
+    end
+
+    @players_ids.reverse!
+
+    @player_position_map = Hash[@players_ids.map.with_index(index_offset = 1).to_a]
+
+    @players_resources_map = sort_criteria_map.dup
+  end
+
+  protected
+  def find_new_position(resource_count, player_position_old, find_up)
+
+    if find_up
+      index_left  = 0
+      index_right = player_position_old - 1
+    else
+      index_left  = player_position_old - 1
+      index_right = @players_ids.size - 1
+    end
+
+    while index_left <= index_right
+      median_index = (index_right + index_left) / 2
+
+      player_median_resources = @players_resources_map[@players_ids[median_index]]
+
+      if resource_count > player_median_resources
+        index_right = median_index - 1
+      elsif resource_count == player_median_resources
+
+        index_left = median_index
+
+        while resource_count == player_median_resources
+          index_left              = index_left + 1
+          player_median_resources = @players_resources_map[@players_ids[index_left]]
+        end
+
+        break
+      else
+        index_left = median_index + 1
+      end
+    end
+
+    index_left + 1
+  end
+
+  public
+  def try_update_position(player, sort_criteria_value)
+    player_came_to_top   = false
+    player_left_from_top = false
+
+    player_id = player.id
+
+    if player.respond_to?(:is_player?) && !player.is_player?
+      sort_criteria_value = @sort_criteria_non_players
+    end
+
+    @players_locker.synchronize do
+
+      #add player if he doesn't exist
+      if @player_position_map[player_id].nil?
+        add_player_unsafe(player, sort_criteria_value)
+        return
+      end
+
+      sort_criteria_old = @players_resources_map[player_id]
+
+      return if sort_criteria_value == sort_criteria_old
+
+      find_position_up = sort_criteria_value > sort_criteria_old
+
+      position_old = @player_position_map[player_id]
+      position_new = find_new_position(sort_criteria_value, position_old, find_position_up)
+
+      if position_new > position_old
+        # need because player already in top
+        position_new -= 1
+      end
+
+      @players_resources_map[player_id] = sort_criteria_value
+
+      player_in_top = position_new <= @top_size
+
+      if position_new != position_old
+
+        player_came_to_top   = position_old > @top_size && position_new <= @top_size
+        player_left_from_top = position_old <= @top_size && position_new > @top_size
+
+        @players_ids.delete_at(position_old - 1)
+        @players_ids.insert(position_new - 1, player_id)
+
+        update_player_positions(position_new, position_old)
+      end
+
+      if player_came_to_top
+        on_player_came_to_top(player, position_old, position_new, sort_criteria_value)
+      elsif player_left_from_top
+        on_player_left_from_top(player, position_old, position_new, sort_criteria_value)
+      elsif player_in_top #invalidate top player
+        on_player_top_updated(player, position_old, position_new, sort_criteria_value)
+      else #usual player, just invalidate online friends
+        on_player_updated(player, position_old, position_new, sort_criteria_value)
+      end
+
+    end
+
+    nil
+  end
+
+  protected
+  def update_player_positions(position_new, position_old)
+
+    position_start = [position_new, position_old].min
+    position_end   = [position_new, position_old].max
+
+    (position_start..position_end).each do |position|
+
+      player_id = @players_ids[position - 1]
+
+      @player_position_map[player_id] = position
+
+    end
+  end
+
+  #
+  # methods for get info
+  #
+
+  public
+  def get_players_ids(position_start = 0, position_end = nil)
+    result = nil
+
+    @players_locker.synchronize do
+      result = get_players_ids_unsafe(position_start, position_end)
+    end
+
+    result
+  end
+
+  public
+  def get_player_position_total(player)
+    result = 0
+
+    @players_locker.synchronize do
+      result = @player_position_map[player.id]
+    end
+
+    result
+  end
+
+
+  # return
+  # {
+  #   player_id:
+  #   sort_criteria:
+  #   position:
+  # }
+  public
+  def get_player_info(player_id)
+    result = nil
+
+    @players_locker.synchronize do
+      return result unless @player_position_map.key?(player_id)
+
+      result = get_player_info_unsafe(player_id)
+    end
+
+    result
+  end
+
+  private
+  def get_player_info_unsafe(player_id)
+    {
+        player_id:     player_id,
+        position:      @player_position_map[player_id],
+        sort_criteria: @players_resources_map[player_id]
+    }
+  end
+
+  private
+  def get_players_ids_unsafe(position_start, position_end)
+    position_end = position_end || (@top_size - 1)
+
+    position_end = @players_ids.size if position_end < 0
+
+    result = @players_ids[position_start..position_end]
+  end
+
+  # return array of
+  # {
+  #   player_id:
+  #   sort_criteria:
+  #   position:
+  # }
+  public
+  def get_players_infos(position_start = 0, position_end = nil)
+
+    result = []
+
+    @players_locker.synchronize do
+
+      players_ids = get_players_ids_unsafe(position_start, position_end)
+
+      players_ids.each do |player_id|
+        player_info = get_player_info_unsafe(player_id)
+
+        result << player_info
+      end
+
+    end
+
+    result
+  end
+
+  #
+  # manager players
+  #
+
+  public
+  def add_player(player, sort_criteria_value = 0)
+    @players_locker.synchronize do
+      add_player_unsafe(player, sort_criteria_value)
+    end
+  end
+
+  protected
+  def add_player_unsafe(player, sort_criteria_value = 0)
+    player_id           = player.id
+
+    sort_criteria_value = 0 if sort_criteria_value.nil?
+
+    return if @players_resources_map.empty?
+    return unless @player_position_map[player_id].nil?
+
+    index_position = @players_ids.size
+
+    while index_position > 0 && sort_criteria_value > @players_resources_map[@players_ids[index_position - 1]]
+      index_position -= 1
+    end
+
+    @players_ids.insert(index_position, player_id)
+    @players_resources_map[player_id] = sort_criteria_value
+    @player_position_map[player_id]   = index_position + 1
+
+    update_player_positions(index_position + 1, @players_ids.size)
+
+    if index_position < @top_size
+      on_player_came_to_top(player, nil, index_position + 1, sort_criteria_value)
+    end
+  end
+
+  public
+  def delete_player(player)
+    @players_locker.synchronize do
+      player_id = player.id
+
+      position_old = @player_position_map[player.id]
+
+      return if position_old.nil?
+
+      @players_ids.delete_at(position_old - 1)
+      @players_resources_map.delete(player_id)
+      @player_position_map.delete(player_id)
+
+      update_player_positions(position_old, @players_ids.size)
+
+      if position_old <= @top_size
+        position_new       = [@players_ids.size + 1, @top_size + 1].max
+        resource_count_new = 0
+
+        on_player_left_from_top(player, position_old, position_new, resource_count_new)
+      end
+    end
+  end
+
+
+end

data/lib/mrpin/core/utils/utils_io.rb

@@ -0,0 +1,27 @@
+module UtilsIO
+  private
+  def self.root_dir
+    Rails.env.development? ? File.join(Rails.root.to_s, 'public') : "/usr/local/#{AppInfo.instance.server_name}"
+  end
+
+  public
+  def self.to_domain_path(file_path)
+    root_dir = self.root_dir
+
+    file_path = file_path.gsub(root_dir, '')
+
+    File.join('https://', AppInfo.instance.host, file_path)
+  end
+
+  public
+  def self.to_local_path(url_path)
+    root_dir = self.root_dir
+
+    file_path = url_path
+    file_path = file_path.gsub(AppInfo.instance.host, '')
+    file_path = file_path.gsub('https://', '')
+    file_path = file_path.gsub('http://', '')
+
+    File.join(root_dir, file_path)
+  end
+end

data/lib/mrpin/core/utils/utils_string.rb

@@ -0,0 +1,17 @@
+class UtilsString
+
+  public
+  def self.to_utf8(value, default_value = 'unknown')
+    result = nil
+
+    begin
+      result = "#{value}".force_encoding('utf-8')
+    rescue
+      result = default_value
+    end
+
+
+    result
+  end
+
+end

data/lib/mrpin/core/utils/utils_zip.rb

@@ -0,0 +1,58 @@
+class UtilsZip
+
+  #
+  # Properties
+  #
+
+  #
+  # Methods
+  #
+
+  public
+  def self.compress_to_base64(data)
+    return data if data.nil?
+
+    #compress and encode to base64
+    data_bin = Zlib.deflate(data)
+    Base64.strict_encode64(data_bin)
+  end
+
+
+  public
+  def self.decompress_base64(data_base64)
+    result = nil
+
+    unless data_base64.nil?
+      #decode from base64 and decompress
+      progress_bin = Base64.strict_decode64(data_base64)
+      result       = Zlib.inflate(progress_bin)
+      result       = result.force_encoding('utf-8')
+    end
+
+    result
+  end
+
+  # unzip all files from zip to destination dir
+  # return extract dir path
+  #todo:fix extract_dir
+  public
+  def self.unzip_file(filename, destination_dir = nil)
+
+    destination_dir = File.dirname(filename) if destination_dir.nil?
+
+    %x(unzip -n '#{filename}' -d '#{destination_dir}') #-n never overwrite existing files
+
+    extract_dir = File.join(destination_dir, File.basename(filename, '.*'))
+
+    #downcase all file names
+    Dir.glob(extract_dir + '/*.*').each do |file|
+      filename     = File.basename(file, '.*')
+      filename_new = Unicode::downcase(filename.force_encoding('utf-8'))
+      File.rename(file, extract_dir + '/' + filename_new)
+    end
+
+    extract_dir
+  end
+
+
+end

data/lib/mrpin/libs/rails_admin/localization.rb

@@ -0,0 +1,70 @@
+require 'rails_admin/config/actions'
+require 'rails_admin/config/actions/base'
+
+module RailsAdmin
+  module Config
+    module Actions
+      class Localization < Base
+        RailsAdmin::Config::Actions.register(self)
+
+        register_instance_option :visible? do
+          authorized? && (bindings[:abstract_model].to_s == CLASS_MAP[EClassType::ECT_LOCALIZATION])
+        end
+
+        register_instance_option :collection do
+          true
+        end
+
+        register_instance_option :link_icon do
+          'icon-none'
+        end
+
+        register_instance_option :pjax? do
+          false
+        end
+
+        register_instance_option :http_methods do
+          [:get, :post]
+        end
+
+        register_instance_option :controller do
+
+          proc do
+
+            model_name = @abstract_model.model_name
+
+            unless model_name == CLASS_MAP[EClassType::ECT_LOCALIZATION]
+              flash[:error] = 'Localization actions work only with Localization model'
+              redirect_to index_path
+              next
+            end
+
+            flash.clear
+
+            next unless request.post?
+
+            params = request.filtered_parameters.symbolize_keys
+
+            if params[:export] # EXPORT
+
+              begin
+
+                manager_string = AppInfo.instance.manager_string
+
+                file_name = manager_string.export_localizations_to_s3
+
+                flash[:success] = "File #{file_name} was exported"
+
+              rescue Exception => error
+                flash[:error] = "Error exporting file. #{error.message}"
+              end
+            end
+
+            render @action.template_name
+
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mrpin/libs.rb

@@ -0,0 +1,11 @@
+require 'base64'
+require 'benchmark'
+require 'date'
+require 'digest/md5'
+require 'fileutils'
+require 'net/http'
+require 'singleton'
+require 'socket'
+require 'zlib'
+
+Dir[File.dirname(__FILE__) + '/libs/**/*.rb'].each { |file| require file }

data/lib/mrpin/rails/engine.rb

@@ -0,0 +1,11 @@
+module Mrpin
+  module Rails
+    class Engine < ::Rails::Engine
+      # Get rails to add app, lib, vendor to load path
+
+      initializer 'Mrpin-sdk precompile hook', group: :all do |app|
+        app.config.assets.precompile += %w(mrpin.css)
+      end
+    end
+  end
+end

data/lib/mrpin/vendors.rb

@@ -0,0 +1,19 @@
+require 'rails'
+
+require 'amf'
+require 'aws-sdk'
+require 'bootstrap-sass-rails'
+require 'carrierwave/mongoid'
+require 'eventmachine'
+require 'em-websocket'
+require 'devise'
+require 'faraday'
+require 'faraday_middleware'
+require 'mongoid'
+require 'rails_admin'
+require 'rufus-scheduler'
+require 'uglifier'
+require 'unicode'
+require 'uuid'
+require 'vmstat'
+require 'securerandom'

data/lib/mrpin/version.rb

@@ -0,0 +1,3 @@
+module Mrpin
+  VERSION = '1.0.2'
+end

data/lib/mrpin-sdk.rb

@@ -0,0 +1,6 @@
+require 'mrpin/version'
+
+require 'mrpin/libs'
+require 'mrpin/vendors'
+
+require 'mrpin/rails/engine'

data/mrpin-sdk.gemspec

@@ -0,0 +1,54 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+begin
+  require 'mrpin/version'
+rescue Exception => e
+  puts "[WARNING] Can't require mrpin-sdk with error: #{e}"
+end
+
+Gem::Specification.new do |spec|
+  spec.name        = 'mrpin-sdk'
+  spec.version     = Mrpin::VERSION
+  spec.authors     = %w(Gregory Tkach Yakupov Dmitrij)
+  spec.email       = %w(gregory.tkach@gmail.com yakupov.dmitrij@gmail.com)
+  spec.description = %q{Mrpin sdk for backend development.}
+  spec.summary     = "#{spec.description}. Summary."
+  spec.license     = 'MIT'
+  spec.homepage    = 'https://mr-pin.net'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = %w(app lib)
+
+  spec.add_development_dependency 'bundler', '~> 1'
+  spec.add_development_dependency 'rake', '~> 12'
+
+  spec.add_runtime_dependency 'aws-sdk', '~> 2'
+  spec.add_runtime_dependency 'bootstrap-sass-rails', '~> 3'
+  # improve bson deserialization
+  spec.add_runtime_dependency 'bson_ext', '~> 1'
+  # uploader
+  spec.add_runtime_dependency 'carrierwave-mongoid', '~> 0'
+  # auth gem
+  spec.add_runtime_dependency 'devise', '~> 4'
+  # websockets based on event machine
+  spec.add_runtime_dependency 'em-websocket', '~> 0'
+  spec.add_runtime_dependency 'eventmachine', '~> 1'
+  spec.add_runtime_dependency 'faraday', '~> 0'
+  spec.add_runtime_dependency 'faraday_middleware', '~> 0'
+  spec.add_runtime_dependency 'mongoid', '~> 6'
+  spec.add_runtime_dependency 'mrpin-amf', '~> 2'
+  spec.add_runtime_dependency 'rails', '~> 5'
+  spec.add_runtime_dependency 'rails_admin', '~> 1'
+  spec.add_runtime_dependency 'rufus-scheduler', '~> 3'
+  # JavaScript compressor
+  spec.add_runtime_dependency 'uglifier', '~> 2'
+  spec.add_runtime_dependency 'unicode', '~> 0'
+  spec.add_runtime_dependency 'uuid', '~> 2'
+  # system info cpu, memory etc
+  spec.add_runtime_dependency 'vmstat', '~> 2'
+
+end