cck_forms 3.0.0

data/lib/cck_forms/parameter_type_class/integer_range.rb

@@ -0,0 +1,150 @@
+class CckForms::ParameterTypeClass::IntegerRange # Rover :)
+  include CckForms::ParameterTypeClass::Base
+
+  def self.name
+    'Диапазон между двумя целыми числами'
+  end
+
+  # {from: 500, to: 1000, ranges: {"300-600" => true, "601-900" => true, "901-1500" => false}}
+  def mongoize
+    value_from_form = value
+    return nil if value_from_form.blank?
+
+    from = value_from_form.try(:[], 'from').to_i
+    till = value_from_form.try(:[], 'till').to_i
+
+    db_representation = {
+      from: from,
+      till: till,
+      ranges: {}
+    }
+
+    if @extra_options[:ranges].respond_to? :each
+      @extra_options[:ranges].each do |range_string|
+        low, high = range_string.split(range_string_delimiter)
+        if high.to_i.to_s != high.to_s
+          high = Integer::MAX_32BIT
+        end
+        low, high = low.to_i, high.to_i
+
+        #   -----
+        # [ RANGE ]
+        completely_in_range = (from >= low && till <= high)
+
+        #       -------
+        # [ RANGE ]
+        #
+        # ------
+        #    [ RANGE ]
+        intersects_range_partially = (from <= low && till >= low) || (from <= high && till >= high)
+
+        # -----------
+        #  [ RANGE ]
+        contains_range = from < low && till > high
+
+        db_representation[:ranges][range_string] = completely_in_range || intersects_range_partially || contains_range
+      end
+    end
+
+    db_representation
+  end
+
+  def to_s(options = {})
+    options ||= {}
+    return '' if value.blank?
+
+    delimiter = options[:delimeter].presence || default_integer_range_delimiter
+
+    from = value.try(:[], 'from').to_i
+    till = value.try(:[], 'till').to_i
+
+    return '' if from.zero? && till.zero?
+
+    if from.zero?
+      "до #{till}"
+    elsif till.zero?
+      "от #{from}"
+    elsif from == till
+      from.to_s
+    else
+      [from, till].join(delimiter)
+    end
+  end
+
+  def build_form(form_builder, options)
+    set_value_in_hash options
+    if options.delete(:for) == :search
+      build_search_form(form_builder, options)
+    else
+      build_for_admin_interface_form(form_builder, options)
+    end
+  end
+
+  def search(criteria, field, query)
+    criteria.where("#{field}.ranges.#{query}" => true)
+  end
+
+
+
+  private
+
+  def build_for_admin_interface_form(form_builder, options)
+    delimiter = options[:delimeter].presence || ' — '
+
+    default_style = {class: 'form-control input-small'}
+    result = ['<div class="form-inline">']
+    form_builder.fields_for :value do |ff|
+      from_field = ff.number_field :from, options.merge(value: value.try(:[], 'from')).reverse_merge(default_style)
+      till_field = ff.number_field :till, options.merge(value: value.try(:[], 'till')).reverse_merge(default_style)
+      result << [from_field, till_field].join(delimiter).html_safe
+    end
+    result << '</div>'
+    result.join.html_safe
+  end
+
+  def build_search_form(form_builder, options)
+    delimiter = options[:delimeter].presence || default_integer_range_delimiter
+    form_fields = []
+    visual_representation = options.delete(:as)
+    show_only = options.delete(:only)
+
+    if visual_representation == :select
+      klazz = options.delete :class
+      form_fields << form_builder.select(:value, [['', '']] + humanized_integer_ranges_for_select, options.merge(selected: options[:value]), {class: klazz} )
+    else
+      show_all_fields = !show_only
+
+      if show_all_fields or show_only == :low
+        form_fields << form_builder.text_field(:from, options.merge(index: 'value', value: value.try(:[], 'from')))
+      end
+
+      if show_all_fields or show_only == :high
+        form_fields << form_builder.text_field(:till, options.merge(index: 'value', value: value.try(:[], 'till')))
+      end
+    end
+
+    form_fields.join(delimiter).html_safe
+  end
+
+  def default_integer_range_delimiter
+    "–"
+  end
+
+  def humanized_integer_ranges_for_select
+    @extra_options[:ranges].map do |range_string|
+      low, high = range_string.split(range_string_delimiter)
+      if low.to_i.to_s != low.to_s
+        option_text = "до #{high}"
+      elsif high.to_i.to_s != high.to_s
+        option_text = "свыше #{low}"
+      else
+        option_text = [low, high].join(default_integer_range_delimiter)
+      end
+      [option_text, range_string]
+    end
+  end
+
+  def range_string_delimiter
+    /[-:\\]/
+  end
+end

