decidim-decidim_geo 0.2.1

data/lib/decidim/api/query_extension.rb

@@ -0,0 +1,320 @@
+module Decidim
+  module Geo
+    # GeoQueryExtension
+    module QueryExtension
+
+      def self.included(type)
+        def geo_manifests
+          { 
+            "Decidim::Meetings::Meeting": true, 
+            "Decidim::Proposals::Proposal": true, 
+            "Decidim::Assembly": true,
+            "Decidim::ParticipatoryProcess": true,
+            "Decidim::Debates::Debate": false
+          }
+        end
+
+        def supported_geo_components 
+          geo_manifests.keys
+        end
+
+
+        type.field :geo_shapefiles, [Decidim::Geo::GeoShapefileType], description: "Return's information about the shapefiles", null: true do
+          argument :title, [String], required: false
+        end
+
+        type.field :geo_shapedata, [Decidim::Geo::GeoShapedataType], description: "Return's datas from shapefile", null: true do
+          argument :name, [String], required: false
+        end
+
+        type.field :geo_config, Decidim::Geo::GeoConfigType, description: "Return's information about the geo config", null: true
+
+        type.field :geo_scope, [Decidim::Geo::GeoScopeApiType], description: "Return's scopes with shapedatas", null: true do
+          argument :id, type: [Integer], required: false
+        end
+
+        type.field :geo_datasource, Decidim::Geo::GeoDatasourceType.connection_type, null: true do
+          argument :filters, [Decidim::Geo::GeoDatasourceInputFilter], "This argument let's you filter the results", required: false
+          argument :locale, type: String, required: false
+        end
+      end
+
+      def geo_datasource(**kwargs)
+        
+        locale = kwargs[:locale] || I18n.locale
+        return nofilter_datasource(locale) unless kwargs[:filters].present?
+        
+        scopes = kwargs[:filters].select {|f| f[:scope_filter].present?}
+        resource_type = kwargs[:filters].find {|f| f[:resource_type_filter].present?}
+        processes = kwargs[:filters].select {|f| f[:process_filter].present?}
+        assemblies = kwargs[:filters].select {|f| f[:assembly_filter].present?}
+        @time = kwargs[:filters].find {|f| f[:time_filter].present?} 
+        @geoencoded = kwargs[:filters].find {|f| f[:geoencoded_filter].present?}
+        search_params = {locale: locale, class_name: supported_geo_components}
+        filtered_by_spaces = assemblies.length > 0 || processes.length > 0
+        filtered_by_scopes = scopes.length > 0
+        if scopes.length > 0
+          # Search only in a given scope
+          search_params = search_params.merge({scope_ids: scopes.map {|scope| scope.scope_filter.scope_id }})
+        end
+
+        if resource_type
+          # search only for a resource type
+          class_name = resource_type.resource_type_filter.resource_type
+          search_params = search_params.merge({class_name: class_name}) unless class_name == "all"
+        elsif assemblies.length > 0 && processes.length == 0
+          search_params = search_params.merge({class_name: supported_geo_components.select {|k| k != :"Decidim::ParticipatoryProcess"}})
+        elsif processes.length > 0 && assemblies.length == 0
+          search_params = search_params.merge({class_name: supported_geo_components.select {|k| k != :"Decidim::Assembly"}})
+        end
+        search_results = filtered_query_for(**search_params)
+
+        if assemblies.length > 0
+          # The results must be within an assembly
+          search_results = search_results.where(
+            decidim_participatory_space_type: "Decidim::Assembly",
+            decidim_participatory_space_id: assemblies.map{|assembly| assembly.assembly_filter.assembly_id }
+          )
+        end
+
+        if processes.length > 0
+          # The results must be within a process
+          search_results = search_results.where(
+            decidim_participatory_space_type: "Decidim::ParticipatoryProcess",
+            decidim_participatory_space_id: processes.map {|process| process.process_filter.process_id }
+          )
+        end
+
+        fetch_results(search_results)
+      end
+
+      def geo_shapefiles(title: nil)
+        return Decidim::Geo::Shapefile.where(title: title) if title.present?
+        Decidim::Geo::Shapefile.all
+      end
+
+      def geo_shapedata(name: nil)
+        return Decidim::Geo::Shapedata.where("data->>'NAME' in (?)", name) if name.present?
+
+        Decidim::Geo::Shapedata.all
+      end
+
+      def geo_config
+        Decidim::Geo::GeoConfig.geo_config_default
+      end
+
+      def geo_scope(id: [])
+        return Decidim::Scope.all if id.empty?
+        Decidim::Scope.where(id: id)
+      end
+
+      private
+
+      def nofilter_datasource(locale)
+        fetch_results(
+          filtered_query_for(locale: locale, class_name: supported_geo_components)
+        )
+      end
+
+      def has_address?(resource)
+        resource.respond_to?(:address) && resource.address.present?
+      end
+
+      def has_geo_scope?(resource)
+        if resource.respond_to?(:scope)
+          Decidim::Geo::Shapedata.exists?(decidim_scopes_id: resource.scope.id) if resource.scope.present?
+        end
+      end
+
+      def filtered_query_for(class_name: nil, id: nil, term: nil, scope_ids: nil, space_state: nil, locale: nil, spaces: nil)
+        query = {organization: organization,
+          locale: locale,
+          resource_type: class_name,
+        }
+        if scope_ids.present?
+          query.update(decidim_scope_id: scope_ids)
+        end
+        query.update(decidim_participatory_space: spaces) if spaces.present?
+        query.update(resource_id: id) if id.present?
+        result_query = SearchableResource.where(query)
+        result_query = result_query.order("datetime DESC")
+        result_query = result_query.global_search(I18n.transliterate(term)) if term.present?
+        result_query
+      end
+
+      def fetch_results(searcheable_results)
+        data_by_resource_type = {}
+        searcheable_results.select("resource_id,resource_type").each do |resource|
+          data_by_resource_type[resource.resource_type] = [] unless data_by_resource_type[resource.resource_type].present?
+          data_by_resource_type[resource.resource_type].push(resource.resource_id) 
+        end
+        processes_matches = data_by_resource_type["Decidim::ParticipatoryProcess"] || []
+        assemblies_matches = data_by_resource_type["Decidim::Assembly"] || []
+        meetings_matches = data_by_resource_type["Decidim::Meetings::Meeting"] || []
+        proposals_matches = data_by_resource_type["Decidim::Proposals::Proposal"] || []
+        debates_matches = data_by_resource_type["Decidim::Debates::Debate"] || []
+        if @time
+          time_filter = @time.time_filter.time 
+        else
+          time_filter = "active"
+        end
+
+        processes_matches = processes_time_filter(processes_matches, time_filter)
+        assemblies_matches = assembly_time_filter(assemblies_matches, time_filter)
+        meetings_matches = meeting_time_filter(meetings_matches, time_filter)
+        # Proposals & Debates are always hidden when adding a time filter
+        # in the past or the future, as they are not bound to time.
+        proposals_matches = proposals_time_filter(proposals_matches, time_filter)
+        debates_matches = [] if ["past", "future"].include? time_filter
+
+        only_geo_encoded = @geoencoded && @geoencoded.geoencoded_filter.geoencoded
+        only_not_geo_encoded = @geoencoded && !@geoencoded.geoencoded_filter.geoencoded
+        result = {
+          "Decidim::Meetings::Meeting": meetings_matches, 
+          "Decidim::Proposals::Proposal": proposals_matches, 
+          "Decidim::Debates::Debate": debates_matches
+        }.flat_map do |klass, match_ids|
+          query = "#{klass}".constantize.where(id: match_ids)
+          supports_geo = geo_manifests[klass]
+          if only_geo_encoded
+            next [] unless supports_geo
+            query = query.where.not(latitude: nil) 
+          end
+          if only_not_geo_encoded
+            next query unless supports_geo
+            query = query.where(latitude: nil) 
+          end
+          query
+        end
+        result.concat({
+          "Decidim::Assembly": assemblies_matches,
+          "Decidim::ParticipatoryProcess": processes_matches
+        }.flat_map do |klass, match_ids|
+          query = "#{klass}".constantize.joins(:decidim_geo_space_location).where(id: match_ids)
+          supports_geo = geo_manifests[klass]
+          if only_geo_encoded
+            next [] unless supports_geo
+            query = query.where.not(decidim_geo_space_location: {latitude: nil})
+          end
+          if only_not_geo_encoded
+            next query unless supports_geo
+            query = query.where(decidim_geo_space_location: {latitude: nil}) 
+          end
+          query
+        end)
+
+        result.flatten
+      end
+
+      def state_filter(filter)
+        {decidim_scope_id: filter[:scope_ids]}.merge(decidim_participatory_space: spaces_to_filter(filter)).compact
+      end
+  
+      def processes_time_filter(processes, time_filter)
+        manifest = Decidim.participatory_space_manifests.find do |mani| 
+          mani.name == :participatory_process
+        end
+        if !manifest
+          return processes;
+        end
+        
+        public_spaces = manifest.participatory_spaces.call(organization).public_spaces
+        case time_filter
+          when "active"
+            public_spaces.active_spaces
+          when "future"
+            public_spaces.future_spaces
+          when "past"
+            public_spaces.past_spaces
+        else
+          public_spaces
+        end
+        public_spaces.where(id: processes).pluck(:id)
+      end
+
+      def assembly_time_filter(assemblies, time_filter)
+        search_assembly = Decidim::Assembly.visible_for(current_user)
+        query = case time_filter
+        when "past"
+          search_assembly.where("duration < ?", DateTime.now)
+        when "active"
+          search_assembly.where(duration: 15.days.ago..15.days.from_now).or(
+            search_assembly.where(duration: nil)
+          )
+        when "future"
+          search_assembly.where("duration > ?", DateTime.now)
+        else
+          search_assembly
+        end
+        query.where(id: assemblies).pluck(:id)
+      end
+
+      def proposals_time_filter(proposals, time_filter)
+        proposal_query = Decidim::Proposals::Proposal.where(id: proposals).published
+        query = case time_filter
+        when "past"
+          proposal_query.where(state: ["rejected", "accepted"])
+        when "active", "future"
+          proposal_query.where(state: ["not_answered", "evaluating"]).or(
+            proposal_query.where(state: nil)
+          )
+        else
+          proposal_query
+        end
+        query.pluck(:id)
+      end
+
+      def meeting_time_filter(meetings, time_filter)
+        meetings = Decidim::Meetings::Meeting.visible_for(current_user).where(id: meetings)
+        meetings = case time_filter
+          when "past"
+            meetings.where("end_time < ?", DateTime.now)
+          when "active"
+            meetings.where(
+              # Meeting is happening
+              "start_time <= ? AND end_time > ?", DateTime.now, DateTime.now
+            ).or(
+              # Meeting is about to start (now..in 15 days)
+              meetings.where("start_time > ? AND start_time < ?", DateTime.now, 15.days.from_now)
+            ).or(
+              # Meeting has just ended (15days ago ... now)
+              meetings.where("end_time > ? AND end_time < ?", 15.days.ago, DateTime.now)
+            )
+          when "future"
+            meetings.where("start_time >= ?", DateTime.now)
+        else
+          meetings
+        end
+        meetings.pluck(:id)
+      end
+
+
+      def search_by_scope_params(filter, locale)
+        scope = Decidim::Scope.where(id: filter.scope_id) if filter.scope_id.present?
+        return {scope_ids: filter.scope_id, locale: locale} if scope.present?
+        {}
+      end
+
+      def geo_scopes_ids
+        return Decidim::Geo::Shapedata.where.not(decidim_scopes_id: nil).map { |shp| shp.decidim_scopes_id }
+      end
+
+      def resource_data(resource_type_data)
+        resource_type_data[:resource_type].split('::').inject(Object) {|o,c| o.const_get c}.find(resource_type_data[:resource_id])
+      end
+
+      def organization_locale
+        given_organization ||= try(:current_organization)
+        given_organization ||= try(:organization)
+        given_organization.try(:default_locale)
+      end
+
+      def current_user
+        context[:current_user]
+      end
+      def current_organization
+        context[:current_organization]
+      end
+    end
+  end
+end

