decidim-proposals 0.27.8 → 0.28.0.rc4

data/lib/decidim/proposals/seeds.rb

@@ -0,0 +1,278 @@
+# frozen_string_literal: true
+
+require "decidim/components/namer"
+require "decidim/faker/localized"
+
+module Decidim
+  module Proposals
+    class Seeds < Decidim::Seeds
+      attr_reader :participatory_space
+
+      def initialize(participatory_space:)
+        @participatory_space = participatory_space
+      end
+
+      def call
+        component = create_component!
+
+        5.times do |n|
+          proposal = create_proposal!(component:)
+
+          emendation = create_emendation!(proposal:) if proposal.state.nil?
+
+          (n % 3).times do |_m|
+            create_proposal_votes!(proposal:, emendation:)
+          end
+
+          (n % 3).times do
+            create_proposal_notes!(proposal:)
+          end
+
+          Decidim::Comments::Seed.comments_for(proposal)
+
+          create_collaborative_draft!(component:)
+        end
+
+        update_traceability!(component:)
+      end
+
+      def organization
+        @organization ||= participatory_space.organization
+      end
+
+      def create_component!
+        step_settings = if participatory_space.allows_steps?
+                          { participatory_space.active_step.id => { votes_enabled: true, votes_blocked: false, creation_enabled: true } }
+                        else
+                          {}
+                        end
+
+        params = {
+          name: Decidim::Components::Namer.new(participatory_space.organization.available_locales, :proposals).i18n_name,
+          manifest_name: :proposals,
+          published_at: Time.current,
+          participatory_space:,
+          settings: {
+            vote_limit: 0,
+            collaborative_drafts_enabled: true
+          },
+          step_settings:
+        }
+
+        Decidim.traceability.perform_action!(
+          "publish",
+          Decidim::Component,
+          admin_user,
+          visibility: "all"
+        ) do
+          Decidim::Component.create!(params)
+        end
+      end
+
+      def create_proposal!(component:)
+        n = rand(5)
+        state, answer, state_published_at = if n > 3
+                                              ["accepted", Decidim::Faker::Localized.sentence(word_count: 10), Time.current]
+                                            elsif n > 2
+                                              ["rejected", nil, Time.current]
+                                            elsif n > 1
+                                              ["evaluating", nil, Time.current]
+                                            elsif n.positive?
+                                              ["accepted", Decidim::Faker::Localized.sentence(word_count: 10), nil]
+                                            else
+                                              ["not_answered", nil, nil]
+                                            end
+
+        params = {
+          component:,
+          category: participatory_space.categories.sample,
+          scope: random_scope(participatory_space:),
+          title: { en: ::Faker::Lorem.sentence(word_count: 2) },
+          body: { en: ::Faker::Lorem.paragraphs(number: 2).join("\n") },
+          state:,
+          answer:,
+          answered_at: state.present? ? Time.current : nil,
+          state_published_at:,
+          published_at: Time.current
+        }
+
+        proposal = Decidim.traceability.perform_action!(
+          "publish",
+          Decidim::Proposals::Proposal,
+          admin_user,
+          visibility: "all"
+        ) do
+          proposal = Decidim::Proposals::Proposal.new(params)
+          meeting_component = participatory_space.components.find_by(manifest_name: "meetings")
+
+          coauthor = case n
+                     when 0
+                       Decidim::User.where(organization:).sample
+                     when 1
+                       Decidim::UserGroup.where(organization:).sample
+                     when 2
+                       Decidim::Meetings::Meeting.where(component: meeting_component).sample
+                     else
+                       organization
+                     end
+          proposal.add_coauthor(coauthor)
+          proposal.save!
+          proposal
+        end
+      end
+
+      def random_nickname
+        "#{::Faker::Twitter.unique.screen_name}-#{SecureRandom.hex(4)}"[0, 20]
+      end
+
+      def random_email(suffix:)
+        r = SecureRandom.hex(4)
+
+        "#{suffix}-author-#{participatory_space.underscored_name}-#{participatory_space.id}-#{r}@example.org"
+      end
+
+      def create_emendation!(proposal:)
+        author = Decidim::User.find_or_initialize_by(email: random_email(suffix: "amendment"))
+        author.update!(
+          password: "decidim123456789",
+          name: "#{::Faker::Name.name} #{participatory_space.id}",
+          nickname: random_nickname,
+          organization:,
+          tos_agreement: "1",
+          confirmed_at: Time.current
+        )
+
+        group = Decidim::UserGroup.create!(
+          name: ::Faker::Name.name,
+          nickname: random_nickname,
+          email: ::Faker::Internet.email,
+          extended_data: {
+            document_number: ::Faker::Code.isbn,
+            phone: ::Faker::PhoneNumber.phone_number,
+            verified_at: Time.current
+          },
+          organization:,
+          confirmed_at: Time.current
+        )
+
+        Decidim::UserGroupMembership.create!(
+          user: author,
+          role: "creator",
+          user_group: group
+        )
+
+        params = {
+          component: proposal.component,
+          category: participatory_space.categories.sample,
+          scope: random_scope(participatory_space:),
+          title: { en: "#{proposal.title["en"]} #{::Faker::Lorem.sentence(word_count: 1)}" },
+          body: { en: "#{proposal.body["en"]} #{::Faker::Lorem.sentence(word_count: 3)}" },
+          state: "evaluating",
+          answer: nil,
+          answered_at: Time.current,
+          published_at: Time.current
+        }
+
+        emendation = Decidim.traceability.perform_action!(
+          "create",
+          Decidim::Proposals::Proposal,
+          author,
+          visibility: "public-only"
+        ) do
+          emendation = Decidim::Proposals::Proposal.new(params)
+          emendation.add_coauthor(author, user_group: author.user_groups.first)
+          emendation.save!
+          emendation
+        end
+
+        Decidim::Amendment.create!(
+          amender: author,
+          amendable: proposal,
+          emendation:,
+          state: "evaluating"
+        )
+
+        emendation
+      end
+
+      def create_proposal_votes!(proposal:, emendation: nil)
+        author = Decidim::User.find_or_initialize_by(email: random_email(suffix: "vote"))
+        author.update!(
+          password: "decidim123456789",
+          name: "#{::Faker::Name.name} #{participatory_space.id}",
+          nickname: random_nickname,
+          organization:,
+          tos_agreement: "1",
+          confirmed_at: Time.current,
+          personal_url: ::Faker::Internet.url,
+          about: ::Faker::Lorem.paragraph(sentence_count: 2)
+        )
+
+        Decidim::Proposals::ProposalVote.create!(proposal:, author:) unless proposal.published_state? && proposal.rejected?
+        Decidim::Proposals::ProposalVote.create!(proposal: emendation, author:) if emendation
+      end
+
+      def create_proposal_notes!(proposal:)
+        author_admin = Decidim::User.where(organization:, admin: true).all.sample
+
+        Decidim::Proposals::ProposalNote.create!(
+          proposal:,
+          author: author_admin,
+          body: ::Faker::Lorem.paragraphs(number: 2).join("\n")
+        )
+      end
+
+      def create_collaborative_draft!(component:)
+        n = rand(5)
+        state = if n > 3
+                  "published"
+                elsif n > 2
+                  "withdrawn"
+                else
+                  "open"
+                end
+        author = Decidim::User.where(organization:).all.sample
+
+        draft = Decidim.traceability.perform_action!("create", Decidim::Proposals::CollaborativeDraft, author) do
+          draft = Decidim::Proposals::CollaborativeDraft.new(
+            component:,
+            category: participatory_space.categories.sample,
+            scope: random_scope(participatory_space:),
+            title: ::Faker::Lorem.sentence(word_count: 2),
+            body: ::Faker::Lorem.paragraphs(number: 2).join("\n"),
+            state:,
+            published_at: Time.current
+          )
+          draft.coauthorships.build(author: participatory_space.organization)
+          draft.save!
+          draft
+        end
+
+        case n
+        when 2
+          authors = Decidim::User.where(organization:).all.sample(5)
+          authors.each do |local_author|
+            Decidim::Coauthorship.create(coauthorable: draft, author: local_author)
+          end
+        when 3
+          author2 = Decidim::User.where(organization:).all.sample
+          Decidim::Coauthorship.create(coauthorable: draft, author: author2)
+        end
+
+        Decidim::Comments::Seed.comments_for(draft)
+      end
+
+      def update_traceability!(component:)
+        Decidim.traceability.update!(
+          Decidim::Proposals::CollaborativeDraft.all.sample,
+          Decidim::User.where(organization:).all.sample,
+          component:,
+          category: participatory_space.categories.sample,
+          scope: random_scope(participatory_space:),
+          title: ::Faker::Lorem.sentence(word_count: 2),
+          body: ::Faker::Lorem.paragraphs(number: 2).join("\n")
+        )
+      end
+    end
+  end
+end

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

