decidim-plans 0.15.0

data/lib/decidim/plans/component.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "decidim/components/namer"
+
+Decidim.register_component(:plans) do |component|
+  component.engine = Decidim::Plans::Engine
+  component.admin_engine = Decidim::Plans::AdminEngine
+  component.icon = "decidim/plans/icon.svg"
+
+  component.on(:before_destroy) do |instance|
+    raise "Can't destroy this component when there are plans" if Decidim::Plans::Plan.where(component: instance).any?
+  end
+
+  component.data_portable_entities = ["Decidim::Plans::Plan"]
+
+  component.actions = %w(create withdraw)
+
+  component.permissions_class_name = "Decidim::Plans::Permissions"
+
+  component.settings(:global) do |settings|
+    settings.attribute :plan_title_length, type: :integer, default: 100
+    settings.attribute :plan_answering_enabled, type: :boolean, default: true
+    settings.attribute :comments_enabled, type: :boolean, default: true
+    settings.attribute :announcement, type: :text, translated: true, editor: true
+    settings.attribute :attachments_allowed, type: :boolean, default: false
+    settings.attribute :multilingual_answers, type: :boolean, default: true
+  end
+
+  component.settings(:step) do |settings|
+    settings.attribute :comments_blocked, type: :boolean, default: false
+    settings.attribute :creation_enabled, type: :boolean
+    settings.attribute :plan_answering_enabled, type: :boolean, default: true
+    settings.attribute :announcement, type: :text, translated: true, editor: true
+  end
+
+  component.register_resource(:plan) do |resource|
+    resource.model_class_name = "Decidim::Plans::Plan"
+    resource.card = "decidim/plans/plan"
+  end
+
+  component.register_stat :plans_count, primary: true, priority: Decidim::StatsRegistry::HIGH_PRIORITY do |components, start_at, end_at|
+    Decidim::Plans::FilteredPlans.for(components, start_at, end_at).not_hidden.count
+  end
+
+  component.register_stat :plans_accepted, primary: true, priority: Decidim::StatsRegistry::HIGH_PRIORITY do |components, start_at, end_at|
+    Decidim::Plans::FilteredPlans.for(components, start_at, end_at).accepted.count
+  end
+
+  component.register_stat :comments_count, tag: :comments do |components, start_at, end_at|
+    plans = Decidim::Plans::FilteredPlans.for(components, start_at, end_at).published.not_hidden
+    Decidim::Comments::Comment.where(root_commentable: plans).count
+  end
+
+  component.seeds do |participatory_space|
+    admin_user = Decidim::User.find_by(
+      organization: participatory_space.organization,
+      email: "admin@example.org"
+    )
+
+    step_settings = if participatory_space.allows_steps?
+                      { participatory_space.active_step.id => { creation_enabled: true } }
+                    else
+                      {}
+                    end
+
+    params = {
+      name: Decidim::Components::Namer.new(participatory_space.organization.available_locales, :plans).i18n_name,
+      manifest_name: :plans,
+      published_at: Time.current,
+      participatory_space: participatory_space,
+      settings: {
+        multilingual_answers: true
+      },
+      step_settings: step_settings
+    }
+
+    component = Decidim.traceability.perform_action!(
+      "publish",
+      Decidim::Component,
+      admin_user,
+      visibility: "all"
+    ) do
+      Decidim::Component.create!(params)
+    end
+
+    if participatory_space.scope
+      scopes = participatory_space.scope.descendants
+      global = participatory_space.scope
+    else
+      scopes = participatory_space.organization.scopes
+      global = nil
+    end
+
+    5.times do |n|
+      Decidim::Plans::Section.create!(
+        component: component,
+        body: Decidim::Faker::Localized.paragraph,
+        help: Decidim::Faker::Localized.paragraph,
+        mandatory: false,
+        position: n,
+        section_type: Decidim::Plans::Section::TYPES.first
+      )
+    end
+
+    proposal_component = participatory_space.components.find_by(manifest_name: "proposals")
+    proposals = Decidim::Proposals::Proposal.where(component: proposal_component).to_a
+
+    5.times do |n|
+      state, answer = if n > 3
+                        ["accepted", Decidim::Faker::Localized.sentence(10)]
+                      elsif n > 2
+                        ["rejected", nil]
+                      elsif n > 1
+                        ["evaluating", nil]
+                      else
+                        [nil, nil]
+                      end
+
+      params = {
+        component: component,
+        category: participatory_space.categories.sample,
+        scope: Faker::Boolean.boolean(0.5) ? global : scopes.sample,
+        title: Decidim::Faker::Localized.sentence(2),
+        state: state,
+        answer: answer,
+        answered_at: Time.current,
+        published_at: Time.current
+      }
+
+      plan = Decidim.traceability.perform_action!(
+        "publish",
+        Decidim::Plans::Plan,
+        admin_user,
+        visibility: "all"
+      ) do
+        plan = Decidim::Plans::Plan.new(params)
+        plan.add_coauthor(participatory_space.organization)
+        plan.save!
+
+        plan.proposals << proposals.slice!(0, 2) if proposals.length > 2
+
+        plan
+      end
+
+      if n.positive?
+        Decidim::User.where(decidim_organization_id: participatory_space.decidim_organization_id).all.sample(n).each do |author|
+          user_group = [true, false].sample ? Decidim::UserGroups::ManageableUserGroups.for(author).verified.sample : nil
+          plan.add_coauthor(author, user_group: user_group)
+        end
+      end
+
+      Decidim::Plans::Section.where(component: component).each do |section|
+        plan.contents.create!(
+          body: Decidim::Faker::Localized.paragraph,
+          section: section,
+          user: admin_user
+        )
+      end
+
+      Decidim::Comments::Seed.comments_for(plan)
+    end
+  end
+end