data/lib/decidim/api/shapefile_query_extention.rb

@@ -0,0 +1,18 @@
+module Decidim
+  module Geo
+    module ShapefileQueryExtension
+      # Public: Extends a type with `decidim-geo`'s fields.
+      #
+      # type - A GraphQL::BaseType to extend.
+      #
+      # Returns nothing.
+      def self.included(type)
+        type.field :shapefiles, [Decidim::Geo::ShapefileType], description: "Return's information about the shapefiles", null: true
+      end
+
+      def shapefiles
+        Decidim::Geo::Shapefile.all
+      end
+    end
+  end
+end

data/lib/decidim/api/shapefile_type.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Geo
+    class ShapefileType < Decidim::Api::Types::BaseObject
+
+      description "A shapefile"
+
+      field :id, ID, null: false
+      field :title, String, null: false
+      field :description, String, null: true
+      field :shapefile, String, null: false
+      field :created_at, GraphQL::Types::ISO8601DateTime, null: false
+      field :updated_at, GraphQL::Types::ISO8601DateTime, null: false
+
+    end
+  end
+end

data/lib/decidim/decidim_geo/admin.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Geo
+    # This module contains all the domain logic associated to Decidim's Geo
+    # component admin panel.
+    module Admin
+    end
+  end
+end