data/lib/cck_forms/parameter_type_class/map.rb

@@ -0,0 +1,259 @@
+class CckForms::ParameterTypeClass::Map
+  include CckForms::ParameterTypeClass::Base
+
+  MAP_TYPE_GOOGLE = 'google'.freeze
+  MAP_TYPE_YANDEX = 'yandex'.freeze
+  DEFAULT_MAP_TYPE = MAP_TYPE_GOOGLE
+
+  mattr_accessor :map_providers
+  @@map_providers = [MAP_TYPE_YANDEX, MAP_TYPE_GOOGLE]
+
+  mattr_accessor :google_maps_api_key
+
+  def self.name
+    'Точка на карте'
+  end
+
+  # Было базе: {latlon: [x, y], zoom: z}
+  #
+  # Стало в модели: {
+  #   latitude: x,
+  #   longitude: y,
+  #   zoom: z
+  # }
+  def self.demongoize_value(value, parameter_type_class=nil)
+    value = value.to_h
+    value.stringify_keys!
+    latlon = value['latlon'] || []
+
+    latitude = value['latitude'] || latlon[0]
+    longitude = value['longitude'] || latlon[1]
+    type_of_map = value['type'] || DEFAULT_MAP_TYPE
+
+    {
+        'latitude' => latitude,
+        'longitude' => longitude,
+        'zoom' => value['zoom'].presence,
+        'type' => type_of_map
+    }
+  end
+
+
+  # Было в модели: {
+  #   latitude: x,
+  #   longitude: y,
+  #   zoom: z
+  # }
+  #
+  # Стало в базе: {latlon: [x, y], zoom: z}
+  def mongoize
+    value = self.value.is_a?(Hash) ? self.value : {}
+    return {
+        'latlon' => [value['latitude'].presence, value['longitude'].presence],
+        'zoom' => value['zoom'].presence,
+        'type' => value['type'].presence || DEFAULT_MAP_TYPE
+    }
+  end
+
+  # Если переданы :width и :height, вызовет img_tag, иначе вернет пустую строку.
+  def to_s(options = {})
+    options ||= {}
+    if options[:width].to_i > 0 and options[:height].to_i > 0
+      return a_tag(to_s(options.except :link), options[:link]) if options[:link]
+      return img_tag options[:width], options[:height]
+    end
+
+    ''
+  end
+
+  # Возвращает тэг IMG с картинкой карты и точкой на ней, если value не пустое (содержит координаты точки).
+  # См. Google/Yandex Maps Static API.
+  def img_tag(width, height, options = {})
+    map_type = value['type']
+
+    if value['latitude'].present? and value['longitude'].present?
+      if map_type == MAP_TYPE_GOOGLE
+        zoom_if_any = value['zoom'].present? ? "&zoom=#{value['zoom']}" : nil
+        marker_size_if_any = options[:marker_size] ? "|size:#{options[:marker_size]}" : nil
+
+        url = %Q(
+          http://maps.googleapis.com/maps/api/staticmap?
+            language=ru&
+            size=#{width}x#{height}&
+            maptype=roadmap&
+            markers=color:red#{marker_size_if_any}|
+            #{value['latitude']},#{value['longitude']}&
+            sensor=false
+            #{zoom_if_any}
+        ).gsub(/\s+/, '')
+
+      else # yandex
+        zoom_if_any = value['zoom'].present? ? "&z=#{value['zoom']}" : nil
+        marker_size = options[:marker_size] == :large ? 'l' : 'm'
+
+        url = %Q(
+          http://static-maps.yandex.ru/1.x/?
+            l=map&
+            size=#{width},#{height}&
+            pt=#{value['longitude']},#{value['latitude']},pm2bl#{marker_size}&
+            #{zoom_if_any}
+        ).gsub(/\s+/, '')
+      end
+      %Q(<img src="#{url}" width="#{width}" height="#{height}" />).html_safe
+    else
+      ''
+    end
+  end
+
+  # Возвращает тэг A со ссылкой на карту с маркером объекта.
+  def a_tag(content, attrs)
+    if attrs[:href] = url
+      attrs_strings = []
+      attrs.each_pair { |name, value| attrs_strings << sprintf('%s="%s"', name, value) }
+      sprintf '<a %s>%s</a>', attrs_strings.join, content
+    else
+      ''
+    end
+  end
+
+  # Возвращает урл на карту.
+  def url
+    if value['latitude'].present? and value['longitude'].present?
+      if value['type'] == MAP_TYPE_GOOGLE
+        sprintf(
+          'http://maps.google.com/maps?%s&t=m&q=%s+%s',
+          value['zoom'].present? ? 'z=' + value['zoom'] : '',
+          value['latitude'],
+          value['longitude']
+        )
+      else # yandex
+        sprintf(
+          'http://maps.yandex.ru/?l=map&text=%s&ll=%s%s',
+          [value['latitude'], value['longitude']].join(','),
+          [value['longitude'], value['latitude']].join(','),
+          value['zoom'].present? ? '&z=' + value['zoom'] : nil
+        )
+      end
+    end
+  end
+
+  # Построим форму для карты. Представляет собой 3 спрятанных поля latitude, longitude, zoom. Затем рядом ставится ДИВ,
+  # на который вешается карта Гугла, и с помощью скриптов изменение полей привязывается к кликам на карте и изменению
+  # масштаба.
+  #
+  # 1 клик на пустом месте ставит точку (пишем в поля), старая точка при этом удаляется. Клик на точке удаляет ее
+  # (очищаем поля).
+  #
+  # Также, слушает событие change поля "город" (facility_page_cck_params_city_value), чтобы по известным названиям
+  # городов отцентровать карту на выбранном городе.
+  #
+  # options:
+  #
+  #   value     - тек. значение, см. self.demongoize_value
+  #   width     - ширина карты
+  #   height    - высота карты
+  #   latitude  - широта центра карты, если ничего не выбрано
+  #   longitude - долгота центра карты, если ничего не выбрано
+  #   zoom      - масштаб карты, если ничего не выбрано
+
+  def build_form(form_builder, options)
+    set_value_in_hash options
+
+    options = {
+        width: 550,
+        height: 400,
+        latitude: 47.757581,
+        longitude: 67.298256,
+        zoom: 5,
+        value: {},
+    }.merge options
+
+    value = (options[:value].is_a? Hash) ? options[:value].stringify_keys : {}
+
+    inputs = []
+    id = ''
+
+    form_builder.tap do |value_builder|
+      id = form_builder_name_to_id value_builder
+      inputs << value_builder.hidden_field(:latitude,  value: value['latitude'])
+      inputs << value_builder.hidden_field(:longitude, value: value['longitude'])
+      inputs << value_builder.hidden_field(:zoom,      value: value['zoom'])
+      inputs << value_builder.hidden_field(:type,      value: value['type'])
+    end
+
+    city_id = id.clone
+    city_id['map'] = 'city'
+    city_id += '_value'
+
+    cities_js = []
+    city_class = if defined?(KazakhstanCities::City) then KazakhstanCities::City elsif defined?(City) then City end
+    if city_class
+      city_class.all.each do |city|
+        cities_js.push [city.id, {lat: city.lat.to_f, lon: city.lon.to_f, zoom: city.zoom.to_i}]
+      end
+    end
+    cities_js = Hash[cities_js].to_json
+
+    allowed_maps = @@map_providers
+    map_names = {'google' => 'Google', 'yandex' => 'Яндекс'}
+    selected_map_type = value['type'].in?(allowed_maps) ? value['type'] : allowed_maps.first
+
+    switchers = []
+    switchers << %Q|<div class="btn-group cck-map-switchers #{'hide' if allowed_maps.count < 2}" style="margin-top: 5px;">|
+    allowed_maps.map do |map|
+      switchers << %Q|<a class="btn btn-default #{selected_map_type == map ? 'active' : nil}" href="#" data-map-type="#{map}">#{map_names[map]}</a>|
+    end
+    switchers << '</div>'
+
+    map_html_containers = []
+    allowed_maps.each do |map|
+      map_html_containers.push %Q|<div id="#{id}_#{map}" data-id=#{id} class="map_widget" style="display: none; width: #{options[:width]}px; height: #{options[:height]}px"></div>|
+    end
+
+    api_key = @@google_maps_api_key.present? ? "&key=#{@@google_maps_api_key}" : nil
+
+    %Q|
+    <div class="map-canvas">
+      #{inputs.join}
+
+      <script>
+      var mapsReady = {google: false, yandex: false, callback: null, on: function(callback) {
+        this.callback = callback;
+        this.fireIfReady();
+      }, fireIfReady: function() {
+        if(this.google && this.yandex && this.callback) { this.callback() }
+      }}
+
+      function googleMapReady() { mapsReady.google = true; mapsReady.fireIfReady() }
+      function yandexMapReady() { mapsReady.yandex = true; mapsReady.fireIfReady() }
+
+      function loadMapScripts() {
+        var script;
+        script = document.createElement('script');
+        script.type = 'text/javascript';
+        script.src = 'https://maps.googleapis.com/maps/api/js?v=3.exp&sensor=false&callback=googleMapReady#{api_key}';
+        document.body.appendChild(script);
+
+        script = document.createElement('script');
+        script.type = 'text/javascript';
+        script.src = 'https://api-maps.yandex.ru/2.0/?coordorder=longlat&load=package.full&wizard=constructor&lang=ru-RU&onload=yandexMapReady';
+        document.body.appendChild(script);
+      }
+
+      window.onload = loadMapScripts;
+      </script>
+
+      <div data-map-data-source data-options='#{options.to_json}' data-id="#{id}" data-cities='#{cities_js}' data-cityid="#{city_id}" data-allowed-maps='#{allowed_maps.to_json}' style="width: #{options[:width]}px; height: #{options[:height]}px">
+        #{map_html_containers.join}
+      </div>
+
+      #{switchers.join}
+    </div>
+    |
+  end
+
+  def to_diff_value(options = {})
+    demongoize_value!
+    img_tag(64, 64, marker_size: :small)
+  end
+end

