decidim-decidim_geo 0.2.1

data/README.md

@@ -0,0 +1,172 @@
+<h1 align="center"><img src="https://github.com/octree-gva/meta/blob/main/decidim/static/header.png?raw=true" alt="Decidim - Octree Participatory democracy on a robust and open source solution" /></h1>
+<h4 align="center">
+    <a href="https://octreegva.notion.site/Roadmap-Decidim-GEO-f191fcb9e220401f8135514a7bd41aab">Roadmap</a> |
+    <a href="https://drive.google.com/file/d/1lfQJumDg0Ic-RZi-R3MM8frYtKN7PB_S/view?usp=sharing">Presentation</a> |
+    <a href="https://github.com/octree-gva/decidim-module-geo/issues">Issues</a>  <br/>
+    <a href="https://www.octree.ch">Octree</a> |
+    <a href="https://octree.ch/en/contact-us/">Contact Us</a> |
+    <a href="https://blog.octree.ch">Our Blog (FR)</a><br/><br/>
+    <a href="https://decidim.org">Decidim</a> |
+    <a href="https://docs.decidim.org/en/">Decidim Docs</a> |
+    <a href="https://meta.decidim.org">Participatory Governance (meta decidim)</a><br/><br/>
+    <a href="https://matrix.to/#/+decidim:matrix.org">Decidim Community (Matrix+Element.io)</a>
+</h4>
+<p align="center">
+    <a href="https://participer.lausanne.ch">
+        <img
+            src="https://github.com/octree-gva/meta/blob/main/decidim/static/participer_lausanne/chip.png?raw=true"
+            alt="Lausanne Participe — Une plateforme de participation pour imaginer et réaliser ensemble" />
+    </a>
+    <a href="https://opencollective.com/voca">
+        <img
+            src="https://github.com/octree-gva/meta/blob/main/decidim/static/opencollective_chip.png?raw=true"
+            alt="Voca – Open-Source SaaS platform for Decidim" />
+    </a>
+</p>
+
+
+# Decidim::Geo
+Have you ever wondered to centralize all the participation in a map? Well, we do and that is the purpose of Decidim GEO. 
+Participation on the map, means: 
+
+* Overview participation: Be able to consult what happens where.
+* Participate: Be able to pin points, select zones, etc. while participating
+
+This project is its early stage, and has it is quiet ambicious, we open CO-FUNDING and setup a public Roadmap here: [https://octreegva.notion.site/Roadmap-Decidim-GEO-f191fcb9e220401f8135514a7bd41aab](https://octreegva.notion.site/Roadmap-Decidim-GEO-f191fcb9e220401f8135514a7bd41aab).
+
+If you are curious on how it started, [we've made some slide to present the project](https://drive.google.com/file/d/1lfQJumDg0Ic-RZi-R3MM8frYtKN7PB_S/view?usp=sharing).
+
+
+## How it works?
+
+Postgis can load Shapefiles that can represents anything: neighbourghoods, cities, states, trees, public spaces.
+We use this module to map a shape to an application zone, to be able to geo-references all the participatory processes of the platform. This way we can offer better consultation experience, and open new perspective for participation.
+
+<img
+    src="https://github.com/octree-gva/meta/blob/main/decidim/static/geo/admin.png?raw=true"
+    alt="Administration of the GEO space" />
+<img
+    src="https://github.com/octree-gva/meta/blob/main/decidim/static/geo/consult.png?raw=true"
+    alt="Administration of the GEO space" />
+
+
+## Installation
+This gem supports decidim version `0.26.x` and `0.27.x`.
+
+Read the [needed dependancies for `rgeo` gem](https://github.com/rgeo/rgeo?tab=readme-ov-file#dependencies). If you have `libgeos-dev`, be sure you have a postgis database with postgres > 14.0.
+
+Add this line to your application's Gemfile:
+```ruby
+gem "decidim-decidim_geo"
+```
+
+Update your database adapter to postgis adapter (already installed as dependancy of this gem): 
+```
+# config/database.yml
+default: &default
+  adapter: postgis
+```
+
+Update your `DATABASE_URL` environment with `postgis://`: 
+```
+DATABASE_URL="postgis://myuser:mypass@localhost/somedatabase"
+```
+
+And then execute:
+
+```bash
+bundle
+bundle exec rails decidim_geo:install:migrations
+bundle exec rails db:migrate
+```
+
+## Testing
+```
+bundle exec rake test_app
+```
+
+## Local development
+First, you need to run an empty database with a decidim dev container which runs nothing.
+```
+docker-compose down -v --remove-orphans
+docker-compose up -d
+```
+Once created, you access the decidim container
+```
+# Get the id of the decidim dev container
+docker ps --format {{.ID}} --filter=label=org.label-schema.name=decidim
+# f16bd5314386
+docker exec -it f16bd5314386 bash
+```
+You are now in bash, run manually `docker-entrypoint`.
+```
+# Will check your environment and do migrations if needed
+docker-entrypoint
+```
+You are now ready to use your container in the way you want for development:
+
+* Run a rails server: `bundle exec rails s -b 0.0.0.0`
+* Have live-reload on your assets: `bin/webpack-dev-server`
+* Execute tasks, like `bundle exec rails g migration AddSomeColumn`
+* etc.
+```
+bundle exec rails s -b 0.0.0.0 # rails server
+bin/webpack-dev-server
+etc.
+```
+
+To stop everything, uses:
+- `docker-compose down` to stop the containers
+- `docker-compose down -v` to stop the containers and remove all previously saved data.
+
+### Debugging
+To debug something on the container:
+1. Ensure `decidim-app` is running
+```bash
+    docker ps --all
+#   CONTAINER ID   IMAGE                           COMMAND                  CREATED        STATUS        PORTS                                            NAMES
+#   f16bd5314386   decidim-geo-development-app     "sleep infinity"   13 hours ago   Up 13 hours   0.0.0.0:3000->3000/tcp, 0.0.0.0:3035->3035/tcp   decidim-app <-------- THIS ONE
+#   b56adf6404d8   decidim-geo-development-app     "bin/webpack-dev-ser…"   54 seconds ago   Up 46 seconds   0.0.0.0:3035->3035/tcp   decidim-webpacker                                       decidim-installer
+#   bc1e912c3d8a   postgis/postgis:14-3.3-alpine   "docker-entrypoint.s…"   13 hours ago   Up 13 hours   0.0.0.0:5432->5432/tcp                           decidim-module-geo-pg-1
+```
+
+2. Run `docker exec -it decidim-app bash`
+3. Run
+    - `tail -f $ROOT/log/development.log` to **access logs**
+    - `bundle exec rails restart` to **restart rails server AND keeps webpacker running**
+    - `cd $ROOT` to access the `development_app`
+    - `cd $ROOT/../decidim_module_geo` to access the module directory
+
+### FAQ
+
+**I can't see logs on the `decidim-app`?**
+`decidim-app` runs here in development `webpacker-dev-server` AND a puma server, on the same container. 
+Thus, we just run both, and only one will be displayed on STDOUT. To see puma log: `docker exec decidim-app tail -f /home/app/decidim/log/development.log`
+
+**It takes for ever to pull the image?**
+Try to pull from docker hub before doing your install script. `docker pull hfroger/decidim:0.26.8-dev` can help. 
+
+**Why must I access to `127.0.0.1` and not `localhost`?**
+`webpack-dev-server` run a websocket server on port 3535, and the rails server needs to connect to it. 
+`localhost` won't make the trick, and you need to use a "real" ip, like `127.0.0.1`.  [More info](https://stackoverflow.com/a/54102318)
+
+## Contributing
+
+We are not yet ready for contributions, but we are working on a goood workflow
+
+# Why it's not on MetaDecidim?
+We think Decidim is already over complicated to install and setup. This module uses PosGis extensions on a postgres database, that can be hard to install. We block the proposal to metadecidim until these points are solved:
+
+- We have stable release.
+- We have feedbacks from participants that it is actually usefull.
+- We have feedbacks from Decidim's admins that this is actually improving participation.
+- Decidim run primarly on docker, with an updated documentation on installation. (We, at Octree is working on it for a while)
+
+## License
+
+This engine is distributed under the [GNU AFFERO GENERAL PUBLIC LICENSE](LICENSE-AGPLv3.txt)
+
+<br /><br />
+<p align="center">
+    <img src="https://raw.githubusercontent.com/octree-gva/meta/main/decidim/static/octree_and_decidim.png" height="90" alt="Decidim Installation by Octree" />
+</p>

data/Rakefile

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "decidim/dev/common_rake"
+
+def install_module(path)
+  Dir.chdir(path) do
+    system("bundle exec rake decidim_geo:install:migrations")
+  end
+end
+
+def seed_db(path)
+  Dir.chdir(path) do
+    system("bundle exec rake db:seed")
+  end
+end
+
+##
+# Tasks for test_app
+##
+
+desc "Prepare for testing"
+task :prepare_tests do
+  # Remove previous existing db, and recreate one.
+  Dir.chdir("development_app") do
+    system("bundle exec rake db:drop")
+    system("bundle exec rake db:create")
+  end
+  ENV["RAILS_ENV"] = "test"
+  databaseYml = {
+    "test" => {
+      "adapter" => "postgis",
+      "encoding" => "unicode",
+      "host" => ENV.fetch("DATABASE_HOST", "localhost"),
+      "port" => ENV.fetch("DATABASE_PORT", "5432").to_i,
+      "username" => ENV.fetch("DATABASE_USERNAME", "decidim"),
+      "password" => ENV.fetch("DATABASE_PASSWORD", "insecure-password"),
+      "database" => "#{base_app_name}_test"
+    }
+  }
+  config_file = File.expand_path("spec/decidim_dummy_app/config/database.yml", __dir__)
+  File.open(config_file, "w") { |f| YAML.dump(databaseYml, f) }
+  Dir.chdir("spec/decidim_dummy_app") do
+     system("bundle exec rails db:migrate")
+   end
+end
+
+desc "Generates a decidim_dummy_app app for testing"
+task :test_app do
+  Bundler.with_original_env do
+    generate_decidim_app(
+      "spec/decidim_dummy_app",
+        "--app_name",
+        "#{base_app_name}",
+        "--path",
+        "../..",
+        "--skip_spring",
+        "--demo",
+        "--force_ssl",
+        "false",
+        "--locales",
+        "en,fr,es"
+    )
+  end
+  install_module("spec/decidim_dummy_app")
+  Rake::Task["prepare_tests"].invoke
+end
+
+##
+# Tasks for developement_app
+##
+
+desc "Prepare for development"
+task :prepare_dev do
+  # Remove previous existing db, and recreate one.
+  Dir.chdir("development_app") do
+    system("bundle exec rake db:drop")
+    system("bundle exec rake db:create")
+  end
+  ENV["RAILS_ENV"] = "development"
+  databaseYml = {
+    "development" => {
+      "adapter" => "postgis",
+      "encoding" => "unicode",
+      "host" => ENV.fetch("DATABASE_HOST", "localhost"),
+      "port" => ENV.fetch("DATABASE_PORT", "5432").to_i,
+      "username" => ENV.fetch("DATABASE_USERNAME", "decidim"),
+      "password" => ENV.fetch("DATABASE_PASSWORD", "insecure-password"),
+      "database" => "#{base_app_name}_development",
+    }
+  }
+  config_file = File.expand_path("development_app/config/database.yml", __dir__)
+  File.open(config_file, "w") { |f| YAML.dump(databaseYml, f) }
+  Dir.chdir("development_app") do
+    system("bundle exec rake db:migrate")
+    system("npm install -D webpack-dev-server")
+  end
+end
+
+desc "Generates a development app"
+task :development_app do
+  Bundler.with_original_env do
+    generate_decidim_app(
+      "development_app",
+      "--app_name",
+      "#{base_app_name}",
+      "recreate_db",
+      "--path",
+      "..",
+      "--skip_spring",
+      "--demo",
+      "--force_ssl",
+      "false",
+      "--demo"
+    )
+  end
+
+  install_module("development_app")
+  Rake::Task["prepare_dev"].invoke
+end

data/app/cells/decidim/geo/content_blocks/geo_maps/show.erb

@@ -0,0 +1,15 @@
+<link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.2/dist/leaflet.css" integrity="sha256-sA+zWATbFveLLNqWO2gtiw3HL/lh1giY/Inf1BJ0z14=" crossorigin="">
+<script src="https://unpkg.com/leaflet@1.9.2/dist/leaflet.js" integrity="sha256-o9N1jGDZrf5tS+Ft4gbIK7mYMipq9lqpVJ91xHSyKhg=" crossorigin=""></script>
+
+<style>
+  .decidimgeo__map {
+    height: 640px;
+    width: 100%;
+    max-width: 100%;
+    max-height: 100%;
+  }  
+</style>
+
+<%= javascript_pack_tag "decidim_geo" %>
+
+<%= insert_map %>

data/app/cells/decidim/geo/content_blocks/geo_maps_cell.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Geo
+    module ContentBlocks
+      class GeoMapsCell < Decidim::ViewModel
+        #delegate :current_user, to: :controller
+        include Decidim::SanitizeHelper
+
+        def show
+          render unless @options.empty?
+        end
+
+        private
+
+          def insert_map
+            id = @options[:id] || "HomePage"
+            filters = @options[:filters] || []
+            config = {
+              locale: current_locale,
+              space_ids: @options[:scopes] || [],
+              selected_component: current_component || nil,
+              selected_point: current_component? && params[:id] ? params[:id] : nil,
+              images: {
+                not_geolocated: ActionController::Base.helpers.asset_pack_path("media/images/not-geolocated.svg")
+              },
+              filters: @options[:filters] || [],
+              map_config: {
+                lat: geo_config[:latitude],
+                lng: geo_config[:longitude],
+                tile_layer: geo_config[:tile],
+                zoom: geo_config[:zoom]
+              }
+            }.with_indifferent_access
+
+            content_tag(
+              :div, 
+              '',
+              id: "DecidimGeo",
+              class: [
+                "js-decidimgeo", 
+                "decidimgeo__map", 
+                "decidimgeo__map--#{id.underscore}"
+              ],
+              "data-config" => config.to_json,
+              "data-i18n" => geo_i18n.to_json
+            )
+          end
+
+          def geo_i18n
+            supported_models = [
+              Decidim::Meetings::Meeting, 
+              Decidim::Proposals::Proposal, 
+              Decidim::ParticipatoryProcess, 
+              Decidim::Assembly, 
+              Decidim::Debates::Debate              
+            ]
+            geo_i18n = supported_models.map { |klass| [klass.name, klass.model_name.human] }.to_h
+            geo_i18n = {
+              **geo_i18n,
+              "decidim_geo.scopes.all":  t('decidim.geo.scopes.all'),
+              "decidim_geo.scopes.dropdown":  t('decidim.geo.scopes.dropdown'),
+              "decidim_geo.filters.back":  t('decidim.geo.filters.back'),
+              "decidim_geo.filters.button":  t('decidim.geo.filters.button'),
+              "decidim_geo.filters.geo.label":  t('decidim.geo.filters.geo.label'),
+              "decidim_geo.filters.geo.all":  t('decidim.geo.filters.geo.all'),
+              "decidim_geo.filters.geo.only_geoencoded":  t('decidim.geo.filters.geo.only_geoencoded'),
+              "decidim_geo.filters.geo.only_virtual":  t('decidim.geo.filters.geo.only_virtual'),
+              "decidim_geo.filters.time.label":  t('decidim.geo.filters.time.label'),
+              "decidim_geo.filters.time.all":  t('decidim.geo.filters.time.all'),
+              "decidim_geo.filters.time.only_past":  t('decidim.geo.filters.time.only_past'),
+              "decidim_geo.filters.time.only_active":  t('decidim.geo.filters.time.only_active'),
+              "decidim_geo.filters.time.only_future":  t('decidim.geo.filters.time.only_future'),
+              "decidim_geo.filters.type.label":  t('decidim.geo.filters.type.label'),
+              "decidim_geo.filters.type.all":  t('decidim.geo.filters.type.all'),
+              "decidim_geo.filters.type.only_processes":  t('decidim.geo.filters.type.only_processes'),
+              "decidim_geo.filters.type.only_assemblies":  t('decidim.geo.filters.type.only_assemblies'),
+              "decidim_geo.filters.type.only_proposals":  t('decidim.geo.filters.type.only_proposals'),
+              "decidim_geo.filters.type.only_meetings":  t('decidim.geo.filters.type.only_meetings'),
+
+            }
+          end
+
+
+          def current_locale
+            I18n.locale.to_s
+          end
+
+          def current_component
+            return request.env["decidim.current_component"].id if current_component?
+            "none"
+          end  
+
+          def current_component?
+            request.env["decidim.current_component"].present?
+          end  
+
+          def geo_config
+            { 
+              latitude: model.try(:latitude).nil? ? geo_config_default.latitude : model.latitude, 
+              longitude: model.try(:longitude).nil? ? geo_config_default.longitude: model.longitude,
+              tile: Decidim::Geo::GeoConfig.geo_config_default.tile,
+              zoom: Decidim::Geo::GeoConfig.geo_config_default.zoom
+            }.to_h 
+          end
+
+          def geo_config_default
+            Decidim::Geo::GeoConfig.geo_config_default
+          end
+
+      end
+    end
+  end
+end

data/app/cells/decidim/geo/content_blocks/geo_maps_settings_form_cell.rb

@@ -0,0 +1,14 @@
+module Decidim
+  module Geo
+    module ContentBlocks
+      class GeoMapsSettingsFormCell < Decidim::ViewModel
+        alias form model
+
+        def content_block
+          options[:content_block]
+        end
+
+      end
+    end
+  end
+end

data/app/cells/decidim/geo/geo_collection_map/show.erb

@@ -0,0 +1,4 @@
+<%
+    #  cell("decidim/geo/content_blocks/geo_maps", nil, **search_options) if search_controller? 
+%>
+<%= cell("decidim/geo/content_blocks/geo_maps", nil, **collection_options) if participatory_space? %>

data/app/cells/decidim/geo/geo_collection_map_cell.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Geo
+    class GeoCollectionMapCell < Decidim::ViewModel
+      delegate :current_user, to: :controller
+      include Decidim::SanitizeHelper
+
+      def show
+        render
+      end
+
+      private
+      def participatory_space?
+        [
+          "decidim/assemblies/assemblies:index",
+          "decidim/participatory_processes/participatory_processes:index"
+        ].include? "#{params[:controller]}:#{params[:action]}"
+      end
+
+      def search_controller?
+        params[:controller] == "decidim/searches"
+      end
+
+      def search_options
+        param_filter = params[:filter]
+        return {} if param_filter.nil?
+        param_filter.permit!
+        filters = param_filter.keys.map do |key|
+          case "#{key}"
+          when "resource_type"
+            {resourceTypeFilter: {resourceType: param_filter[key]}}
+          when "term"
+            {termFilter: {term: param_filter[key]}}
+          when "decidim_scope_id"
+            {scopeFilter: {scopeId: [param_filter[key]]}}
+          when "space_state"
+            {termFilter: {space_state: param_filter[key]}}
+          end
+        end.select {|v| !v.nil?}
+        {
+          id: "Search",
+          filters: filters,
+          scopes: []
+        }
+      end
+
+      def collection_options
+        case "#{params[:controller]}:#{params[:action]}"
+        when "decidim/assemblies/assemblies:index"
+            {
+              id: "Assemblies",
+              filters: assemblies_filter,
+              scopes: assemblies_scopes
+            }
+        when "decidim/participatory_processes/participatory_processes:index"
+            {
+              id: "Processes",
+              filters: processes_filter,
+              scopes: processes_scopes
+            }
+        else
+          {}
+        end
+      end
+
+      def visible_processes
+        Decidim::ParticipatoryProcess.visible_for(
+          current_user
+        )
+      end
+      def processes_scopes
+        visible_processes.map { |a| a.scopes.map{ |s| s.id} }.flatten.uniq
+      end
+      def visible_assemblies
+        Decidim::Assembly.visible_for(
+          current_user
+        )
+      end
+      def assemblies_scopes
+        visible_assemblies.map { |a| a.scopes.map{ |s| s.id} }.flatten.uniq
+      end
+
+      def assemblies_filter
+        return [{resourceTypeFilter: {resourceType: "Decidim::Assembly"}}] if geo_config.only_assemblies
+        # Filter only content that are bound to one of the displayed assemblies
+        visible_assemblies.map {|assembly| {assemblyFilter: {assemblyId: assembly.id}} }
+      end
+      
+      def processes_filter
+        return [{resourceTypeFilter: {resourceType: "Decidim::ParticipatoryProcess"}}] if geo_config.only_processes
+        # Filter only content that are bound to one of the displayed processes
+        visible_processes.map {|process| {processFilter: {processId: process.id}} }
+      end
+
+      def geo_config
+        Decidim::Geo::GeoConfig.geo_config_default
+      end
+    end
+  end
+end
+  

data/app/commands/decidim/admin/create_scope.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    # A command with all the business logic when creating a static scope.
+    class CreateScope < Decidim::Geo::Command
+      # Public: Initializes the command.
+      #
+      # form - A form object with the params.
+      # parent_scope - A parent scope for the scope to be created
+      def initialize(form, parent_scope = nil)
+        @form = form
+        @parent_scope = parent_scope
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid.
+      # - :invalid if the form wasn't valid and we couldn't proceed.
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) if form.invalid?
+
+        scope = create_scope
+        broadcast(:ok, :scope=>scope)
+      end
+
+      private
+
+      attr_reader :form
+
+      def create_scope
+        Decidim.traceability.create!(
+          Scope,
+          form.current_user,
+          {
+            name: form.name,
+            organization: form.organization,
+            code: form.code,
+            scope_type: form.scope_type,
+            parent: @parent_scope
+          },
+          extra: {
+            parent_name: @parent_scope.try(:name),
+            scope_type_name: form.scope_type.try(:name)
+          }
+        )
+      end
+
+      def shapedata
+        Decidim::Geo::Shapedata.find_by_id(form.shapedata)
+      end
+    end
+  end
+end

data/app/commands/decidim/admin/create_scope_type.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    # A command with all the business logic when creating a scope type.
+    class CreateScopeType < Decidim::Geo::Command
+      # Public: Initializes the command.
+      #
+      # form - A form object with the params.
+      def initialize(form, user = nil)
+        @form = form
+        @user = user
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid.
+      # - :invalid if the form wasn't valid and we couldn't proceed.
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) if form.invalid?
+
+        create_scope_type
+        broadcast(:ok)
+      end
+
+      private
+
+      attr_reader :form
+
+      def create_scope_type
+        scope_type = ScopeType.create!(
+          name: form.name,
+          organization: form.organization,
+          plural: form.plural
+        )
+        scope_type.shapefile = shapefile
+        scope_type.save!
+      end
+
+      def shapefile
+        Decidim::Geo::Shapefile.find_by_id(form.shapefile)
+      end
+    end
+  end
+end