data/lib/decidim/plans/engine.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    class Engine < ::Rails::Engine
+      isolate_namespace Decidim::Plans
+
+      routes do
+        resources :plans do
+          get :search_proposals
+          resource :plan_widget, only: :show, path: "embed"
+          resources :versions, only: [:show, :index]
+          member do
+            get :preview
+            post :publish
+            put :withdraw
+            post :request_access, controller: "plan_collaborator_requests"
+            post :request_accept, controller: "plan_collaborator_requests"
+            post :request_reject, controller: "plan_collaborator_requests"
+          end
+        end
+
+        root to: "plans#index"
+      end
+
+      initializer "decidim_plans.assets" do |app|
+        app.config.assets.precompile += %w(decidim_plans_manifest.js
+                                           decidim_plans_manifest.css
+                                           decidim/plans/identity_selector_dialog.js
+                                           decidim/plans/decidim_plans_manifest.js
+                                           decidim/plans/social_share.js
+                                           decidim/plans/proposal_picker.scss
+                                           decidim/plans/social_share.css.scss
+                                           decidim/plans/plans_form.scss)
+      end
+
+      initializer "decidim_plans.add_cells_view_paths" do
+        Cell::ViewModel.view_paths << File.expand_path("#{Decidim::Plans::Engine.root}/app/cells")
+        Cell::ViewModel.view_paths << File.expand_path("#{Decidim::Plans::Engine.root}/app/views") # for partials
+      end
+    end
+  end
+end

data/lib/decidim/plans/locale_aware.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    module LocaleAware
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def current_locale
+          I18n.locale.to_s
+        end
+      end
+
+      private
+
+      # The current locale for the user. Available as a helper for the views.
+      #
+      # Returns a String.
+      def current_locale
+        @current_locale ||= self.class.current_locale
+      end
+
+      # The available locales in the application. Available as a helper for the
+      # views.
+      #
+      # Returns an Array of Strings.
+      def available_locales
+        @available_locales ||= (current_organization || Decidim).public_send(:available_locales)
+      end
+    end
+  end
+end

