decidim-decidim_geo 0.2.1

data/app/models/decidim/debates/debate.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Debates
+    # The data store for a Debate in the Decidim::Debates component. It stores a
+    # title, description and any other useful information to render a custom
+    # debate.
+    class Debate < Debates::ApplicationRecord
+      include Decidim::HasComponent
+      include Decidim::HasCategory
+      include Decidim::Resourceable
+      include Decidim::Followable
+      include Decidim::Comments::CommentableWithComponent
+      include Decidim::Comments::HasAvailabilityAttributes
+      include Decidim::ScopableResource
+      include Decidim::Authorable
+      include Decidim::Reportable
+      include Decidim::HasReference
+      include Decidim::Traceable
+      include Decidim::Loggable
+      include Decidim::NewsletterParticipant
+      include Decidim::Searchable
+      include Decidim::TranslatableResource
+      include Decidim::TranslatableAttributes
+      include Decidim::Endorsable
+      include Decidim::Randomable
+
+      if Decidim.version == '0.27.4'
+        include Decidim::DownloadYourData
+        include Decidim::FilterableResource
+      end
+
+      belongs_to :last_comment_by, polymorphic: true, foreign_type: "last_comment_by_type", optional: true
+      component_manifest_name "debates"
+
+      validates :title, presence: true
+
+      translatable_fields :title, :description, :instructions, :information_updates
+      searchable_fields({ 
+                          scope_id: :decidim_scope_id,
+                          participatory_space: { component: :participatory_space },
+                          A: :title,
+                          D: :description,
+                          datetime: :start_time
+                        },
+                        index_on_create: ->(debate) { debate.visible? },
+                        index_on_update: ->(debate) { debate.visible? })
+
+      scope :open, -> { where(closed_at: nil) }
+      scope :closed, -> { where.not(closed_at: nil) }
+      scope :authored_by, ->(author) { where(author: author) }
+      scope :commented_by, lambda { |author|
+        joins(:comments).where(
+          decidim_comments_comments:
+          {
+            decidim_author_id: author.id,
+            decidim_author_type: author.class.base_class.name
+          }
+        )
+      }
+
+      if Decidim.version == '0.27.4'
+        scope_search_multi :with_any_state, [:open, :closed]
+      end
+
+      def self.log_presenter_class_for(_log)
+        Decidim::Debates::AdminLog::DebatePresenter
+      end
+
+      def comments_start_time
+        start_time
+      end
+
+      def comments_end_time
+        end_time
+      end
+
+      # Public: Overrides the `reported_content_url` Reportable concern method.
+      def reported_content_url
+        ResourceLocatorPresenter.new(self).url
+      end
+
+      # Public: Overrides the `reported_attributes` Reportable concern method.
+      def reported_attributes
+        [:title, :description]
+      end
+
+      # Public: Overrides the `reported_searchable_content_extras` Reportable concern method.
+      def reported_searchable_content_extras
+        [normalized_author.name]
+      end
+
+      # Public: Calculates whether the current debate is an AMA-styled one or not.
+      # AMA-styled debates are those that have a start and end time set, and comments
+      # are only open during that timelapse. AMA stands for Ask Me Anything, a type
+      # of debate inspired by Reddit.
+      #
+      # Returns a Boolean.
+      def ama?
+        start_time.present? && end_time.present?
+      end
+
+      # Public: Checks whether the debate is an AMA-styled one and is open.
+      #
+      # Returns a boolean.
+      def open_ama?
+        ama? && Time.current.between?(start_time, end_time)
+      end
+
+      # Public: Checks if the debate is open or not.
+      #
+      # Returns a boolean.
+      def open?
+        (ama? && open_ama?) || !ama?
+      end
+
+      # Public: Overrides the `accepts_new_comments?` CommentableWithComponent concern method.
+      def accepts_new_comments?
+        return false unless open?
+        return false if closed?
+
+        commentable? && !comments_blocked? && comments_allowed?
+      end
+
+      # Public: Overrides the `comments_have_alignment?` Commentable concern method.
+      def comments_have_alignment?
+        true
+      end
+
+      # Public: Overrides the `comments_have_votes?` Commentable concern method.
+      def comments_have_votes?
+        true
+      end
+
+      # Public: Identifies the commentable type in the API.
+      def commentable_type
+        self.class.name
+      end
+
+      # Public: Override Commentable concern method `users_to_notify_on_comment_created`
+      def users_to_notify_on_comment_created
+        return Decidim::User.where(id: followers).or(Decidim::User.where(id: component.participatory_space.admins)).distinct if official?
+
+        followers
+      end
+
+      # Public: Overrides the `allow_resource_permissions?` Resourceable concern method.
+      def allow_resource_permissions?
+        true
+      end
+
+      def self.export_serializer
+        Decidim::Debates::DownloadYourDataDebateSerializer
+      end
+
+      def self.newsletter_participant_ids(component)
+        authors_ids = Decidim::Debates::Debate.where(component: component)
+                                              .where(decidim_author_type: Decidim::UserBaseEntity.name)
+                                              .where.not(author: nil)
+                                              .group(:decidim_author_id)
+                                              .pluck(:decidim_author_id).flatten.compact
+        commentators_ids = Decidim::Comments::Comment.user_commentators_ids_in(Decidim::Debates::Debate.where(component: component))
+        (authors_ids + commentators_ids).flatten.compact.uniq
+      end
+
+      # Checks whether the user can edit the debate.
+      #
+      # user - the user to check for authorship
+      def editable_by?(user)
+        !closed? && authored_by?(user)
+      end
+
+      # Checks whether the debate is closed or not.
+      #
+      def closed?
+        closed_at.present? && conclusions.present?
+      end
+
+      # Checks whether the user can edit the debate.
+      #
+      # user - the user to check for authorship
+      def closeable_by?(user)
+        authored_by?(user)
+      end
+
+      # Public: Updates the comments counter cache. We have to do it these
+      # way in order to properly calculate the counter with hidden
+      # comments.
+      #
+      # rubocop:disable Rails/SkipsModelValidations
+      def update_comments_count
+        comments_count = comments.not_hidden.not_deleted.count
+        last_comment = comments.not_hidden.not_deleted.order("created_at DESC").first
+
+        update_columns(
+          last_comment_at: last_comment&.created_at,
+          last_comment_by_id: last_comment&.decidim_user_group_id || last_comment&.decidim_author_id,
+          last_comment_by_type: last_comment&.decidim_author_type,
+          comments_count: comments_count,
+          updated_at: Time.current
+        )
+      end
+      # rubocop:enable Rails/SkipsModelValidations
+
+      if Decidim.version == '0.27.4'
+        # Create i18n ransackers for :title and :description.
+        # Create the :search_text ransacker alias for searching from both of these.
+        ransacker_i18n_multi :search_text, [:title, :description]
+      end
+
+      def self.ransackable_scopes(_auth_object = nil)
+        [:with_any_state, :with_any_origin, :with_any_category, :with_any_scope]
+      end
+
+      def self.ransack(params = {}, options = {})
+        DebateSearch.new(self, params, options)
+      end
+
+      private
+
+      def comments_blocked?
+        component.current_settings.comments_blocked
+      end
+    end
+  end
+end

