promo_controller.rb

class PromoController < ProxyController

  CONTROLLER_MANIFEST = {
      :common_methods => { # common methods, that controller responds to
                            :to_xml => :to_xml,
                            :to_friend_xml => :to_friend_xml,
                            :to_imaginary_friend_xml => :to_imaginary_friend_xml,
                            :daily_reset => :daily_reset,
                            :on_first_request => :on_first_request,
                            :on_get_user_stat => :on_get_user_stat,
                            :save => {:name => :save!, :need_init => true}
      },
      :commands => { #commands, that controller can perform
                     # :command_1 => :controller_method_name,
                     # :command_2 => :controller_method_name
      }
  }

  KEEP_CATEGORIES = ['chest']

  register_controller(:fortune_wheel, FortuneWheelController)
  register_controller(:materials, MaterialsSaleController)
  register_controller(:boatman, BoatmanSaleController)
  register_controller(:fb_bonus, FBBonusController)
  register_controller(:packs, PacksSaleController)
  register_controller(:flash_sales, FlashSalesController)
  register_controller(:lottery, LotteryController)
  register_controller(:start_pack, StartPackController)
  register_controller(:product_bonus, ProductBonusController)
  register_controller(:chest, PromoChestController)
  register_controller(:custom_sale, CustomSaleController)

  attr_accessor :promo_data
  def initialize(user)
    super
    refresh
  end

  def self.config
    ApplicationConfig.configs[:promo_config]
  end

  def refresh
    @promo_data = JSON.parse(@user.promo_data || '{}')
    @promo_data['pay_group'] = 0 if @promo_data['pay_group'].nil?
    self
  end

  def on_first_request
    self.call_controllers_method(:on_first_request)
  end

  def on_get_user_stat
    self.call_controllers_method(:on_get_user_stat)
  end

  def save!
    @user.promo_data = @promo_data.to_json
  end

  def promo_config
    ApplicationConfig.configs[:promo_config]
  end

  def to_xml
    client_data = self.call_controllers_method(:to_client_data).stringify_keys
    client_data = @promo_data.merge(client_data).select{|key, value| !value.nil? && !(value.is_a?(Hash) && value['finished'])}
    " promotions='#{client_data.to_json}'"
  end

  def to_friend_xml(friend)
    client_data = self.call_controllers_method(:to_client_friend_data, [friend.user_id]).stringify_keys
    client_data.select!{|key, value| value.present? && !(value.is_a?(Hash) && value['finished'])}
    client_data.present? ? " promotions='#{client_data.to_json}'" : ''
  end

  def to_imaginary_friend_xml(num)
    to_friend_xml({'user_id' => User.get_imaginary_friend_id(num)})
  end

  def get_or_create(category)
    return promo_data[category] if promo_data[category].present?
    set_category(category, {})
  end

  def set_category(category, value)
    promo_data[category] = value
  end

  def users_pay_groups_config
    ABTestController.with_patched_config(:promo_config, @user) do
      return PromoController::config['user_pay_groups']
    end
  end

  def user_pay_group
    update_user_pay_group if promo_data['pay_group'].nil?
    promo_data['pay_group'].to_i
  end

  def user_pay_group=(group)
    set_category('pay_group', group)
  end

  def daily_reset
    update_user_pay_group
    self.call_controllers_method(:daily_reset)
  end

  def is_category_active?(category, category_config = nil, with_lag = false)
    check_category(category, category_config, with_lag).blank?
  end

  def check_category(category, category_config = nil, with_lag = false)
    category_config ||= self.class.config[category]

    if category_config['action_start'].present? && category_config['action_end'].present?
      start_time = category_config['action_start'].to_i
      end_time = [category_config['action_end'].to_i, 0].max + (with_lag ? self.end_time_lag(category_config['end_time_lag'] || self.class.config[category]['end_time_lag']) : 0)

      if @user.current_time.to_i <= start_time || @user.current_time.to_i >= end_time
        return :time
      end
    end

    return nil if category_config['require'].blank?
    @user.check_require_config(category_config['require'])
  end

  def check_level(level)
    if level.is_a?(Hash)
      @user.level >= (level['min'] || 0) && @user.level <= (level['max'] || ApplicationConfig.levels.size - 1)
    else
      @user.level >= level.to_i
    end
  end

  def check_unlock(unlock)
    @user.unlock_controller.has_unlock?(unlock)
  end

  def check_quest(quests)
    res = false
    quests['any'].each{|quest_id| res = true if @user.quest_controller.quest_completed?(quest_id)} if quests['any'].present?
    quests['all'].each{|quest_id| return false unless @user.quest_controller.quest_completed?(quest_id)} if quests['all'].present?
    res
  end

  def check_room(rooms)
    rooms.each{|room| return true if @user.room_controller.current_room.to_s == room.to_s}
    false
  end

  def check_paying(needed_value)
    @user.paying? == needed_value
  end

  def update_user_pay_group
    user_spent = get_user_spend_money
    old_group = promo_data['pay_group']
    new_group = pay_group_by_spend_money(user_spent)
    if old_group != new_group
      Kontagent.event("pay_group_#{new_group}", @user, 1, @user.level, 'server', 'promo', 'change_pay_group')
    end
    self.user_pay_group = new_group
  end

  def pay_group_by_spend_money(user_spent)
    new_group, _ = users_pay_groups_config.find do |i, intervals|
      intervals.any? do |interval|
        ok = true
        ok = ok && interval['min'] <= user_spent if interval['min']
        ok = ok && interval['max'] >= user_spent if interval['max']
        ok
      end
    end
    new_group ||= 0
  end

  def get_user_spend_money(period = nil)
    query_data = {:select => 'SUM(money)'}
    if period != -1
      pay_end = pay_group_end(period)
      query_data[:conditions] = ['(money > 0) AND (created_at BETWEEN ? AND ?)', pay_end.to_s(:db), pay_group_start.to_s(:db)]
    else
      query_data[:conditions] = ['(money > 0)']
    end

    transactions = @user.user_transactions.all(query_data)
    transactions.first.sum.to_i / UserTransaction.config['money_multiplier'].to_f
  end

  def can_give_horseshoes?
    return @user.level >= ApplicationConfig.configs[:horseshoe_reward_level]
  end

  def pay_group_start
    @user.current_time.beginning_of_day
  end

  def pay_group_end(period = nil)
    period ||= self.class.config['pay_period']
    pay_group_start - period.days
  end

  def clear
    promo_data.each_key do |key|
      unless KEEP_CATEGORIES.include?(key)
        promo_data[key] = {}
      end
    end
    save!
  end

  def end_time_lag(end_time_lag = nil)
    (end_time_lag || promo_config['end_time_lag'] || Server.time_lag).to_i
  end

end