data/lib/decidim/decidim_geo/admin_engine.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Geo
+    # This is the engine that runs on the public interface of `Geo`.
+    class AdminEngine < ::Rails::Engine
+      isolate_namespace Decidim::Geo::Admin
+
+      paths["db/migrate"] = nil
+      paths["lib/tasks"] = nil
+
+      routes do
+        # Add admin engine routes here
+        resources :shapefiles do 
+          resources :attachments
+        end
+
+        resources :geo_configs
+
+        root to: 'geo_configs#index'
+      end
+
+      initializer "decidim_geo.admin_mount_routes" do
+        Decidim::Core::Engine.routes do
+          mount Decidim::Geo::AdminEngine, at: "/admin/geo", as: "decidim_admin_geo"
+        end
+      end
+    
+      initializer "decidim_geo.webpacker.admin_assets_path" do
+        Decidim.register_assets_path File.expand_path("#{Decidim::Geo::Engine.root}/app/packs/admin")
+      end
+
+      initializer "decidim_geo.admin_menu" do
+        Decidim.menu :admin_menu do |menu|
+          menu.add_item :geo, 
+                        I18n.t("menu.geo", scope: "decidim.admin", default: "Geo"),
+                        decidim_admin_geo.geo_configs_path,
+                        icon_name: "map",
+                        position: 10,
+                        active: is_active_link?(decidim_admin_geo.geo_configs_path, :inclusive),
+                        if: defined?(current_user) && current_user&.read_attribute("admin")
+        end
+      end
+
+      initializer "decidim_geo.admin_menu" do
+        Decidim.menu :admin_geo_menu do |menu|
+          menu.add_item :edit_config,
+                        I18n.t("menu.geo", scope: "decidim.admin", default: "Configurations"),
+                        decidim_admin_geo.geo_configs_path,
+                        position: 1,
+                        active: is_active_link?(decidim_admin_geo.geo_configs_path, :inclusive),
+                        if: defined?(current_user) && current_user&.read_attribute("admin")
+
+          menu.add_item :shapefiles,
+                        I18n.t("menu.geo", scope: "decidim.admin", default: "Shapefiles"),
+                        decidim_admin_geo.shapefiles_path,
+                        position: 2,
+                        active: is_active_link?(decidim_admin_geo.shapefiles_path, :inclusive),
+                        if: defined?(current_user) && current_user&.read_attribute("admin")
+        end
+      end
+
+      def load_seed
+        nil
+      end
+
+    end
+  end
+end