data/app/models/decidim/geo/application_record.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Geo
+    # Abstract class from which all models in this engine inherit.
+    class ApplicationRecord < ActiveRecord::Base
+      self.abstract_class = true
+    end
+  end
+end

data/app/models/decidim/geo/geo_config.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Geo
+    # The data store for geo configuration default.
+    class GeoConfig < ApplicationRecord
+
+      self.table_name = 'decidim_geo_configs'
+
+      validates :longitude, :latitude, :zoom, :presence => true
+
+      def self.geo_config_default
+        Decidim::Geo::GeoConfig
+          .first_or_create(latitude: 0, 
+                           longitude: 0,
+                           zoom: 13,
+                           tile: tile_layer_default)
+      end
+
+      def self.tile_layer_default
+        return "" unless Decidim.config.maps.present?
+
+        Decidim.config.maps[:dynamic][:tile_layer][:url]
+      end
+            
+    end
+  end
+end

data/app/models/decidim/geo/shapedata.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Geo
+    # Data fo the shapfiles uploaded
+    class Shapedata < ApplicationRecord
+
+      self.table_name = 'decidim_geo_shapefile_datas'
+      validates :data, :presence => true
+
+      belongs_to :scope, inverse_of: :shapedata, optional: true, foreign_key: "decidim_scopes_id"
+
+      def execute_statement(sql)
+        Shapedata.connection.exec_query(sql)
+      end
+
+      def shapedata?
+        return false
+      end
+
+    end
+  end
+end

