Initial commit

app/models/visualization/relator.rb

@@ -0,0 +1,168 @@
+require_relative './stats'
+require_relative '../visualization/collection'
+require_relative './support_tables'
+require_relative '../map'
+require_relative '../layer'
+
+module CartoDB
+  module Visualization
+    class Relator
+      LAYER_SCOPES = {
+        base:             :user_layers,
+        cartodb:          :carto_layers,
+        data:             :data_layers,
+        others:           :other_layers,
+        named_map:        :named_maps_layers
+      }.freeze
+
+      INTERFACE = %w{ overlays user table related_templates related_tables related_canonical_visualizations
+                      layers stats mapviews total_mapviews data_layers synchronization synced? permission
+                      parent children support_tables prev_list_item next_list_item likes reload_likes
+                      estimated_row_count actual_row_count }.freeze
+
+      def initialize(map, attributes = {})
+        @id             = attributes.fetch(:id)
+        @user_id        = attributes.fetch(:user_id)
+        @permission_id  = attributes.fetch(:permission_id)
+        @parent_id      = attributes.fetch(:parent_id)
+        @kind           = attributes.fetch(:kind)
+        @support_tables = nil
+        @likes          = nil
+        @prev_id        = attributes.fetch(:prev_id)
+        @next_id        = attributes.fetch(:next_id)
+        @map            = map
+      end
+
+      # @return []
+      def children
+        ordered = []
+        children_vis = Visualization::Collection.new.fetch(parent_id: @id)
+        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
+
+      # @return CartoDB::Visualization::Member
+      def parent
+        @parent ||= Visualization::Member.new(id: @parent_id).fetch unless @parent_id.nil?
+      end
+
+      # @return CartoDB::Visualization::Member
+      def prev_list_item
+        @prev_vis ||= Visualization::Member.new(id: @prev_id).fetch unless @prev_id.nil?
+      end
+
+      # @return CartoDB::Visualization::Member
+      def next_list_item
+         @next_vis ||= Visualization::Member.new(id: @next_id).fetch unless @next_id.nil?
+      end
+
+      def support_tables
+        @support_tables ||= Visualization::SupportTables.new(
+          user.in_database, parent_id: @id, parent_kind: @kind, public_user_roles: user.db_service.public_user_roles)
+      end
+
+      def overlays
+        @overlays ||= Carto::Overlay.where(visualization_id: id).all
+      end
+
+      def user
+        @user ||= ::User[@user_id] unless @user_id.nil?
+      end
+
+      def table
+        return nil if map.nil?
+        @table ||= ::UserTable.from_map_id(map.id).try(:service)
+      end
+
+      def estimated_row_count
+        table.nil? ? nil : table.estimated_row_count
+      end
+
+      def actual_row_count
+        table.nil? ? nil : table.actual_row_count
+      end
+
+      def related_templates
+        Carto::Template.where(source_visualization_id: @id).all
+      end
+
+      def related_tables
+        @related_tables ||= layers(:data).flat_map { |layer| layer.user_tables.map(&:service) }.uniq(&:id)
+      end
+
+      def related_canonical_visualizations
+        @related_canonical_visualizations ||= get_related_canonical_visualizations
+      end
+
+      def layers(kind)
+        return [] unless map
+        map.send(LAYER_SCOPES.fetch(kind))
+      end
+
+      def synchronization
+        CartoDB::Synchronization::Member.new(visualization_id: @id).fetch_by_visualization_id
+      rescue KeyError
+        {}
+      end
+
+      def synced?
+        !synchronization.is_a?(Hash)
+      end
+
+      def stats(user=nil)
+        @stats ||= Visualization::Stats.new(self, user).to_poro
+      end
+
+      def mapviews(user=nil)
+        @mapviews ||= stats(user).collect { |o| o[1] }.reduce(:+)
+      end
+
+      def total_mapviews(user=nil)
+        @total_mapviews ||= Visualization::Stats.new(self, user).total_mapviews
+      end
+
+      def data_layers
+        layers(:data)
+      end
+
+      def permission
+        @permission ||= CartoDB::Permission.where(id: @permission_id).first unless @permission_id.nil?
+      end
+
+      def likes
+        @likes ||= likes_search.all.to_a
+      end
+
+      def reload_likes
+        @likes = nil
+        likes
+      end
+
+      attr_reader :id, :map
+
+      private
+
+      def likes_search
+        Like.where(subject: @id)
+      end
+
+      def get_related_canonical_visualizations
+        get_related_visualizations_by_types([CartoDB::Visualization::Member::TYPE_CANONICAL])
+      end
+
+      def get_related_visualizations_by_types(types)
+        related_map_ids = related_tables.map(&:map_id)
+        CartoDB::Visualization::Collection.new.fetch(map_id: related_map_ids, type: types)
+      end
+
+    end
+  end
+end