data/lib/decidim/decidim_geo/api.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Geo
+    autoload :QueryExtension, "decidim/api/query_extension"
+    autoload :GeoShapefileType, "decidim/api/geo_shapefile_type"
+    autoload :GeoShapedataType, "decidim/api/geo_shapedata_type"
+    autoload :GeoConfigType, "decidim/api/geo_config_type"
+    autoload :GeoScopeApiType, "decidim/api/geo_scope_api_type"
+    autoload :HasScopeableInputFilter, "decidim/api/input_filters/has_scopeable_input_filter"
+    autoload :GeoDatasourceInputFilter, "decidim/api/input_filters/geo_datasource_input_filter"
+    autoload :ScopeInputFilter, "decidim/api/input_filters/scope_input_filter"
+    autoload :AssemblyInputFilter, "decidim/api/input_filters/assembly_input_filter"
+    autoload :ProcessInputFilter, "decidim/api/input_filters/process_input_filter"
+    autoload :ResourceTypeInputFilter, "decidim/api/input_filters/resource_type_input_filter"
+    autoload :TimeInputFilter, "decidim/api/input_filters/time_input_filter"
+    autoload :GeoencodedInputFilter, "decidim/api/input_filters/geoencoded_input_filter"
+    autoload :MeetingsInputFilter, "decidim/api/meetings_input_filter"
+    autoload :GeoDatasourceType, "decidim/api/geo_datasource_type"
+    autoload :GeoDatasourcesType, "decidim/api/geo_datasources_type"
+    autoload :GeoCoordinatesType, "decidim/api/geo_coordinates_type"
+  end
+end

