lib/carto/named_maps/template.rb
module Carto
module NamedMaps
class Template
NAMED_MAPS_VERSION = '0.0.1'.freeze
MAP_CONFIG_VERSION = '1.5.0'.freeze
NAME_PREFIX = 'tpl_'.freeze
AUTH_TYPE_OPEN = 'open'.freeze
AUTH_TYPE_SIGNED = 'token'.freeze
EMPTY_CSS = '#dummy{}'.freeze
TILER_WIDGET_TYPES = {
'category': 'aggregation',
'formula': 'formula',
'histogram': 'histogram',
'list': 'list',
'time-series': 'histogram'
}.freeze
DATAVIEW_TEMPLATE_OPTIONS = [:column, :aggregation, :aggregationColumn, :aggregation_column, :operation].freeze
def initialize(visualization)
# TODO: Remove when it's safe to assume this confussion won't happen.
raise 'Carto::NamedMaps::Template needs a Carto::Visualization' unless visualization.is_a?(Carto::Visualization)
@visualization = visualization
end
def to_hash
@template ||= stats_aggregator.timing('named-map.template-data') do
{
name: name,
auth: auth,
version: NAMED_MAPS_VERSION,
placeholders: placeholders,
layergroup: {
version: MAP_CONFIG_VERSION,
layers: layers,
stat_tag: @visualization.id,
dataviews: dataviews,
analyses: analyses_definitions
},
view: view
}
end
end
def to_json
to_hash.to_json
end
def name
(NAME_PREFIX + @visualization.id).gsub(/[^a-zA-Z0-9\-\_.]/, '').tr('-', '_')
end
private
def placeholders
placeholders = {}
layers = @visualization.layers
last_index, carto_layers_visibility_placeholders = layer_visibility_placeholders(layers.select(&:carto?))
_, torque_layer_visibility_placeholders = layer_visibility_placeholders(layers.select(&:torque?),
starting_index: last_index)
placeholders = placeholders.merge(carto_layers_visibility_placeholders)
placeholders = placeholders.merge(torque_layer_visibility_placeholders)
placeholders
end
def layer_visibility_placeholders(layers, starting_index: 0)
placeholders = {}
index = starting_index
layers.each do |layer|
placeholders["layer#{index}".to_sym] = {
type: 'number',
default: layer.options[:visible] ? 1 : 0
}
index += 1
end
[index, placeholders]
end
def layers
layers = []
layer_index = -1 # forgive me for I have sinned
is_builder = @visualization.builder?
@visualization.named_map_layers.each do |layer|
if layer.data_layer?
layer_index += 1
options = options_for_carto_and_torque_layers(layer, layer_index, is_builder)
layers.push(id: layer.id, type: 'cartodb', options: options)
elsif layer.base_layer?
layer_options = layer.options
if layer_options['type'] == 'Plain'
layers.push(type: 'plain', options: options_for_plain_basemap_layers(layer_options))
elsif !layer.gmapsbase?
# Tiler doesn't support rendering Google basemaps in static images. We skip them to avoid errors in
# dashboard previews, this way at least we get the data on a transparent background.
layers.push(type: 'http', options: options_for_http_basemap_layers(layer_options))
end
end
end
@visualization.torque_layers.each do |layer|
layer_index += 1
options = options_for_carto_and_torque_layers(layer, layer_index, is_builder)
layers.push(id: layer.id, type: 'torque', options: options)
end
layers
end
def options_for_plain_basemap_layers(layer_options)
layer_options['image'].present? ? { imageUrl: layer_options['image'] } : { color: layer_options['color'] }
end
def options_for_http_basemap_layers(layer_options)
options = {}
options[:urlTemplate] = layer_options['urlTemplate'] if layer_options['urlTemplate'].present?
options[:subdomains] = layer_options['subdomains'] if layer_options['subdomains'].present?
options[:tms] = layer_options['tms'] if layer_options['tms'].present?
options
end
def options_for_carto_and_torque_layers(layer, index, is_builder)
layer_options = layer.options.with_indifferent_access
tile_style = layer_options[:tile_style].strip if layer_options[:tile_style]
options = {
cartocss: tile_style.present? ? tile_style : EMPTY_CSS,
cartocss_version: layer_options.fetch('style_version')
}
layer_options_source = layer_options[:source]
if is_builder && layer_options_source
options[:source] = { id: layer_options_source }
else
options[:sql] = visibility_wrapped_sql(layer.default_query(@visualization.user), index)
end
options[:sql_wrap] = layer_options[:sql_wrap] || layer_options[:query_wrapper]
attributes, interactivity = attributes_and_interactivity(layer.infowindow, layer.tooltip)
options[:attributes] = attributes if attributes.present?
options[:interactivity] = interactivity if interactivity.present?
options
end
def visibility_wrapped_sql(sql, index)
"SELECT * FROM (#{sql}) AS wrapped_query WHERE <%= layer#{index} %>=1"
end
def attributes_and_interactivity(layer_infowindow, layer_tooltip)
click_fields = layer_infowindow['fields'] if layer_infowindow
hover_fields = layer_tooltip['fields'] if layer_tooltip
interactivity = []
attributes = {}
if hover_fields.present?
interactivity << hover_fields.map { |hover_field| hover_field.fetch('name') }
end
if click_fields.present?
interactivity << 'cartodb_id'
attributes = {
id: 'cartodb_id',
columns: click_fields.map { |click_field| click_field.fetch('name') }
}
end
[attributes, interactivity.join(',')]
end
def dataviews
dataviews = {}
@visualization.widgets.each do |widget|
dataviews[widget.id.to_s] = dataview_data(widget)
end
dataviews
end
def analyses_definitions
@visualization.analyses.map(&:analysis_definition_for_api)
end
def stats_aggregator
@@stats_aggregator_instance ||= CartoDB::Stats::EditorAPIs.instance
end
def dataview_data(widget)
options = widget.options.select { |k, _v| DATAVIEW_TEMPLATE_OPTIONS.include?(k) }
options[:aggregationColumn] = options.delete(:aggregation_column)
dataview_data = {
type: TILER_WIDGET_TYPES[widget.type.to_sym],
options: options
}
dataview_data[:source] = { id: widget.source_id } if widget.source_id.present?
dataview_data
end
def auth
visualization_for_auth = @visualization.non_mapcapped
method, valid_tokens = if visualization_for_auth.password_protected?
[AUTH_TYPE_SIGNED, [visualization_for_auth.get_auth_token]]
elsif visualization_for_auth.is_privacy_private?
[AUTH_TYPE_SIGNED, visualization_for_auth.allowed_auth_tokens]
else
[AUTH_TYPE_OPEN, nil]
end
auth = { method: method }
auth[:valid_tokens] = valid_tokens if valid_tokens
auth
end
def view
valid_state? ? view_from_state : view_from_map
end
def preview_layers
preview_layers = {}
@visualization.data_layers.each do |layer|
preview_layers[:"#{layer.id}"] = layer.options[:visible] || false
end
preview_layers
end
def valid_state?
state = @visualization.state.json
map = state[:map]
state.present? && map.present? && map[:center].present? && map[:sw].present? && map[:ne].present? &&
map[:sw][0].present? && map[:sw][1].present? && map[:ne][0].present? && map[:ne][1].present?
end
def view_from_map
map = @visualization.map
return unless map
center_data = map.center_data
data = {
zoom: map.zoom,
center: {
lng: center_data[1].to_f,
lat: center_data[0].to_f
}
}
bounds_data = map.view_bounds_data
filter_and_merge_view(bounds_data, data)
end
def view_from_state
state = @visualization.state.json
center_data = state[:map][:center]
center_and_zoom = {
zoom: state[:map][:zoom],
center: {
lng: center_data[1],
lat: center_data[0]
}
}
bounds_data = {
west: state[:map][:sw][0],
south: state[:map][:sw][1],
east: state[:map][:ne][0],
north: state[:map][:ne][1]
}
filter_and_merge_view(bounds_data, center_and_zoom)
end
def filter_and_merge_view(bounds_data, center_and_zoom)
# INFO: Don't return 'bounds' if any of the points is 0 to avoid static map trying to go too small zoom level
if bounds_data[:west] != 0 || bounds_data[:south] != 0 || bounds_data[:east] != 0 || bounds_data[:north] != 0
center_and_zoom[:bounds] = bounds_data
end
center_and_zoom.merge!(preview_layers: preview_layers)
end
end
end
end