@@ -1,17 +1,16 @@
 # frozen_string_literal: true
 
+require "decidim/components/namer"
 require "decidim/core/test/factories"
 require "decidim/participatory_processes/test/factories"
 require "decidim/meetings/test/factories"
 
 FactoryBot.define do
   factory :proposal_component, parent: :component do
-    transient do
-      skip_injection { false }
-    end
-    name { generate_component_name(participatory_space.organization.available_locales, :proposals) }
+    name { Decidim::Components::Namer.new(participatory_space.organization.available_locales, :proposals).i18n_name }
     manifest_name { :proposals }
-    participatory_space { create(:participatory_process, :with_steps, organization: organization, skip_injection: skip_injection) }
+    participatory_space { create(:participatory_process, :with_steps, organization:) }
+
     trait :with_endorsements_enabled do
       step_settings do
         {
@@ -59,7 +58,7 @@ FactoryBot.define do
 
       settings do
         {
-          vote_limit: vote_limit
+          vote_limit:
         }
       end
     end
@@ -71,7 +70,7 @@ FactoryBot.define do
 
       settings do
         {
-          proposal_limit: proposal_limit
+          proposal_limit:
         }
       end
     end
@@ -83,7 +82,7 @@ FactoryBot.define do
 
       settings do
         {
-          proposal_length: proposal_length
+          proposal_length:
         }
       end
     end
@@ -141,7 +140,7 @@ FactoryBot.define do
 
       settings do
         {
-          threshold_per_proposal: threshold_per_proposal
+          threshold_per_proposal:
         }
       end
     end
@@ -178,7 +177,7 @@ FactoryBot.define do
 
       settings do
         {
-          minimum_votes_per_user: minimum_votes_per_user
+          minimum_votes_per_user:
         }
       end
     end
@@ -225,8 +224,8 @@ FactoryBot.define do
       step_settings do
         {
           participatory_space.active_step.id => {
-            automatic_hashtags: automatic_hashtags,
-            suggested_hashtags: suggested_hashtags,
+            automatic_hashtags:,
+            suggested_hashtags:,
             creation_enabled: true
           }
         }
@@ -252,16 +251,40 @@ FactoryBot.define do
       skip_injection { false }
     end
 
-    title { generate_localized_title(:proposal_title, skip_injection: skip_injection) }
-    body { generate_localized_description(:proposal_body, skip_injection: skip_injection) }
-    component { create(:proposal_component, skip_injection: skip_injection) }
+    title do
+      if skip_injection
+        Decidim::Faker::Localized.localized { generate(:title) }
+      else
+        Decidim::Faker::Localized.localized { "<script>alert(\"Proposal TITLE\");</script> #{generate(:title)}" }
+      end
+    end
+    body do
+      if skip_injection
+        Decidim::Faker::Localized.localized { Faker::Lorem.sentences(number: 3).join("\n") }
+      else
+        Decidim::Faker::Localized.localized { "<script>alert(\"Proposal BODY\");</script> #{Faker::Lorem.sentences(number: 3).join("\n")}" }
+      end
+    end
+    component { create(:proposal_component) }
     published_at { Time.current }
     address { "#{Faker::Address.street_name}, #{Faker::Address.city}" }
     latitude { Faker::Address.latitude }
     longitude { Faker::Address.longitude }
     cost { 20_000 }
-    cost_report { generate_localized_title(:proposal_cost_report, skip_injection: skip_injection) }
-    execution_period { generate_localized_title(:proposal_execution_period, skip_injection: skip_injection) }
+    cost_report do
+      if skip_injection
+        Decidim::Faker::Localized.localized { generate(:title) }
+      else
+        Decidim::Faker::Localized.localized { "<script>alert(\"Proposal cost report\")</script> #{generate(:title)}" }
+      end
+    end
+    execution_period do
+      if skip_injection
+        Decidim::Faker::Localized.localized { generate(:title) }
+      else
+        Decidim::Faker::Localized.localized { "<script>alert(\"Proposal execution period\")</script> #{generate(:title)}" }
+      end
+    end
 
     after(:build) do |proposal, evaluator|
       proposal.title = if evaluator.title.is_a?(String)
@@ -279,10 +302,10 @@ FactoryBot.define do
       proposal.body = Decidim::ContentProcessor.parse_with_processor(:hashtag, proposal.body, current_organization: proposal.organization).rewrite
 
       if proposal.component
-        users = evaluator.users || [create(:user, :confirmed, organization: proposal.component.participatory_space.organization, skip_injection: evaluator.skip_injection)]
+        users = evaluator.users || [create(:user, :confirmed, organization: proposal.component.participatory_space.organization)]
         users.each_with_index do |user, idx|
           user_group = evaluator.user_groups[idx]
-          proposal.coauthorships.build(author: user, user_group: user_group)
+          proposal.coauthorships.build(author: user, user_group:)
         end
       end
     end
@@ -296,19 +319,19 @@ FactoryBot.define do
     end
 
     trait :participant_author do
-      after :build do |proposal, evaluator|
+      after :build do |proposal|
         proposal.coauthorships.clear
-        user = build(:user, organization: proposal.component.participatory_space.organization, skip_injection: evaluator.skip_injection)
+        user = build(:user, organization: proposal.component.participatory_space.organization)
         proposal.coauthorships.build(author: user)
       end
     end
 
     trait :user_group_author do
-      after :build do |proposal, evaluator|
+      after :build do |proposal|
         proposal.coauthorships.clear
-        user = create(:user, organization: proposal.component.participatory_space.organization, skip_injection: evaluator.skip_injection)
-        user_group = create(:user_group, :verified, organization: user.organization, users: [user], skip_injection: evaluator.skip_injection)
-        proposal.coauthorships.build(author: user, user_group: user_group)
+        user = create(:user, organization: proposal.component.participatory_space.organization)
+        user_group = create(:user_group, :verified, organization: user.organization, users: [user])
+        proposal.coauthorships.build(author: user, user_group:)
       end
     end
 
@@ -320,10 +343,10 @@ FactoryBot.define do
     end
 
     trait :official_meeting do
-      after :build do |proposal, evaluator|
+      after :build do |proposal|
         proposal.coauthorships.clear
-        component = build(:meeting_component, participatory_space: proposal.component.participatory_space, skip_injection: evaluator.skip_injection)
-        proposal.coauthorships.build(author: build(:meeting, component: component, skip_injection: evaluator.skip_injection))
+        component = build(:meeting_component, participatory_space: proposal.component.participatory_space)
+        proposal.coauthorships.build(author: build(:meeting, component:))
       end
     end
 
@@ -364,7 +387,7 @@ FactoryBot.define do
     end
 
     trait :not_answered do
-      state { nil }
+      state { :not_answered }
     end
 
     trait :draft do
@@ -372,108 +395,93 @@ FactoryBot.define do
     end
 
     trait :hidden do
-      after :create do |proposal, evaluator|
-        create(:moderation, hidden_at: Time.current, reportable: proposal, skip_injection: evaluator.skip_injection)
+      after :create do |proposal|
+        create(:moderation, hidden_at: Time.current, reportable: proposal)
       end
     end
 
     trait :with_votes do
-      after :create do |proposal, evaluator|
-        create_list(:proposal_vote, 5, proposal: proposal, skip_injection: evaluator.skip_injection)
+      after :create do |proposal|
+        create_list(:proposal_vote, 5, proposal:)
       end
     end
 
     trait :with_endorsements do
-      after :create do |proposal, evaluator|
+      after :create do |proposal|
         5.times.collect do
-          create(:endorsement, resource: proposal, skip_injection: evaluator.skip_injection,
-                               author: build(:user, organization: proposal.participatory_space.organization, skip_injection: evaluator.skip_injection))
+          create(:endorsement, resource: proposal, author: build(:user, organization: proposal.participatory_space.organization))
         end
       end
     end
 
     trait :with_amendments do
-      after :create do |proposal, evaluator|
-        create_list(:proposal_amendment, 5, amendable: proposal, skip_injection: evaluator.skip_injection)
+      after :create do |proposal|
+        create_list(:proposal_amendment, 5, amendable: proposal)
       end
     end
 
     trait :with_photo do
-      after :create do |proposal, evaluator|
-        proposal.attachments << create(:attachment, :with_image, attached_to: proposal, skip_injection: evaluator.skip_injection)
+      after :create do |proposal|
+        proposal.attachments << create(:attachment, :with_image, attached_to: proposal)
       end
     end
 
     trait :with_document do
-      after :create do |proposal, evaluator|
-        proposal.attachments << create(:attachment, :with_pdf, attached_to: proposal, skip_injection: evaluator.skip_injection)
-      end
-    end
-
-    trait :moderated do
-      after(:create) do |proposal, evaluator|
-        create(:moderation, reportable: proposal, hidden_at: 2.days.ago, skip_injection: evaluator.skip_injection)
+      after :create do |proposal|
+        proposal.attachments << create(:attachment, :with_pdf, attached_to: proposal)
       end
     end
   end
 
   factory :proposal_vote, class: "Decidim::Proposals::ProposalVote" do
-    transient do
-      skip_injection { false }
-    end
-    proposal { build(:proposal, skip_injection: skip_injection) }
-    author { build(:user, organization: proposal.organization, skip_injection: skip_injection) }
+    proposal { build(:proposal) }
+    author { build(:user, organization: proposal.organization) }
   end
 
   factory :proposal_amendment, class: "Decidim::Amendment" do
-    transient do
-      skip_injection { false }
-    end
-    amendable { build(:proposal, skip_injection: skip_injection) }
-    emendation { build(:proposal, component: amendable.component, skip_injection: skip_injection) }
-    amender { build(:user, organization: amendable.component.participatory_space.organization, skip_injection: skip_injection) }
-    state { Decidim::Amendment::STATES.sample }
+    amendable { build(:proposal) }
+    emendation { build(:proposal, component: amendable.component) }
+    amender { build(:user, organization: amendable.component.participatory_space.organization) }
+    state { Decidim::Amendment::STATES.keys.sample }
   end
 
   factory :proposal_note, class: "Decidim::Proposals::ProposalNote" do
-    transient do
-      skip_injection { false }
-    end
-    body do
-      if skip_injection
-        generate(:title)
-      else
-        "<script>alert(\"proposal_note_body\");</script> #{generate(:title)}"
-      end
-    end
-    proposal { build(:proposal, skip_injection: skip_injection) }
-    author { build(:user, organization: proposal.organization, skip_injection: skip_injection) }
+    body { Faker::Lorem.sentences(number: 3).join("\n") }
+    proposal { build(:proposal) }
+    author { build(:user, organization: proposal.organization) }
   end
 
   factory :collaborative_draft, class: "Decidim::Proposals::CollaborativeDraft" do
     transient do
       users { nil }
-      skip_injection { false }
       # user_groups correspondence to users is by sorting order
       user_groups { [] }
     end
 
-    title { generate_localized_title(:collaborative_draft_title, skip_injection: skip_injection)["en"] }
-    body { generate_localized_description(:collaborative_draft_body, skip_injection: skip_injection)["en"] }
-    component { create(:proposal_component, skip_injection: skip_injection) }
+    title { "<script>alert(\"TITLE\");</script> #{generate(:title)}" }
+    body { "<script>alert(\"BODY\");</script>\n#{Faker::Lorem.sentences(number: 3).join("\n")}" }
+    component { create(:proposal_component) }
     address { "#{Faker::Address.street_name}, #{Faker::Address.city}" }
     state { "open" }
 
     after(:build) do |collaborative_draft, evaluator|
       if collaborative_draft.component
-        users = evaluator.users || [create(:user, organization: collaborative_draft.component.participatory_space.organization, skip_injection: evaluator.skip_injection)]
+        users = evaluator.users || [create(:user, organization: collaborative_draft.component.participatory_space.organization)]
         users.each_with_index do |user, idx|
           user_group = evaluator.user_groups[idx]
-          collaborative_draft.coauthorships.build(author: user, user_group: user_group)
+          collaborative_draft.coauthorships.build(author: user, user_group:)
         end
       end
     end
 
+    trait :participant_author do
+      after :build do |draft|
+        draft.coauthorships.clear
+        user = build(:user, organization: draft.component.participatory_space.organization)
+        draft.coauthorships.build(author: user)
+      end
+    end
+
     trait :published do
       state { "published" }
       published_at { Time.current }
@@ -492,20 +500,33 @@ FactoryBot.define do
     transient do
       skip_injection { false }
     end
-    title { generate_localized_title(:participatory_text_title, skip_injection: skip_injection) }
-    description { generate_localized_description(:participatory_text_description, skip_injection: skip_injection) }
-    component { create(:proposal_component, skip_injection: skip_injection) }
+
+    title do
+      if skip_injection
+        Decidim::Faker::Localized.localized { generate(:title) }
+      else
+        Decidim::Faker::Localized.localized { "<script>alert(\"Meetings TITLE\")</script> #{generate(:title)}" }
+      end
+    end
+
+    description do
+      Decidim::Faker::Localized.wrapped("<p>", "</p>") do
+        if skip_injection
+          Decidim::Faker::Localized.localized { Faker::Lorem.sentences(number: 3).join("\n") }
+        else
+          Decidim::Faker::Localized.localized { "<script>alert(\"Meetings description\");</script> #{Faker::Lorem.sentences(number: 3).join("\n")}" }
+        end
+      end
+    end
+    component { create(:proposal_component) }
   end
 
   factory :valuation_assignment, class: "Decidim::Proposals::ValuationAssignment" do
-    transient do
-      skip_injection { false }
-    end
     proposal
     valuator_role do
       space = proposal.component.participatory_space
       organization = space.organization
-      build :participatory_process_user_role, role: :valuator, skip_injection: skip_injection, user: build(:user, organization: organization, skip_injection: skip_injection)
+      build :participatory_process_user_role, role: :valuator, user: build(:user, organization:)
     end
   end
 end

data/lib/decidim/proposals/valuatable.rb

@@ -8,8 +8,7 @@ module Decidim
       include Decidim::Comments::Commentable
 
       included do
-        has_many :valuation_assignments, foreign_key: "decidim_proposal_id", dependent: :destroy,
-                                         counter_cache: :valuation_assignments_count, class_name: "Decidim::Proposals::ValuationAssignment"
+        has_many :valuation_assignments, foreign_key: "decidim_proposal_id", dependent: :destroy
 
         def valuators
           valuator_role_ids = valuation_assignments.where(proposal: self).pluck(:valuator_role_id)

data/lib/decidim/proposals/version.rb

@@ -4,7 +4,7 @@ module Decidim
   # This holds decidim-proposals version.
   module Proposals
     def self.version
-      "0.27.8"
+      "0.28.0.rc4"
     end
   end
 end