data/lib/decidim/decidim_geo/engine.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "rails"
+require "decidim/core"
+require "rgeo-geojson"
+
+module Decidim
+  module Geo
+    # This is the engine that runs on the public interface of geo.
+    class Engine < ::Rails::Engine
+      isolate_namespace Decidim::Geo
+      
+      routes do
+      end
+      config.to_prepare do
+        # API overrides
+        Decidim::Api::QueryType.include Decidim::Geo::QueryExtension
+        Decidim::ParticipatoryProcesses::ParticipatoryProcessInputFilter.include Decidim::Geo::HasScopeableInputFilter
+
+        # Spaces locations
+        Decidim::Assembly.include(Decidim::Geo::SpaceOverride)
+        Decidim::Assemblies::Admin::AssemblyForm.include(Decidim::Geo::AssemblyFormOverride)
+        Decidim::Assemblies::Admin::CreateAssembly.include(Decidim::Geo::AssemblyCreateCommandOverride)
+        Decidim::Assemblies::Admin::UpdateAssembly.include(Decidim::Geo::AssemblyUpdateCommandOverride)
+        
+        Decidim::ParticipatoryProcess.include(Decidim::Geo::SpaceOverride)
+        Decidim::ParticipatoryProcesses::Admin::ParticipatoryProcessForm.include(Decidim::Geo::ParticipatoryProcessFormOverride)
+        Decidim::ParticipatoryProcesses::Admin::CreateParticipatoryProcess.include(Decidim::Geo::ParticipatoryProcessCommandOverride)
+        Decidim::ParticipatoryProcesses::Admin::UpdateParticipatoryProcess.include(Decidim::Geo::ParticipatoryProcessCommandOverride)
+      end
+
+      initializer "decidim_geo.content_blocks" do
+        Decidim.content_blocks.register(:homepage, :geo_maps) do |content_block|
+          content_block.cell = "decidim/geo/content_blocks/geo_maps"
+          content_block.public_name_key = "decidim.geo.content_blocks.name"
+        end
+      end
+
+      initializer "add_cells_view_paths" do
+        Cell::ViewModel.view_paths << File.expand_path("#{Decidim::Geo::Engine.root}/app/cells")
+      end
+
+      initializer "decidim.graphql_api" do
+      end
+
+      initializer "decidim_geo.check_rgeo" do
+        unless RGeo::Geos.supported?
+          Rails.logger.warn("GEOS is not available, but is required for correct interpretation of polygons in shapefiles")
+        end
+      end
+
+      initializer "decidim_geo.webpacker.assets_path" do
+        Decidim.register_assets_path File.expand_path("#{Decidim::Geo::Engine.root}/app/packs")
+      end
+
+    end
+  end
+end