data/lib/cck_forms/parameter_type_class/phones.rb

@@ -0,0 +1,204 @@
+class CckForms::ParameterTypeClass::Phones
+  include CckForms::ParameterTypeClass::Base
+
+  MIN_PHONES_IN_FORM  = Rails.application.config.cck_forms.phones.min_phones_in_form
+  MOBILE_CODES        = Rails.application.config.cck_forms.phones.mobile_codes
+  PREFIX              = Rails.application.config.cck_forms.phones.prefix
+  NUMBER_PARTS_GLUE   = Rails.application.config.cck_forms.phones.number_parts_glue
+
+  def self.name
+    'Телефоны'
+  end
+
+  # Проверяет входной массив на наличие телефонов (хэша с ключами prefix, code и number).
+  # На выходе выдает очищенный массив хэшей с такими ключами, пропуская пустые телефоны.
+  #
+  # Было в модели: [{prefix: '+7'}, {code: ' 123 ', number: '1234567', zzz: ''}]
+  #
+  # Стало в базе: [{prefix: '', code: '123', number: '1234567'}]
+  def mongoize
+    value = self.value
+    return [] unless value.respond_to? :each
+
+    value = value.values if value.is_a? Hash
+
+    result = []
+    value.each do |phone|
+      phone = {} if phone.blank? or !(phone.is_a? Hash)
+      phone = blank_phone.merge phone.stringify_keys
+
+      phone['prefix'] = phone['prefix'].strip
+      phone['code']   = clean_numbers(phone['code'].to_s)
+      phone['number'] = clean_numbers(phone['number'].to_s)
+
+      if phone['code'].present? or phone['number'].present?
+        result << {
+            'prefix' => phone['prefix'],
+            'code'   => phone['code'],
+            'number' => phone['number'],
+        }
+      end
+    end
+
+    result
+  end
+
+  # Просто приводит телефоны в базе в соответствие формату.
+  def self.demongoize_value(value, parameter_type_class=nil)
+    if value
+      value.map do |phone|
+        phone = phone.stringify_keys!
+        {
+            'prefix' => phone['prefix'],
+            'code'   => phone['code'],
+            'number' => phone['number'],
+        }
+      end
+    end
+  end
+
+  # Строит форму для заполнения телефонов. В ней будет минимум MIN_PHONES_IN_FORM телефонов, если их меньше, остальные
+  # будут добавлены пустые.
+  #
+  # Также, если заполнены все MIN_PHONES_IN_FORM, добавит 1 пустое поле, чтобы можно было добавить новый телефон.
+  #
+  # Возвращает ХТМЛ.
+  def build_form(form_builder, options)
+    set_value_in_hash options
+    value = options[:value].presence
+    value = [] unless !value.blank? and value.is_a? Array
+
+    result = value.map { |phone| build_single_form(form_builder, phone) }
+
+    [1, CckForms::ParameterTypeClass::Phones::MIN_PHONES_IN_FORM - result.length].max.times { result << build_single_form(form_builder, {}) }
+
+    id = form_builder_name_to_id form_builder
+    sprintf '<div id="%s">%s</div>%s', id, result.join, script(id)
+  end
+
+  # Строит форму для 1 телефона из значения вида {prefix: '', code: '', number: ''}
+  def build_single_form(form_builder, phone)
+    phone = {} unless phone.is_a? Hash
+    phone = blank_phone.merge phone
+
+    phone_form = []
+
+    form_builder.fields_for(:value, index: '') do |phone_builder|
+      phone_form << phone_builder.text_field(:prefix, class: 'input-tiny form-control', value: phone['prefix'])
+      phone_form << phone_builder.text_field(:code,   class: 'input-mini form-control', value: phone['code'])
+      phone_form << phone_builder.text_field(:number, class: 'input-small form-control', value: phone['number'])
+    end
+
+    sprintf '<p class="form-inline">%s &mdash; %s &mdash; %s</p>', phone_form[0], phone_form[1], phone_form[2]
+  end
+
+  # Возвращает 1 пустой телефон (хэш вида {prefix: '+7', code: '', number: ''}). Так сказать, эталон.
+  def blank_phone
+    {
+        'prefix' => PREFIX,
+        'code'   => '',
+        'number' => '',
+    }
+  end
+
+  def script(id)
+    <<HTML
+    <script type="text/javascript">
+      $(function() {
+        var $phones = $("##{id}");
+        var doTimes = #{CckForms::ParameterTypeClass::Phones::MIN_PHONES_IN_FORM};
+
+        var createPhone = function() {
+          var $newPhone = $phones.children("p:last").clone();
+          $newPhone.children("input").each(function() {
+            var $this = $(this);
+            var isPrefix = $this.prop('name').match(/\\[prefix\\]$/);
+            $this.val(isPrefix ? "#{blank_phone['prefix']}" : '');
+            var index = $this.prop("id").match(/value_([0-9]+)_/);
+            if(!index) {
+              return;
+            }
+            index = index[1] * 1;
+            $this.prop("id", $this.prop("id").replace(index, index + 1));
+            $this.prop("name", $this.prop("name").replace(index, index + 1));
+          })
+          $phones.children("p:last").after($newPhone);
+        }
+
+        $phones.append('<a href="#" class="add_more">Добавить еще телефонов</a>');
+        $phones.children(".add_more").click(function() {
+          for(var i = 0; i < doTimes; ++ i) {
+            createPhone();
+          }
+          return false;
+        })
+      });
+    </script>
+HTML
+  end
+
+  def to_html(options = {})
+    phones_list = []
+    (value || []).each do |phone|
+      if phone['number'] && clean_numbers(phone['number'].to_s).present?
+        if phone['prefix'].present? || phone['code'].present?
+          prefix = phone['prefix'].present? ? "<span class=\"phone-prefix\">#{phone['prefix']}</span>" : ''
+          code = phone['code'].present? ? "<span class=\"phone-code\">#{phone['code']}</span>" : ''
+          start = sprintf(phone['code'].in?(MOBILE_CODES) ? '<span class="phone-mobile-prefix">%s(%s)</span>' : '<span class="phone-city-prefix">%s(%s)</span>', prefix, code)
+        else
+          start = ''
+        end
+
+        number = split_number(clean_numbers(phone['number'])).join(NUMBER_PARTS_GLUE)
+        phones_list << sprintf('<span class="phone">%s<span class="phone-number">%s</span></span>', start, number)
+      end
+    end
+
+    phones_list = phones_list.take(options[:limit]) if options[:limit]
+
+    if options[:as_list]
+      phones_list
+    else
+      phones_list.join(', ').html_safe
+    end
+  end
+
+  def to_s(options = {})
+    HTML::FullSanitizer.new.sanitize to_html(options)
+  end
+
+
+
+  private
+
+  # 123-45-67 asdasd -> 1234567
+  def clean_numbers(number)
+    number.gsub /\D/, ''
+  end
+
+  # 1234567 -> 123 45 67 с тэгами
+  def split_number(number)
+    if number.length > 4
+      tokens = []
+
+      # перевернем строку и разобъем на пары
+      number.reverse.scan(/.(?:.|$)/) do |token|
+        token.reverse!
+        if token.length == 1
+          tokens.last.prepend token
+        else
+          tokens << token
+        end
+      end
+
+      # сольем все обратно
+      tokens.reverse!
+      tokens.tap do |tokens|
+        tokens.map! { |token| yield token } if block_given?
+      end
+    else
+      yield number if block_given?
+      [number]
+    end
+  end
+end

