decidim-toggle 0.1.3

data/README.md

@@ -0,0 +1,90 @@
+# Decidim Toggle
+
+<p align="center">
+  <img src="website/static/img/logo.svg" alt="Decidim Toggle" width="120" />
+</p>
+
+[![pipeline status](https://git.octree.ch/decidim/vocacity/decidim-modules/decidim-toggle/badges/main/pipeline.svg)](https://git.octree.ch/decidim/vocacity/decidim-modules/decidim-toggle/-/commits/main)
+[![License: AGPL-3.0](https://img.shields.io/badge/License-AGPL--3.0-blue.svg)](LICENSE.md)
+[![Docs](https://img.shields.io/badge/docs-octree--gva.github.io-informational)](https://octree-gva.github.io/decidim-toggle/)
+
+Register organization settings tabs for Decidim modules—one form, one command, one read API per gem.
+
+## Contents
+
+- [Quick start](#quick-start)
+- [Host app install](#host-app-install)
+- [Documentation](#documentation)
+- [Development](#development-this-gem)
+- [Support](#support)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Quick start
+
+Add a settings tab in three steps:
+
+1. **Form** — include `Decidim::Toggle::ModuleConfigForm`, set `module_config_name`, declare attributes.
+
+```ruby
+module MyModule
+  class AdminConfigForm < Decidim::Form
+    include Decidim::Toggle::ModuleConfigForm
+
+    self.module_config_name = "my_module"
+    mimic :organization
+    attribute :enabled, :boolean
+  end
+end
+```
+
+2. **Register** — in your engine, after `decidim_toggle.organization_settings_tabs`:
+
+```ruby
+initializer "decidim_my_module.organization_settings_tab", after: "decidim_toggle.organization_settings_tabs" do
+  Decidim::Toggle.settings_tabs :organization_settings do |tabs|
+    tabs.add_tab :my_module, "My module",
+                 form: MyModule::AdminConfigForm,
+                 command: Decidim::Toggle::UpdateModuleConfigCommand,
+                 module_name: :my_module
+  end
+end
+```
+
+3. **Read** — `Decidim::Toggle.config_for(organization, :my_module)`.
+
+Optional view partial: `form_layout_partial:` on `add_tab` — see [Customize views](https://octree-gva.github.io/decidim-toggle/integrate/customize-views).
+
+Full walkthrough: [Add a settings tab](https://octree-gva.github.io/decidim-toggle/integrate/quickstart).
+
+## Host app install
+
+```ruby
+gem "decidim-toggle"
+```
+
+```bash
+bundle install
+rails decidim_toggle:install:migrations
+rails db:migrate
+```
+
+## Documentation
+
+[octree-gva.github.io/decidim-toggle](https://octree-gva.github.io/decidim-toggle/) — integrator guides (registration, views, storage) and contributor docs.
+
+## Development (this gem)
+
+Docker + `./bin/check` (RuboCop, erblint, RSpec) — see [CONTRIBUTING.md](CONTRIBUTING.md) and [Contribute](https://octree-gva.github.io/decidim-toggle/contributing).
+
+## Support
+
+[GitLab issues](https://git.octree.ch/decidim/vocacity/decidim-modules/decidim-toggle/-/issues) for bugs and integration questions.
+
+## Contributing
+
+Pull requests welcome. Read [CONTRIBUTING.md](CONTRIBUTING.md) before opening a merge request.
+
+## License
+
+[AGPL-3.0](LICENSE.md).

data/Rakefile

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "decidim/dev/common_rake"
+
+def install_deps(path)
+  Dir.chdir(path) do
+    system("bundle exec rails decidim:update")
+    system("bundle exec rake db:migrate")
+  end
+end
+
+def seed_db(path)
+  Dir.chdir(path) do
+    system("bundle exec rake db:seed")
+  end
+end
+
+desc "Generates a dummy app for testing"
+task test_app: "decidim:generate_external_test_app"
+
+desc "Generates a development app."
+task :development_app do
+  Bundler.with_original_env do
+    generate_decidim_app(
+      "development_app",
+      "--app_name",
+      "#{base_app_name}_development_app",
+      "--path",
+      "..",
+      "--recreate_db",
+      "--demo",
+      "--locales",
+      "en,ca,es,fr"
+    )
+  end
+  install_deps("development_app")
+  seed_db("development_app")
+end

data/app/commands/decidim/toggle/update_authorizations_command.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Toggle
+    class UpdateAuthorizationsCommand < Decidim::Command
+      def initialize(organization, form)
+        @organization = organization
+        @form = form
+      end
+
+      def call
+        return broadcast(:invalid) if form.invalid?
+
+        transaction do
+          organization.available_authorizations = form.clean_available_authorizations
+          organization.save!
+        end
+
+        Decidim::OrganizationSettings.reload(organization) if defined?(Decidim::OrganizationSettings)
+
+        broadcast(:ok)
+      rescue ActiveRecord::RecordInvalid
+        broadcast(:invalid)
+      end
+
+      private
+
+      attr_reader :organization, :form
+    end
+  end
+end

data/app/commands/decidim/toggle/update_emails_command.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Toggle
+    class UpdateEmailsCommand < Decidim::Command
+      def initialize(organization, form)
+        @organization = organization
+        @form = form
+      end
+
+      def call
+        return broadcast(:invalid) if form.invalid?
+
+        transaction do
+          organization.smtp_settings = form.encrypted_smtp_settings
+          organization.save!
+        end
+
+        Decidim::OrganizationSettings.reload(organization) if defined?(Decidim::OrganizationSettings)
+        broadcast(:ok)
+      rescue ActiveRecord::RecordInvalid
+        broadcast(:invalid)
+      end
+
+      private
+
+      attr_reader :organization, :form
+    end
+  end
+end

data/app/commands/decidim/toggle/update_file_upload_settings_command.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Toggle
+    class UpdateFileUploadSettingsCommand < Decidim::Command
+      def initialize(organization, form)
+        @organization = organization
+        @form = form
+      end
+
+      def call
+        return broadcast(:invalid) if form.invalid?
+
+        transaction do
+          organization.file_upload_settings = form.file_upload_settings.final
+          organization.save!
+        end
+
+        Decidim::OrganizationSettings.reload(organization) if defined?(Decidim::OrganizationSettings)
+
+        broadcast(:ok)
+      rescue ActiveRecord::RecordInvalid
+        broadcast(:invalid)
+      end
+
+      private
+
+      attr_reader :organization, :form
+    end
+  end
+end

data/app/commands/decidim/toggle/update_locale_command.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "rake"
+
+module Decidim
+  module Toggle
+    class UpdateLocaleCommand < Decidim::Command
+      def initialize(organization, form)
+        @organization = organization
+        @form = form
+      end
+
+      def call
+        return broadcast(:invalid) if form.invalid?
+
+        transaction do
+          update_organization_locales
+          rebuild_search_index
+        end
+
+        broadcast(:ok)
+      rescue ActiveRecord::RecordInvalid
+        broadcast(:invalid)
+      end
+
+      private
+
+      attr_reader :organization, :form
+
+      def update_organization_locales
+        organization.available_locales = form.clean_available_locales
+        organization.default_locale = form.default_locale
+        if organization.respond_to?(:enable_machine_translations=)
+          organization.enable_machine_translations = form.enable_machine_translations
+          organization.machine_translation_display_priority = form.machine_translation_display_priority || "original"
+        end
+        organization.save!
+      end
+
+      def rebuild_search_index
+        Rails.application.load_tasks
+        Rake::Task["decidim:locales:rebuild_search"].reenable
+        Rake::Task["decidim:locales:rebuild_search"].invoke
+      end
+    end
+  end
+end

data/app/commands/decidim/toggle/update_module_config_command.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Toggle
+    # Persists a form that includes {ModuleConfigForm} into {OrganizationModuleConfig#config}.
+    class UpdateModuleConfigCommand < Decidim::Command
+      def initialize(organization, form)
+        @organization = organization
+        @form = form
+      end
+
+      def call
+        return broadcast(:invalid) if form.class.module_config_name.blank?
+        return broadcast(:invalid) if form.invalid?
+
+        Decidim::Toggle.save_config!(
+          organization,
+          form.class.module_config_name,
+          form.to_h
+        )
+        broadcast(:ok)
+      rescue ActiveRecord::RecordInvalid
+        broadcast(:invalid)
+      end
+
+      private
+
+      attr_reader :organization, :form
+    end
+  end
+end

data/app/commands/decidim/toggle/update_name_command.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Toggle
+    class UpdateNameCommand < Decidim::Command
+      def initialize(organization, form)
+        @organization = organization
+        @form = form
+      end
+
+      def call
+        return broadcast(:invalid) if form.invalid?
+
+        transaction do
+          organization.name = form.name
+          organization.host = form.host
+          organization.secondary_hosts = form.clean_secondary_hosts
+          organization.save!
+        end
+
+        broadcast(:ok)
+      rescue ActiveRecord::RecordInvalid
+        broadcast(:invalid)
+      end
+
+      private
+
+      attr_reader :organization, :form
+    end
+  end
+end

data/app/commands/decidim/toggle/update_omniauth_command.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Toggle
+    class UpdateOmniauthCommand < Decidim::Command
+      def initialize(organization, form)
+        @organization = organization
+        @form = form
+      end
+
+      def call
+        return broadcast(:invalid) if form.invalid?
+
+        transaction do
+          organization.omniauth_settings = form.encrypted_omniauth_settings
+          organization.save!
+        end
+
+        Decidim::OrganizationSettings.reload(organization) if defined?(Decidim::OrganizationSettings)
+        broadcast(:ok)
+      rescue ActiveRecord::RecordInvalid
+        broadcast(:invalid)
+      end
+
+      private
+
+      attr_reader :organization, :form
+    end
+  end
+end

data/app/commands/decidim/toggle/update_security_command.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Toggle
+    class UpdateSecurityCommand < Decidim::Command
+      def initialize(organization, form)
+        @organization = organization
+        @form = form
+      end
+
+      def call
+        return broadcast(:invalid) if form.invalid?
+
+        transaction do
+          organization.force_users_to_authenticate_before_access_organization = form.force_users_to_authenticate_before_access_organization
+          organization.users_registration_mode = form.users_registration_mode
+          organization.content_security_policy = form.content_security_policy
+          organization.save!
+        end
+
+        broadcast(:ok)
+      rescue ActiveRecord::RecordInvalid
+        broadcast(:invalid)
+      end
+
+      private
+
+      attr_reader :organization, :form
+    end
+  end
+end

data/app/controllers/decidim_toggle/system/settings_tab_controller.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module DecidimToggle
+  module System
+    class SettingsTabController < Decidim::System::ApplicationController
+      def update
+        build_tabs_registry
+        config = registry.form_tab(params[:tab_id])
+        return head :not_found unless config
+
+        @organization = Decidim::Organization.find(params[:organization_id])
+        form_class = config[:form]
+        command_class = config[:command]
+        @form = form(form_class).from_params(params.permit!).with_context(current_organization: @organization)
+
+        command_class.call(@organization, @form) do
+          on(:ok) do
+            flash[:notice] = t("decidim_toggle.system.organizations.form_tab.success")
+            redirect_to settings_tab_redirect_target
+          end
+
+          on(:invalid) do
+            flash[:decidim_toggle_invalid_settings_tab] = {
+              organization_id: @organization.id,
+              tab_id: params[:tab_id].to_s,
+              params: params.fetch(:organization, {}).permit!.to_h,
+              errors: @form.errors.messages.transform_keys(&:to_s).transform_values { |messages| messages.map(&:to_s) }
+            }
+            redirect_to settings_tab_redirect_target
+          end
+        end
+      end
+
+      private
+
+      def build_tabs_registry
+        tabs = Decidim::Toggle::SettingsTabs.new(:organization_settings)
+        tabs.build_for(self)
+      end
+
+      def registry
+        Decidim::Toggle::SettingsTabRegistry.find(:organization_settings)
+      end
+
+      def settings_tab_redirect_target
+        anchor = tab_anchor_fragment
+        return decidim_system.edit_organization_path(@organization) if anchor.blank?
+
+        decidim_system.edit_organization_path(@organization, anchor:)
+      end
+
+      def tab_anchor_fragment
+        tab_id = params[:decidim_toggle_active_tab].presence
+        return nil unless tab_id
+
+        tabs = Decidim::Toggle::SettingsTabs.new(:organization_settings)
+        tabs.build_for(self)
+        return nil unless tabs.items.any? { |item| item.identifier.to_s == tab_id.to_s }
+
+        "panel-toggle-#{tab_id}"
+      end
+    end
+  end
+end

data/app/forms/decidim/toggle/update_authorizations_form.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Toggle
+    # Vanilla Decidim: `available_authorizations` is a string array of workflow names.
+    # Other gems may replace this tab (same identifier `:authorizations`); see
+    # {Decidim::Toggle::OrganizationSettingsTabs}.
+    class UpdateAuthorizationsForm < Decidim::Form
+      mimic :organization
+
+      attribute :available_authorizations, [String]
+
+      validate :available_authorizations_subset_of_workflows
+
+      def self.from_model(organization)
+        from_params(organization: { available_authorizations: Array(organization.available_authorizations).map(&:to_s) })
+      end
+
+      def self.collection_for_available_authorizations
+        Decidim.authorization_workflows.map { |w| [w.name, w.description] }
+      end
+
+      def self.from_params(params, additional_params = {})
+        params = params.to_h.with_indifferent_access if params.respond_to?(:to_h)
+        attrs = params[:organization] || params
+        if attrs[:available_authorizations].nil?
+          params = params.dup
+          params[:organization] = (params[:organization] || {}).merge(available_authorizations: [])
+        end
+        super(params, additional_params)
+      end
+
+      def clean_available_authorizations
+        @clean_available_authorizations ||= if available_authorizations.blank?
+                                              []
+                                            else
+                                              available_authorizations.map(&:to_s).select(&:present?)
+                                            end
+      end
+
+      private
+
+      def available_authorizations_subset_of_workflows
+        return if clean_available_authorizations.blank?
+
+        allowed = Decidim.authorization_workflows.to_set(&:name)
+        invalid = Array(clean_available_authorizations).map(&:to_s).reject { |a| allowed.include?(a) }
+        return if invalid.empty?
+
+        errors.add(:available_authorizations, :invalid)
+      end
+    end
+  end
+end

data/app/forms/decidim/toggle/update_emails_form.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Toggle
+    class UpdateEmailsForm < Decidim::System::BaseOrganizationForm
+      mimic :organization
+
+      # These tabs only update a small JSONB slice (SMTP settings).
+      # The generic system form validates presence of `host` and
+      # `users_registration_mode`, so fall back to the current organization when
+      # those attributes aren't part of the tab payload.
+      def host
+        super.presence || current_organization&.host
+      end
+
+      def users_registration_mode
+        super.presence || current_organization&.users_registration_mode
+      end
+
+      private
+
+      # No-op: this tab doesn't touch organization identity/uniqueness.
+      def validate_organization_uniqueness
+        # intentionally blank
+      end
+    end
+  end
+end

data/app/forms/decidim/toggle/update_file_upload_settings_form.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Toggle
+    # Wraps {Decidim::System::FileUploadSettingsForm} for the settings-tab endpoint
+    # so file upload settings can be saved without submitting the full organization form.
+    class UpdateFileUploadSettingsForm < Decidim::Form
+      mimic :organization
+
+      attribute :file_upload_settings, Decidim::System::FileUploadSettingsForm
+
+      def self.from_model(organization)
+        from_params(
+          organization: {
+            file_upload_settings: Decidim::System::FileUploadSettingsForm.from_model(organization.file_upload_settings)
+          }
+        )
+      end
+
+      def self.from_params(params, additional_params = {})
+        params = params.to_h.with_indifferent_access if params.respond_to?(:to_h)
+        super(params, additional_params)
+      end
+    end
+  end
+end

data/app/forms/decidim/toggle/update_locale_form.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Toggle
+    class UpdateLocaleForm < Decidim::Form
+      mimic :organization
+
+      attribute :available_locales, Array
+      attribute :default_locale, String
+      attribute :enable_machine_translations, Boolean
+      attribute :machine_translation_display_priority, String
+
+      # Decidim::Form delegates :available_locales to current_organization; this form is often
+      # built without context (e.g. system settings tabs), so prefer the attribute value.
+      def available_locales
+        attributes["available_locales"]
+      end
+
+      validates :available_locales, presence: true
+      validates :default_locale, presence: true
+      validates :machine_translation_display_priority,
+                inclusion: { in: %w(original translation) },
+                if: -> { defined?(Decidim::Organization::AVAILABLE_MACHINE_TRANSLATION_DISPLAY_PRIORITIES) && enable_machine_translations }
+      validate :available_locales_subset_of_i18n
+      validate :default_locale_in_available_locales
+      validate :default_locale_in_i18n
+
+      def self.from_model(organization)
+        attrs = locale_attrs_from(organization)
+        attrs[:enable_machine_translations] = organization.enable_machine_translations if organization.respond_to?(:enable_machine_translations)
+        attrs[:machine_translation_display_priority] = organization.machine_translation_display_priority if organization.respond_to?(:machine_translation_display_priority)
+        from_params(attrs)
+      end
+
+      def self.locale_attrs_from(organization)
+        record =
+          if organization.is_a?(Decidim::Organization)
+            organization
+          elsif organization.respond_to?(:id) && organization.id.present?
+            Decidim::Organization.find_by(id: organization.id)
+          end
+
+        source = record || organization
+
+        {
+          available_locales: Array(source.try(:available_locales)).map(&:to_s),
+          default_locale: source.try(:default_locale)&.to_s
+        }
+      end
+      private_class_method :locale_attrs_from
+
+      def self.collection_for_machine_translation_display_priority
+        return [] unless defined?(Decidim::Organization::AVAILABLE_MACHINE_TRANSLATION_DISPLAY_PRIORITIES)
+
+        Decidim::Organization::AVAILABLE_MACHINE_TRANSLATION_DISPLAY_PRIORITIES.map do |priority|
+          [
+            priority,
+            I18n.t("activemodel.attributes.organization.machine_translation_display_priority_#{priority}", default: priority)
+          ]
+        end
+      end
+
+      def self.collection_for_available_locales
+        I18n.available_locales.map { |l| [l.to_s, l.to_s] }
+      end
+
+      def self.collection_for_default_locale
+        I18n.available_locales.map { |l| [l.to_s, l.to_s] }
+      end
+
+      def self.from_params(params, additional_params = {})
+        params = params.to_h.with_indifferent_access if params.respond_to?(:to_h)
+        attrs = params[:organization] || params
+        if attrs[:available_locales].is_a?(Hash)
+          params = params.dup
+          params[:organization] = (params[:organization] || {}).merge(available_locales: attrs[:available_locales].keys.compact_blank)
+        end
+        super(params, additional_params)
+      end
+
+      def clean_available_locales
+        return [] if available_locales.blank?
+
+        allowed = i18n_available_locales_set
+        Array(available_locales).map(&:to_s).select { |l| allowed.include?(l) }
+      end
+
+      private
+
+      def i18n_available_locales_set
+        @i18n_available_locales_set ||= I18n.available_locales.to_set(&:to_s)
+      end
+
+      def available_locales_subset_of_i18n
+        return if available_locales.blank?
+
+        invalid = Array(available_locales).map(&:to_s) - i18n_available_locales_set.to_a
+        return if invalid.empty?
+
+        errors.add(:available_locales, :inclusion)
+      end
+
+      def default_locale_in_available_locales
+        return if default_locale.blank?
+
+        errors.add(:default_locale, :inclusion) unless Array(available_locales).map(&:to_s).include?(default_locale.to_s)
+      end
+
+      def default_locale_in_i18n
+        return if default_locale.blank?
+
+        errors.add(:default_locale, :inclusion) unless i18n_available_locales_set.include?(default_locale.to_s)
+      end
+    end
+  end
+end