data/app/models/decidim/geo/shapefile.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Geo
+    # The data store for a Proposal in the Decidim::Proposals component.
+    class Shapefile < ApplicationRecord
+      #include Decidim::TranslatableResource
+      include Decidim::HasUploadValidations
+
+      self.table_name = 'decidim_geo_shapefiles'
+
+      has_many :shapedatas, foreign_key: "decidim_geo_shapefiles_id"
+
+      belongs_to :scope_type, inverse_of: :shapefile, optional: true, foreign_key: "decidim_scope_types_id"
+
+      #translatable_fields :title, :description
+
+      validates :title, :description, :presence => true
+      
+      has_one_attached :shapefile
+      validates_upload :shapefile, uploader: Decidim::Geo::ShapefileUploader
+      belongs_to :organization,
+               foreign_key: "decidim_organization_id",
+               class_name: "Decidim::Organization"
+    end
+  end
+end

data/app/models/decidim/geo/space_location.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Decidim
+    module Geo
+      # Data fo the shapfiles uploaded
+      class SpaceLocation < ApplicationRecord
+        self.table_name = 'decidim_geo_space_locations'
+        belongs_to :decidim_geo_space, polymorphic: true
+
+        def has_address?
+          !latitude.nil? && !longitude.nil?
+        end
+      end
+    end
+  end
+  

data/app/models/decidim/scope.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Decidim
+  # Scopes are used in some entities through Decidim to help users know which is
+  # the scope of a participatory process.
+  # (i.e. does it affect the whole city or just a district?)
+  class Scope < ApplicationRecord
+    include Decidim::Traceable
+    include Decidim::Loggable
+    include Decidim::TranslatableResource
+
+    translatable_fields :name
+
+    belongs_to :organization,
+               foreign_key: "decidim_organization_id",
+               class_name: "Decidim::Organization",
+               inverse_of: :scopes
+
+    belongs_to :scope_type,
+               class_name: "Decidim::ScopeType",
+               inverse_of: :scopes,
+               optional: true
+
+    belongs_to :parent,
+               class_name: "Decidim::Scope",
+               inverse_of: :children,
+               optional: true
+
+    has_many :children,
+             foreign_key: "parent_id",
+             class_name: "Decidim::Scope",
+             inverse_of: :parent,
+             dependent: :destroy
+
+    has_one :shapedata,
+            foreign_key: "decidim_scopes_id",
+            class_name: "Decidim::Geo::Shapedata",
+            inverse_of: :scope,
+            dependent: :nullify
+
+    before_validation :update_part_of, on: :update
+
+    validates :name, :code, :organization, presence: true
+    validates :code, uniqueness: { scope: :organization }
+    validate :forbid_cycles
+
+    after_create_commit :create_part_of
+
+    # Scope to return only the top level scopes.
+    #
+    # Returns an ActiveRecord::Relation.
+    def self.top_level(organization_id = nil)
+      query = where parent_id: nil
+      query = query.where(decidim_organization_id: organization_id) if organization_id
+      query
+    end
+
+    def self.log_presenter_class_for(_log)
+      Decidim::AdminLog::ScopePresenter
+    end
+
+    def descendants
+      @descendants ||= organization.scopes.where("? = ANY(decidim_scopes.part_of)", id)
+    end
+
+    def ancestor_of?(scope)
+      scope && scope.part_of.member?(id)
+    end
+
+    # Gets the scopes from the part_of list in descending order (first the top level scope, last itself)
+    #
+    # root - The root scope to start retrieval. If present, ignores top level scopes until reaching the root scope.
+    #
+    # Returns an array of Scope objects
+    def part_of_scopes(root = nil)
+      scope_ids = part_of
+      scope_ids.select! { |id| id == root.id || !root.part_of.member?(id) } if root
+      organization.scopes.where(id: scope_ids).sort { |s1, s2| part_of.index(s2.id) <=> part_of.index(s1.id) }
+    end
+
+    # Allow ransacker to search for a key in a hstore column (`name`.`en`)
+    ransacker :name do |parent|
+      Arel::Nodes::InfixOperation.new("->>", parent.table[:name], Arel::Nodes.build_quoted(I18n.locale.to_s))
+    end
+
+    private
+
+    def forbid_cycles
+      return unless parent
+
+      errors.add(:parent_id, :cycle_detected) if parent.part_of.include?(id)
+    end
+
+    def create_part_of
+      build_part_of
+      save if changed?
+    end
+
+    def update_part_of
+      build_part_of
+    end
+
+    def build_part_of
+      if parent
+        part_of.clear.append(id).concat(parent.reload.part_of)
+      else
+        part_of.clear.append(id)
+      end
+    end
+  end
+end