data/lib/decidim/decidim_geo/load_shp/app_load_shp.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Geo
+    module LoadShp
+      class AppLoadShp
+        def initialize(shapefile)
+          logger.info "⚙️ starts shapefile loader (##{now})"
+          @shapefile = shapefile
+        end
+
+        def run!
+          Dir.mktmpdir do |dir|
+            extract_file(dir)
+            shp_reader(dir)
+          end
+        end
+
+        private
+
+          def extract_file(dir)
+            logger.debug "Extract shapefile in tmp dir '#{dir}'"
+            @shapefile.shapefile.blob.open do |file|
+              Zip::File.open(file) do |zip_file|
+                zip_file.each do |entry|
+                  logger.debug "Extracting #{entry.name}"
+                  entry.extract(File.join(dir, entry.name))
+                end
+              end
+            end
+          rescue Exception => e
+            logger.error "can not extract file."
+            logger.error e.message
+            raise e
+          end
+
+          def shp_reader(dir)
+            shp_file = Dir.glob("#{dir}/**/*.shp")
+            logger.info "Shapefile exists ? #{shp_file}"
+            raise "Shapefile doesn't exists" if shp_file.empty?
+            
+            RGeo::Shapefile::Reader.open(shp_file.first, srid: 2056) do |file|
+              logger.info "File contains #{file.num_records} records."
+              
+              file.each do |record|
+                shp_loader(record)
+              end
+            rescue Exception => e
+              logger.error e.message
+              raise e
+            end
+          end
+
+          def shp_loader(record)
+            data = record.attributes
+            @shapefile.shapedatas.create!(data: data, geom: record.geometry)
+          end
+
+          ##
+          # Define logger for the class.
+          def logger
+            @logger ||= Rails.logger
+          end
+
+          ##
+          # Time at the start of the backup task
+          def now
+            @now ||= Time.new.strftime("%Y-%m-%d_%H-%M-%S")
+          end
+
+          ##
+          # Directory where the user's uploads are.
+          def uploads_path
+            @uploads_path ||= "#{ENV.fetch('RAILS_ROOT')}/public/uploads"
+          end
+
+          ##
+          # Directory where the app's logs are.
+          def logs_path
+            @logs_path ||= "#{ENV.fetch('RAILS_ROOT')}/log"
+          end
+      end
+    end
+  end
+end

data/lib/decidim/decidim_geo/space_location/assembly_create_command_override.rb

@@ -0,0 +1,26 @@
+
+module Decidim
+    module Geo
+        module AssemblyCreateCommandOverride
+            extend ActiveSupport::Concern
+            included do
+                alias_method :decidim_original_assembly, :assembly
+                
+                private
+
+                def assembly
+                    serialized_assembly = decidim_original_assembly
+                    return serialized_assembly unless form.decidim_geo_has_address?
+                    
+                    location = serialized_assembly.decidim_geo_space_location || Decidim::Geo::SpaceLocation.new
+                    location.address = form.decidim_geo_space_address
+                    location.latitude = form.latitude
+                    location.longitude = form.longitude
+                    serialized_assembly.decidim_geo_space_location = location
+                    location.save
+                    serialized_assembly
+                end
+            end
+        end
+    end
+end

data/lib/decidim/decidim_geo/space_location/assembly_form_override.rb

@@ -0,0 +1,33 @@
+
+module Decidim
+    module Geo
+        module AssemblyFormOverride
+            extend ActiveSupport::Concern
+            included do
+                alias_method :decidim_original_map_model, :map_model
+                attribute :latitude, ActiveModel::Type::Float
+                attribute :longitude, ActiveModel::Type::Float
+
+                attribute :decidim_geo_space_address, ActiveModel::Type::String        
+                validates :decidim_geo_space_address, geocoding: true, if: ->(form) { form.decidim_geo_has_address? }
+
+                def map_model(model)
+                    decidim_original_map_model(model)
+                    location = model.decidim_geo_space_location || Decidim::Geo::SpaceLocation.new
+                    self.decidim_geo_space_address = location.address
+                end
+                
+                def geocoding_enabled?
+                    Decidim::Map.available?(:geocoding)
+                end
+                def geocoded?
+                    latitude.present? && longitude.present?
+                end
+                def decidim_geo_has_address?
+                    decidim_geo_space_address.present?
+                end
+            end
+
+        end
+    end
+end