cartodb/app/models/carto/visualization.rb
2020-06-15 10:58:47 +08:00

835 lines
22 KiB
Ruby

require 'active_record'
require 'cartodb-common'
require_relative '../visualization/stats'
require_dependency 'carto/named_maps/api'
require_dependency 'carto/helpers/auth_token_generator'
require_dependency 'carto/uuidhelper'
require_dependency 'carto/visualization_invalidation_service'
require_dependency 'carto/visualization_backup_service'
module Carto::VisualizationDependencies
def fully_dependent_on?(user_table)
derived? && layers_dependent_on(user_table).count == data_layers.count
end
def partially_dependent_on?(user_table)
derived? && layers_dependent_on(user_table).count.between?(1, data_layers.count - 1)
end
def dependent_on?(user_table)
derived? && layers_dependent_on(user_table).any?
end
private
def layers_dependent_on(user_table)
data_layers.select { |l| l.depends_on?(user_table) }
end
end
class Carto::Visualization < ActiveRecord::Base
include CacheHelper
include Carto::UUIDHelper
include Carto::AuthTokenGenerator
include Carto::VisualizationDependencies
include Carto::VisualizationBackupService
TYPE_CANONICAL = 'table'.freeze
TYPE_DERIVED = 'derived'.freeze
TYPE_SLIDE = 'slide'.freeze
TYPE_REMOTE = 'remote'.freeze
TYPE_KUVIZ = 'kuviz'.freeze
VALID_TYPES = [TYPE_CANONICAL, TYPE_DERIVED, TYPE_SLIDE, TYPE_REMOTE, TYPE_KUVIZ].freeze
KIND_GEOM = 'geom'.freeze
KIND_RASTER = 'raster'.freeze
PRIVACY_PUBLIC = 'public'.freeze
PRIVACY_PRIVATE = 'private'.freeze
PRIVACY_LINK = 'link'.freeze
PRIVACY_PROTECTED = 'password'.freeze
PRIVACIES = [PRIVACY_LINK, PRIVACY_PROTECTED, PRIVACY_PUBLIC, PRIVACY_PRIVATE].freeze
VERSION_BUILDER = 3
V2_VISUALIZATIONS_REDIS_KEY = 'vizjson2_visualizations'.freeze
scope :remotes, -> { where(type: TYPE_REMOTE) }
# INFO: disable ActiveRecord inheritance column
self.inheritance_column = :_type
belongs_to :user, -> { select(Carto::User::DEFAULT_SELECT) }, inverse_of: :visualizations
belongs_to :full_user, -> { readonly(true) }, class_name: Carto::User, inverse_of: :visualizations,
primary_key: :id, foreign_key: :user_id
belongs_to :permission, inverse_of: :visualization, dependent: :destroy
has_many :likes, foreign_key: :subject
has_many :shared_entities, foreign_key: :entity_id, inverse_of: :visualization, dependent: :destroy
has_one :external_source, class_name: Carto::ExternalSource, dependent: :destroy, inverse_of: :visualization
has_many :unordered_children, class_name: Carto::Visualization, foreign_key: :parent_id
has_many :overlays, -> { order(:order) }, dependent: :destroy, inverse_of: :visualization
belongs_to :active_layer, class_name: Carto::Layer
belongs_to :map, class_name: Carto::Map, inverse_of: :visualization, dependent: :destroy
has_one :asset, class_name: Carto::Asset, inverse_of: :visualization, dependent: :destroy
has_many :related_templates, class_name: Carto::Template, foreign_key: :source_visualization_id
has_one :synchronization, class_name: Carto::Synchronization, dependent: :destroy
has_many :external_sources, class_name: Carto::ExternalSource
has_many :analyses, class_name: Carto::Analysis
has_many :mapcaps, -> { order('created_at DESC') }, class_name: Carto::Mapcap, dependent: :destroy
has_one :state, class_name: Carto::State, autosave: true
has_many :snapshots, class_name: Carto::Snapshot, dependent: :destroy
validates :name, :privacy, :type, :user_id, :version, presence: true
validates :privacy, inclusion: { in: PRIVACIES }
validates :type, inclusion: { in: VALID_TYPES }
validate :validate_password_presence
validate :validate_privacy_changes
validate :validate_user_not_viewer, on: :create
before_validation :set_default_version, :set_register_table_only
before_create :set_random_id, :set_default_permission
before_save :remove_password_if_unprotected
after_save :propagate_attribution_change
after_save :propagate_privacy_and_name_to, if: :table
before_destroy :backup_visualization
after_commit :perform_invalidations
attr_accessor :register_table_only
def set_register_table_only
self.register_table_only = false
# This is a callback, returning `true` avoids halting because of assignment `false` return value
true
end
def set_default_version
self.version ||= user.try(:new_visualizations_version)
end
DELETED_COLUMNS = ['state_id', 'url_options'].freeze
def self.columns
super.reject { |c| DELETED_COLUMNS.include?(c.name) }
end
def size
# Only canonical visualizations (Datasets) have a related table and then count against disk quota,
# but we want to not break and even allow ordering by size multiple types
if user_table
user_table.size
elsif remote? && external_source
external_source.size
else
0
end
end
def tags
tags = super
tags == nil ? [] : tags
end
def tags=(tags)
tags.reject!(&:blank?) if tags
super(tags)
end
def user_table
map.user_table if map
end
def table
@table ||= user_table.try(:service)
end
def layers_with_data_readable_by(user)
return [] unless map
map.layers.select { |l| l.data_readable_by?(user) }
end
def related_tables
@related_tables ||= get_related_tables
end
def related_tables_readable_by(user)
layers_with_data_readable_by(user).map { |l| l.user_tables_readable_by(user) }.flatten.uniq
end
def related_canonical_visualizations
@related_canonical_visualizations ||= get_related_canonical_visualizations
end
def stats
@stats ||= CartoDB::Visualization::Stats.new(self).to_poro
end
def transition_options
@transition_options ||= (slide_transition_options.nil? ? {} : JSON.parse(slide_transition_options).symbolize_keys)
end
def transition_options=(value)
self.slide_transition_options = ::JSON.dump(value.nil? ? DEFAULT_OPTIONS_VALUE : value)
end
def children
ordered = []
children_vis = self.unordered_children
if children_vis.count > 0
ordered << children_vis.select { |vis| vis.prev_id.nil? }.first
while !ordered.last.next_id.nil?
target = ordered.last.next_id
unless target.nil?
ordered << children_vis.select { |vis| vis.id == target }.first
end
end
end
ordered
end
# TODO: refactor next methods, all have similar naming but some receive user and some others user_id
def liked_by?(user)
likes_by_user(user).any?
end
def likes_by_user(user)
likes.where(actor: user.id)
end
def add_like_from(user)
unless has_read_permission?(user)
raise UnauthorizedLikeError
end
likes.create!(actor: user.id)
self
rescue ActiveRecord::RecordNotUnique
raise AlreadyLikedError
end
def remove_like_from(user)
unless has_read_permission?(user)
raise UnauthorizedLikeError
end
item = likes.where(actor: user.id)
item.first.destroy unless item.first.nil?
self
end
def send_like_email(current_viewer, vis_preview_image)
if self.type == Carto::Visualization::TYPE_CANONICAL
::Resque.enqueue(::Resque::UserJobs::Mail::TableLiked, self.id, current_viewer.id, vis_preview_image)
elsif self.type == Carto::Visualization::TYPE_DERIVED
::Resque.enqueue(::Resque::UserJobs::Mail::MapLiked, self.id, current_viewer.id, vis_preview_image)
end
end
def is_viewable_by_user?(user)
is_publically_accesible? || has_read_permission?(user)
end
def is_accesible_by_user?(user)
is_viewable_by_user?(user) || password_protected?
end
def is_accessible_with_password?(user, password)
is_viewable_by_user?(user) || password_valid?(password)
end
def is_publically_accesible?
(public? || public_with_link?) && published?
end
def writable_by?(user)
(user_id == user.id && !user.viewer?) || has_write_permission?(user)
end
def varnish_key
"#{user.database_name}:#{sorted_related_table_names},#{id}"
end
def surrogate_key
get_surrogate_key(CartoDB::SURROGATE_NAMESPACE_VISUALIZATION, id)
end
def qualified_name(viewer_user = nil)
if viewer_user.nil? || owner?(viewer_user)
name
else
"#{user.sql_safe_database_schema}.#{name}"
end
end
# Despite storing always a named map, no need to retrieve it for "public" visualizations
def retrieve_named_map?
password_protected? || has_private_tables?
end
def has_password?
!password_salt.nil? && !encrypted_password.nil?
end
def type_slide?
type == TYPE_SLIDE
end
def kind_raster?
kind == KIND_RASTER
end
def canonical?
type == TYPE_CANONICAL
end
# TODO: remove. Kept for backwards compatibility with ::Permission model
def table?
type == TYPE_CANONICAL
end
def derived?
type == TYPE_DERIVED
end
def remote?
type == TYPE_REMOTE
end
def kuviz?
type == TYPE_KUVIZ
end
def layers
map ? map.layers : []
end
def data_layers
map ? map.data_layers : []
end
def carto_layers
map ? map.carto_layers : []
end
def user_layers
map ? map.user_layers : []
end
def torque_layers
map ? map.torque_layers : []
end
def other_layers
map ? map.other_layers : []
end
def base_layers
map ? map.base_layers : []
end
def named_map_layers
map ? map.named_map_layers : []
end
def password_valid?(password)
password_protected? &&
Carto::Common::EncryptionService.verify(password: password, secure_password: encrypted_password,
salt: password_salt, secret: Cartodb.config[:password_secret])
end
def organization?
privacy == PRIVACY_PRIVATE && !permission.acl.empty?
end
def password_protected?
privacy == PRIVACY_PROTECTED
end
def private?
is_privacy_private? && !organization?
end
def is_privacy_private?
privacy == PRIVACY_PRIVATE
end
def public?
privacy == PRIVACY_PUBLIC
end
def public_with_link?
self.privacy == PRIVACY_LINK
end
def editable?
!(kind_raster? || type_slide?)
end
def get_auth_tokens
[get_auth_token]
end
def mapviews
@mapviews ||= CartoDB::Visualization::Stats.mapviews(stats)
end
def total_mapviews
@total_mapviews ||= CartoDB::Visualization::Stats.new(self, nil).total_mapviews
end
def geometry_types
@geometry_types ||= user_table.geometry_types if user_table
end
def table_service
user_table.try(:service)
end
def has_read_permission?(user)
user && (owner?(user) || (permission && permission.user_has_read_permission?(user)))
end
alias :can_view_private_info? :has_read_permission?
def estimated_row_count
user_table.try(:row_count)
end
def actual_row_count
user_table.try(:actual_row_count)
end
def license_info
if !license.nil?
Carto::License.find(license.to_sym)
end
end
def can_be_cached?
!is_privacy_private?
end
def widgets
# Preload widgets for all layers
ActiveRecord::Associations::Preloader.new.preload(layers, :widgets)
layers.map(&:widgets).flatten
end
def analysis_widgets
widgets.select { |w| w.source_id.present? }
end
def attributions_from_derived_visualizations
related_canonical_visualizations.map(&:attributions).reject(&:blank?)
end
def delete_from_table
destroy if persisted?
end
def allowed_auth_tokens
entities = [user] + permission.entities_with_read_permission
entities.map(&:get_auth_token)
end
# - v2 (Editor): not private
# - v3 (Builder): not derived or not private, mapcapped
# This Ruby code should match the SQL code at Carto::VisualizationQueryBuilder#build section for @only_published.
def published?
!is_privacy_private? && (!builder? || !derived? || mapcapped?)
end
def builder?
version == VERSION_BUILDER
end
MAX_MAPCAPS_PER_VISUALIZATION = 1
def create_mapcap!
unless mapcaps.count < MAX_MAPCAPS_PER_VISUALIZATION
mapcaps.last.destroy
end
auto_generate_indices_for_all_layers
mapcaps.create!
end
def mapcapped?
latest_mapcap.present?
end
def latest_mapcap
mapcaps.first
end
def uses_builder_features?
builder? || analyses.any? || widgets.any? || mapcapped?
end
def add_source_analyses
return unless analyses.empty?
data_layers.each_with_index do |layer, index|
analysis = Carto::Analysis.source_analysis_for_layer(layer, index)
if analysis.save
layer.options[:source] = analysis.natural_id
layer.options[:letter] = analysis.natural_id.first
layer.save
else
CartoDB::Logger.warning(message: 'Couldn\'t add source analysis for layer', user: user, layer: layer)
end
end
end
def ids_json
layers_for_hash = layers.map do |layer|
{ layer_id: layer.id, widgets: layer.widgets.map(&:id) }
end
{
visualization_id: id,
map_id: map.id,
layers: layers_for_hash
}
end
def populate_ids(ids_json)
self.id = ids_json[:visualization_id]
map.id = ids_json[:map_id]
map.layers.each_with_index do |layer, index|
stored_layer_ids = ids_json[:layers][index]
stored_layer_id = stored_layer_ids[:layer_id]
layer.id = stored_layer_id
layer.maps = [map]
layer.widgets.each_with_index do |widget, widget_index|
widget.id = stored_layer_ids[:widgets][widget_index]
widget.layer_id = stored_layer_id
end
end
end
def for_presentation
mapcapped? ? latest_mapcap.regenerate_visualization : self
end
# TODO: we should make visualization privacy/security methods aware of mapcaps and make those
# deal with all the different the cases internally.
# See https://github.com/CartoDB/cartodb/pull/9678
def non_mapcapped
persisted? ? self : Carto::Visualization.find(id)
end
def mark_as_vizjson2
$tables_metadata.SADD(V2_VISUALIZATIONS_REDIS_KEY, id)
end
def uses_vizjson2?
$tables_metadata.SISMEMBER(V2_VISUALIZATIONS_REDIS_KEY, id) > 0
end
def open_in_editor?
!builder? && uses_vizjson2?
end
def can_be_automatically_migrated_to_v3?
overlays.builder_incompatible.none?
end
def state
super ? super : build_state
end
def can_be_private?
derived? ? user.try(:private_maps_enabled) : user.try(:private_tables_enabled)
end
# TODO: Backward compatibility with Sequel
def store_using_table(_table_privacy_changed = false)
store
end
def store
save!
self
end
def is_owner?(user)
user && user.id == user_id
end
def unlink_from(user_table)
layers_dependent_on(user_table).each do |layer|
Carto::Analysis.find_by_natural_id(id, layer.source_id).try(:destroy) if layer.source_id
layer.destroy
end
end
def invalidate_after_commit
# This marks this visualization as affected by this transaction, so AR will call its `after_commit` hook, which
# performs the actual invalidations. This takes this operation outside of the DB transaction to avoid long locks
if self.class.connection.open_transactions.zero?
raise 'invalidate_after_commit should be called within a transaction'
end
add_to_transaction
true
end
# TODO: Privacy manager compatibility, can be removed after removing ::UserTable
alias :invalidate_cache :invalidate_after_commit
def has_permission?(user, permission_type)
return false if user.viewer && permission_type == Carto::Permission::ACCESS_READWRITE
return is_owner?(user) if permission_id.nil?
is_owner?(user) || permission.permitted?(user, permission_type)
end
def ensure_valid_privacy
self.privacy = default_privacy if privacy.nil?
self.privacy = PRIVACY_PUBLIC unless can_be_private?
end
def default_privacy
can_be_private? ? PRIVACY_LINK : PRIVACY_PUBLIC
end
def privacy=(privacy)
super(privacy.try(:downcase))
end
def password=(value)
if value.present?
self.password_salt = ""
self.encrypted_password = Carto::Common::EncryptionService.encrypt(password: value,
secret: Cartodb.config[:password_secret])
end
end
def synced?
synchronization.present?
end
def dependent_visualizations
user_table.try(:dependent_visualizations) || []
end
def backup_visualization(category = Carto::VisualizationBackup::CATEGORY_VISUALIZATION)
return true if remote?
if map && !destroyed?
create_visualization_backup(visualization: self, category: category)
end
end
private
def remove_password
self.password_salt = nil
self.encrypted_password = nil
end
def perform_invalidations
invalidation_service.invalidate
rescue => e
# This is called at an after_commit. If there's any error, we won't notice
# but the after_commit chain stops.
# This was discovered during #12844, because "Updates changes even if named maps communication fails" test
# begun failing because Overlay#invalidate_cache invokes this method directly.
# We chose to log and continue to keep coherence on calls to this outside the callback.
CartoDB::Logger.error(message: "Error on visualization invalidation", exception: e, visualization_id: id)
end
def propagate_privacy_and_name_to
raise "Empty table sent to propagate_privacy_and_name_to()" unless table
propagate_privacy if privacy_changed? && canonical?
propagate_name if name_was != name # name_changed? returns false positives in changes like a->A->a (sanitization)
end
def propagate_privacy
table.reload
if privacy && table.privacy_text.casecmp(privacy) != 0 # privacy is different, case insensitive
CartoDB::TablePrivacyManager.new(table).set_from_visualization(self).update_cdb_tablemetadata
end
end
def propagate_name
# TODO: Move this to ::Table?
return if table.changing_name?
table.register_table_only = register_table_only
table.name = name
if table.name != name
# Sanitization. For example, spaces -> _
update_column(:name, table.name)
end
table.update(name: name)
if name_changed?
support_tables.rename(name_was, name, true, name_was)
end
self
rescue => exception
if name_changed? && !(exception.to_s =~ /relation.*does not exist/)
revert_name_change(name_was)
end
raise CartoDB::InvalidMember.new(exception.to_s)
end
def revert_name_change(previous_name)
self.name = previous_name
store
rescue => exception
raise CartoDB::InvalidMember.new(exception.to_s)
end
def propagate_attribution_change
table.propagate_attribution_change(attributions) if table && attributions_changed?
end
def support_tables
@support_tables ||= CartoDB::Visualization::SupportTables.new(
user.in_database, parent_id: id, parent_kind: kind, public_user_roles: user.db_service.public_user_roles
)
end
def auto_generate_indices_for_all_layers
user_tables = data_layers.map(&:user_tables).flatten.uniq
user_tables.each do |ut|
::Resque.enqueue(::Resque::UserDBJobs::UserDBMaintenance::AutoIndexTable, ut.id)
end
end
def set_random_id
# This should be done with a DB default
self.id ||= random_uuid
end
def set_default_permission
self.permission ||= Carto::Permission.create(owner: user, owner_username: user.username)
end
def has_private_tables?
!related_tables.index { |table| table.private? }.nil?
end
def sorted_related_table_names
mapped_table_names = related_tables.map { |table| "#{user.database_schema}.#{table.name}" }
mapped_table_names.sort { |i, j| i <=> j }.join(',')
end
def get_related_tables
return [] unless map
map.data_layers.flat_map(&:user_tables).uniq
end
def get_related_canonical_visualizations
get_related_visualizations_by_types([TYPE_CANONICAL])
end
def get_related_visualizations_by_types(types)
Carto::Visualization.where(map_id: related_tables.map(&:map_id), type: types).all
end
def has_write_permission?(user)
user && !user.viewer? && (owner?(user) || (permission && permission.user_has_write_permission?(user)))
end
def owner?(user)
user_id == user.id
end
def validate_password_presence
errors.add(:password, 'required for protected visualization') if password_protected? && !has_password?
end
def remove_password_if_unprotected
remove_password unless password_protected?
end
def validate_privacy_changes
return unless privacy_changed? && derived?
if is_privacy_private? && !user.try(:private_maps_enabled?)
errors.add(:privacy, 'cannot be set to private')
elsif (privacy_was == Carto::Visualization::PRIVACY_PRIVATE ||
(!privacy_was && privacy != Carto::Visualization::PRIVACY_PRIVATE)) &&
CartoDB::QuotaChecker.new(user).will_be_over_public_map_quota?
errors.add(:privacy, 'over account public map quota')
end
end
def validate_user_not_viewer
if user.viewer
errors.add(:user, 'cannot be viewer')
end
end
def invalidation_service
@invalidation_service ||= Carto::VisualizationInvalidationService.new(self)
end
class Watcher
# watcher:_orgid_:_vis_id_:_user_id_
KEY_FORMAT = "watcher:%s".freeze
# @params user Carto::User
# @params visualization Carto::Visualization
# @throws Carto::Visualization::WatcherError
def initialize(user, visualization, notification_ttl = nil)
raise WatcherError.new('User must belong to an organization') if user.organization.nil?
@user = user
@visualization = visualization
default_ttl = Cartodb.config[:watcher].present? ? Cartodb.config[:watcher].try("fetch", 'ttl', 60) : 60
@notification_ttl = notification_ttl.nil? ? default_ttl : notification_ttl
end
# Notifies that is editing the visualization
# NOTE: Expiration is handled internally by redis
def notify
key = KEY_FORMAT % @visualization.id
$tables_metadata.multi do
$tables_metadata.hset(key, @user.username, current_timestamp + @notification_ttl)
$tables_metadata.expire(key, @notification_ttl)
end
end
# Returns a list of usernames currently editing the visualization
def list
key = KEY_FORMAT % @visualization.id
users_expiry = $tables_metadata.hgetall(key)
now = current_timestamp
users_expiry.select { |_, expiry| expiry.to_i > now }.keys
end
private
def current_timestamp
Time.now.getutc.to_i
end
end
class WatcherError < CartoDB::BaseCartoDBError; end
class AlreadyLikedError < StandardError; end
class UnauthorizedLikeError < StandardError; end
end