data/app/models/decidim/scope_type.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Decidim
+  # Scope types allows to use different types of scopes in participatory process
+  # (municipalities, provinces, states, countries, etc.)
+  # Override to include shapefiles field
+  class ScopeType < ApplicationRecord
+    include Decidim::TranslatableResource
+
+    translatable_fields :name, :plural
+    belongs_to :organization,
+               foreign_key: "decidim_organization_id",
+               class_name: "Decidim::Organization",
+               inverse_of: :scope_types
+
+    has_one :shapefile, 
+            class_name: "Decidim::Geo::Shapefile", 
+            inverse_of: :scope_type, 
+            foreign_key: "decidim_scope_types_id", 
+            dependent: :nullify
+
+    has_many :scopes, class_name: "Decidim::Scope", inverse_of: :scope_type, dependent: :nullify
+
+    validates :name, presence: true
+  end
+end

data/app/overrides/decidim/assemblies/admin/assemblies/_form/insert_location_form.html.erb.deface

@@ -0,0 +1,13 @@
+<!-- insert_after ".card-section:nth-child(2)" -->
+<% if Decidim::Map.available?(:geocoding) %>
+    <div class="card-divider">
+        <h2 class="card-title"><%= t(".decidim_geo_space_address") %></h2>
+    </div>
+
+    <div class="card-section">
+        <div class="row column">
+            <%= form.geocoding_field :decidim_geo_space_address, autocomplete: true %>
+            <p class="help-text"><%= t(".decidim_geo_space_address_help") %></p>
+        </div>
+    </div>
+<% end %>

data/app/overrides/decidim/assemblies/assemblies/show/insert_location.html.erb.deface

@@ -0,0 +1,7 @@
+<!-- insert_before "erb[loud]:contains('social_handler_links')" -->
+<% if current_participatory_space.decidim_geo_space_location && current_participatory_space.decidim_geo_space_location.has_address?%>
+    <div class="definition-data__item scope">
+    <span class="definition-data__title"><%= t("decidim_geo_space_location", scope: "decidim.assemblies.show") %></span>
+    <%= current_participatory_space.decidim_geo_space_location.address %>
+    </div>
+<% end %>

data/app/overrides/decidim/participatory_processes/admin/participatory_processes/_form/insert_location_form.html.erb.deface

@@ -0,0 +1,13 @@
+<!-- insert_after ".card-section:nth-child(2)" -->
+<% if Decidim::Map.available?(:geocoding) %>
+    <div class="card-divider">
+        <h2 class="card-title"><%= t(".decidim_geo_space_address") %></h2>
+    </div>
+
+    <div class="card-section">
+        <div class="row column">
+            <%= form.geocoding_field :decidim_geo_space_address, autocomplete: true %>
+            <p class="help-text"><%= t(".decidim_geo_space_address_help") %></p>
+        </div>
+    </div>
+<% end %>