data/lib/cck_forms/parameter_type_class/string.rb

@@ -0,0 +1,13 @@
+class CckForms::ParameterTypeClass::String
+  include CckForms::ParameterTypeClass::Base
+
+  def self.name
+    'Строка'
+  end
+
+  def build_form(form_builder, options)
+    set_value_in_hash options
+    attrs = @extra_options.slice(:maxlength, :pattern)
+    form_builder.text_field :value, {class: 'form-control'}.merge(attrs).merge(options)
+  end
+end

data/lib/cck_forms/parameter_type_class/string_collection.rb

@@ -0,0 +1,23 @@
+class CckForms::ParameterTypeClass::StringCollection
+  include CckForms::ParameterTypeClass::Base
+
+  def self.name
+    'Массив строк'
+  end
+
+  def mongoize
+    value.split "\r\n" if value.is_a? String
+  end
+
+  def self.demongoize_value(value, parameter_type_class=nil)
+    value = [value] if value.is_a? String
+    super
+  end
+
+  def build_form(form_builder, options)
+    set_value_in_hash options
+    options[:value] = value.join("\r\n") if value
+
+    form_builder.text_area :value, {cols: 50, rows: 5, class: 'form-control'}.merge(options)
+  end
+end

data/lib/cck_forms/parameter_type_class/text.rb

@@ -0,0 +1,18 @@
+class CckForms::ParameterTypeClass::Text
+  include CckForms::ParameterTypeClass::Base
+
+  def self.name
+    'Текст'
+  end
+
+  def build_form(form_builder, options)
+    set_value_in_hash options
+    form_builder.text_area :value, {cols: 50, rows: 5, class: 'form-control'}.merge(options)
+  end
+
+  def to_diff_value(options = {})
+    to_html.presence.try do |html|
+      "<div class='well well-small'>#{html}</div>".html_safe
+    end
+  end
+end