data/lib/decidim/plans/optionally_translatable_attributes.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    module OptionallyTranslatableAttributes
+      extend ActiveSupport::Concern
+      include LocaleAware
+      include TranslatableAttributes
+
+      class_methods do
+        def optionally_translatable_attribute(name, type, *options)
+          @translatable_attributes ||= []
+          @translatable_attributes << name
+          translatable_attribute(name, type, *options)
+        end
+
+        def optionally_translatable_validate_presence(attribute, options = {})
+          if_conditional_proc = conditional_proc(options[:if])
+          unless_conditional_proc = conditional_proc(options[:unless])
+          multilingual_proc = proc { |record|
+            record.component.settings.multilingual_answers?
+          }
+
+          multilingual_options = options.dup
+          localized_options = options.dup
+
+          multilingual_options[:if] = proc { |record|
+            multilingual_proc.call(record) && if_conditional_proc.call(record)
+          }
+          localized_options[:unless] = proc { |record|
+            multilingual_proc.call(record) && unless_conditional_proc.call(record)
+          }
+
+          multilingual_options[:translatable_presence] = true
+          localized_options[:presence] = true
+
+          localized_attribute = "#{attribute}_#{current_locale}".to_sym
+          validates attribute, multilingual_options
+          validates localized_attribute, localized_options
+        end
+
+        def translatable_attributes
+          @translatable_attributes
+        end
+
+        def conditional_proc(condition)
+          return proc { true } if condition.nil?
+
+          if condition.is_a?(String) || condition.is_a?(Symbol)
+            return proc { |record|
+              record.send(condition)
+            }
+          end
+
+          proc { |record| condition.call(record) }
+        end
+      end
+
+      def before_validation
+        handle_multilingual_fields
+      end
+
+      private
+
+      def multilingual?
+        component.settings.multilingual_answers?
+      end
+
+      def handle_multilingual_fields
+        return if multilingual?
+
+        self.class.translatable_attributes.each do |name|
+          attr_src_name = "#{name}_#{current_locale}"
+          value = public_send(attr_src_name)
+
+          # Set the same value for all locales as given for the source locale
+          available_locales.each do |loc|
+            attr_name = "#{name}_#{loc}"
+            public_send("#{attr_name}=", value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/decidim/plans/paper_trail/record_trail.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    module PaperTrail
+      module RecordTrail
+        # Saves associations if
+        # a) The version record responds to `track_associations?` and returns
+        #    `true` from it.
+        # b) `PaperTrail.config.track_associations` is set to `true`.
+        def save_associations(version)
+          if version.respond_to?(:track_associations?)
+            return unless version.track_associations?
+          else
+            return unless ::PaperTrail.config.track_associations?
+          end
+
+          save_bt_associations(version)
+          save_habtm_associations(version)
+        end
+      end
+    end
+  end
+end

data/lib/decidim/plans/paper_trail.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "paper_trail-association_tracking"
+require_relative "paper_trail/record_trail"
+
+module PaperTrail
+  class RecordTrail
+    prepend ::Decidim::Plans::PaperTrail::RecordTrail
+  end
+end

data/lib/decidim/plans/test/factories.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "decidim/core/test/factories"
+require "decidim/participatory_processes/test/factories"
+
+FactoryBot.define do
+  factory :section, class: Decidim::Plans::Section do
+    section_type { Decidim::Plans::Section::TYPES.first }
+    body { generate_localized_title }
+    position { 0 }
+    mandatory { false }
+    answer_length { 0 }
+    component
+  end
+
+  factory :content, class: Decidim::Plans::Content do
+    body { generate_localized_title }
+    plan
+    section { create(:section) }
+    user { create(:user, organization: plan.organization) }
+  end
+
+  factory :plan_component, parent: :component do
+    name { Decidim::Components::Namer.new(participatory_space.organization.available_locales, :plans).i18n_name }
+    manifest_name { :plans }
+    participatory_space { create(:participatory_process, :with_steps, organization: organization) }
+
+    trait :with_creation_enabled do
+      step_settings do
+        {
+          participatory_space.active_step.id => { creation_enabled: true }
+        }
+      end
+    end
+
+    trait :with_attachments_allowed do
+      settings do
+        {
+          attachments_allowed: true
+        }
+      end
+    end
+
+    trait :with_single_language_answers do
+      settings do
+        {
+          multilingual_answers: false
+        }
+      end
+    end
+  end
+
+  factory :attached_proposal, class: "Decidim::Plans::AttachedProposal" do
+    plan
+    proposal
+  end
+
+  factory :plan, class: "Decidim::Plans::Plan" do
+    transient do
+      users { nil }
+      plan_proposals { nil }
+      # user_groups correspondence to users is by sorting order
+      user_groups { [] }
+    end
+
+    title { generate_localized_title }
+    component { create(:plan_component) }
+    published_at { Time.current }
+
+    after(:build) do |plan, evaluator|
+      if plan.component
+        users = evaluator.users || [create(:user, organization: plan.component.participatory_space.organization)]
+        users.each_with_index do |user, idx|
+          user_group = evaluator.user_groups[idx]
+          plan.coauthorships.build(author: user, user_group: user_group)
+        end
+
+        proposal_component = create(:proposal_component, participatory_space: plan.component.participatory_space)
+        proposals = evaluator.plan_proposals || [create(:proposal, component: proposal_component)]
+        plan.attached_proposals = proposals.map { |p| create(:attached_proposal, plan: plan, proposal: p) }
+      end
+    end
+
+    trait :published do
+      published_at { Time.current }
+    end
+
+    trait :unpublished do
+      published_at { nil }
+    end
+
+    trait :evaluating do
+      state { "evaluating" }
+      answered_at { Time.current }
+    end
+
+    trait :accepted do
+      state { "accepted" }
+      answered_at { Time.current }
+    end
+
+    trait :rejected do
+      state { "rejected" }
+      answered_at { Time.current }
+    end
+
+    trait :withdrawn do
+      state { "withdrawn" }
+    end
+
+    trait :with_answer do
+      state { "accepted" }
+      answer { generate_localized_title }
+      answered_at { Time.current }
+    end
+
+    trait :open do
+      state { "open" }
+    end
+
+    trait :draft do
+      published_at { nil }
+    end
+  end
+
+  factory :plan_collaborator_request, class: "Decidim::Plans::PlanCollaboratorRequest" do
+    plan
+    user
+  end
+end

data/lib/decidim/plans/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Plans
+    VERSION = "0.15.0"
+    DECIDIM_VERSION = "~> 0.15.0"
+  end
+end

data/lib/decidim/plans.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "plans/version"
+require_relative "plans/admin"
+require_relative "plans/engine"
+require_relative "plans/admin_engine"
+require_relative "plans/paper_trail"
+require_relative "plans/component"
+require_relative "plans/locale_aware"
+require_relative "plans/optionally_translatable_attributes"
+
+module Decidim
+  module Plans
+    # Public: Stores an instance of Loggability
+    def self.loggability
+      @loggability ||= Loggability.new
+    end
+
+    # Public: Stores an instance of Tracer
+    def self.tracer
+      @tracer ||= Tracer.new
+    end
+  end
+end