data/app/overrides/decidim/participatory_processes/participatory_process_groups/show/insert_map.html.erb.deface

@@ -0,0 +1,6 @@
+<!-- insert_before '.wrapper' -->
+<%= cell("decidim/geo/content_blocks/geo_maps", @group,
+    id: "ProcessGroup",
+    filters:  @group.participatory_processes.map {|process|  { processFilter: { processId: process.id } } },
+    scopes: @group.participatory_processes.scope.map{|s| s.id}
+) %>

data/app/overrides/layouts/decidim/_assembly_header/insert_map.html.erb.deface

@@ -0,0 +1,25 @@
+<!-- insert_after '.process-header' -->
+<%
+assemblies = []
+# recursivly get all the children assemblies.
+def iter_children(assembly, collection)
+    assembly.children.map {|ch| iter_children(ch, collection) } if assembly.children
+    collection.push(assembly.id)
+end
+iter_children(current_participatory_space, assemblies) unless current_participatory_space.scope.present?
+%>
+<%= cell("decidim/geo/content_blocks/geo_maps", current_participatory_space, 
+    id: "Assembly",
+    filters: if current_participatory_space.scope.present?
+        [
+          { scopeFilter: { scopeId: current_participatory_space.scope.id } }
+        ]
+    else 
+        assemblies.map { |assembly_id| { assemblyFilter: { assemblyId: assembly_id } } }
+    end,
+    scopes: if current_participatory_space.scope.present?
+        [current_participatory_space.scope.id]
+    else
+        []
+    end
+) %>

data/app/overrides/layouts/decidim/_process_header/insert_map.html.erb.deface

@@ -0,0 +1,22 @@
+<!-- insert_after '.process-header' -->
+<% if controller.controller_name != "participatory_process_steps" %>
+  <%= cell("decidim/geo/content_blocks/geo_maps", current_participatory_space, 
+      id: "Process",
+      filters: if current_participatory_space.scope.present?
+        # If the process has a scope, filter by its scope
+        [
+          { scopeFilter: { scopeId: current_participatory_space.scope.id } }
+        ]
+      else 
+        # Else filter on the process data
+        [
+          { processFilter: { processId: current_participatory_space.id } }
+        ]
+      end,
+      scopes:  if current_participatory_space.scope.present?
+          [current_participatory_space.scope.id]
+        else
+            []
+        end
+  ) %>
+<% end %>

data/app/overrides/layouts/decidim/_wrapper/insert_map.html.erb.deface

@@ -0,0 +1,5 @@
+<!-- insert_after '.show-for-medium > .navbar' -->
+<%= cell(
+    "decidim/geo/geo_collection_map", 
+    id: "Indexes",
+) %>

data/app/overrides/remove_default_meetings_map.rb

@@ -0,0 +1,4 @@
+Deface::Override.new(:virtual_path => "decidim/meetings/meetings/index",
+                     :name => "remove_default_meetings_map",
+                     :remove => "erb[silent]:contains('if current_component.settings.maps_enabled? && search.result.not_online.exists?')",
+                     :closing_selector => "erb[silent]:contains('end')")

data/app/overrides/remove_default_proposals_map.rb

@@ -0,0 +1,4 @@
+Deface::Override.new(:virtual_path => "decidim/proposals/proposals/index",
+                     :name => "remove_default_proposals_map",
+                     :remove => "erb[loud]:contains('dynamic_map_for proposals_data_for_map(@all_geocoded_proposals) do')",
+                     :closing_selector => "erb[silent]:contains('end')")

data/app/packs/entrypoints/decidim_geo.js

@@ -0,0 +1,3 @@
+require.context("../images", true);
+
+import "src/decidim/geo/index.js";

data/app/packs/images/decidim/geo/not-geolocated.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="17" height="16" viewBox="0 0 17 16" fill="none">
+  <path d="M11.4334 10.7334L8.35339 7.64671L8.28006 7.57337L2.70006 2.00004L1.85339 2.84671L3.97339 4.96671C3.89339 5.30004 3.85339 5.64004 3.85339 6.00004C3.85339 9.50004 8.52006 14.6667 8.52006 14.6667C8.52006 14.6667 9.63339 13.4334 10.7667 11.7667L13.0067 14L13.8534 13.1467M8.52006 4.33337C8.96209 4.33337 9.38601 4.50897 9.69857 4.82153C10.0111 5.13409 10.1867 5.55801 10.1867 6.00004C10.1867 6.48671 9.96673 6.92671 9.63339 7.23337L12.0534 9.66671C12.7067 8.41337 13.1867 7.12004 13.1867 6.00004C13.1867 4.76236 12.6951 3.57538 11.8199 2.70021C10.9447 1.82504 9.75774 1.33337 8.52006 1.33337C7.18673 1.33337 6.01339 1.88004 5.16006 2.76004L7.28673 4.88671C7.59339 4.54671 8.02673 4.33337 8.52006 4.33337Z" fill="#808080"/>
+</svg>

data/app/packs/src/decidim/geo/actions/index.js

@@ -0,0 +1,25 @@
+export const displayNestedLayers = (leafletContainer, checked) => {
+  if (
+    leafletContainer.classList.contains("decidimGeo__customControl__input") &&
+    leafletContainer.checked !== checked
+  ) {
+    leafletContainer.dispatchEvent(
+      new MouseEvent("click", {
+        view: window,
+        bubbles: false,
+        cancelable: false
+      })
+    );
+    //leafletContainer.checked = checked;
+    //This leads layers to unsynchronize with the input state.
+    // Bubbling the click seems to ensure leaflet events are correctly triggered.
+  }
+
+  if (leafletContainer.children) {
+    return [...leafletContainer.children].map((child) =>
+      displayNestedLayers(child, checked)
+    );
+  } else {
+    return;
+  }
+};

data/app/packs/src/decidim/geo/api/index.js

@@ -0,0 +1,53 @@
+import * as queries from "./queries";
+import { getDecidimData } from "../utils";
+import configStore from "../models/configStore";
+
+const makeQuery =
+  (queryName, responseKey = undefined) =>
+  async (params = {}) => {
+    const _responseKey = responseKey ? responseKey : queryName;
+    const { locale } = configStore.getState();
+    const variables = { ...(params.variables || {}), locale: locale };
+    const queryParams = { ...params, variables };
+    const response = await getDecidimData(queries[queryName], queryParams);
+    return response.data[_responseKey];
+  };
+
+const _getGeoDatasource = makeQuery("geoDatasource");
+const _getGeoDatasourceIds = makeQuery("geoDatasourceIds", "geoDatasource");
+
+export const getGeoDatasource = async (params = {}, fetchAll = true) => {
+  let results = [];
+  if (!params.variables) {
+    params.variables = {};
+  }
+  const apiQuery = fetchAll ? _getGeoDatasource : _getGeoDatasourceIds;
+  let page;
+  try {
+    page = await apiQuery(params);
+  } catch (error) {
+    console.error(error);
+    throw error;
+  }
+  if (!page) return [];
+  const { hasNextPage = false, endCursor = "" } = page?.pageInfo || {};
+  results = results.concat(page.nodes);
+  let hasMore = hasNextPage;
+  params.variables.after = endCursor;
+  while (hasMore) {
+    try {
+      page = await apiQuery(params);
+    } catch (error) {
+      console.error(error);
+      return { nodes: results, edges: page.edge };
+    }
+    const { endCursor = params.variables.after, hasNextPage } = page.pageInfo || {};
+    results = results.concat(page.nodes);
+    hasMore = hasNextPage;
+    params.variables.after = endCursor;
+  }
+
+  return { nodes: results, edges: page.edge };
+};
+export const getGeoConfig = makeQuery("geoConfig");
+export const getGeoScopes = makeQuery("geoScope");