decidim-lausanne-budgets 0.1.0

data/app/commands/decidim/lausanne/budgets/admin/import_proposals_to_budgets.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Lausanne
+    module Budgets
+      module Admin
+        # A command with all the business logic when an admin imports proposals from
+        # one component to projects of a budget.
+        class ImportProposalsToBudgets < Decidim::Lausanne::Budgets::Command
+          # Public: Initializes the command.
+          #
+          # form - A form object with the params.
+          def initialize(form)
+            @form = form
+          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) unless @form.valid?
+
+            broadcast(:ok, create_projects_from_accepted_proposals)
+          end
+
+          private
+
+            attr_reader :form
+
+            def create_projects_from_accepted_proposals
+              transaction do
+                proposals.map do |original_proposal|
+                  next if proposal_already_copied?(original_proposal)
+
+                  new_project = create_project_from_proposal!(original_proposal)
+
+                  new_project.link_resources([original_proposal], "included_proposals")
+                end.compact
+              end
+            end
+
+            def create_project_from_proposal!(original_proposal)
+              params = {
+                budget: form.budget,
+                title: original_proposal.title,
+                description: original_proposal.body,
+                budget_amount: form.default_budget,
+                category: original_proposal.category,
+                scope: original_proposal.scope
+              }
+
+              @project = Decidim.traceability.create!(
+                Project,
+                form.current_user,
+                params,
+                visibility: "all"
+              )
+            end
+
+            def proposals
+              return all_proposals if form.scope_id.blank?
+
+              all_proposals.where(decidim_scope_id: form.scope_id)
+            end
+
+            def all_proposals
+              Decidim::Proposals::Proposal.where(component: origin_component)
+                                          .where(state: :accepted)
+            end
+
+            def origin_component
+              form.origin_component
+            end
+
+            def proposal_already_copied?(original_proposal)
+              original_proposal.linked_resources(:projects, "included_proposals").any? do |project|
+                project.budget == form.budget
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/lausanne/budgets/admin/update_budget.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Lausanne
+    module Budgets
+      module Admin
+        # This command is executed when the user updates a Budget
+        # from the admin panel.
+        class UpdateBudget < Decidim::Lausanne::Budgets::Command
+          def initialize(form, budget)
+            @form = form
+            @budget = budget
+          end
+
+          # Updates the budget if valid.
+          #
+          # Broadcasts :ok if successful, :invalid otherwise.
+          def call
+            return broadcast(:invalid) if form.invalid?
+
+            update_budget!
+
+            broadcast(:ok, budget)
+          end
+
+          private
+
+            attr_reader :form, :budget
+
+            def update_budget!
+              attributes = {
+                scope: form.scope,
+                title: form.title,
+                weight: form.weight,
+                description: form.description,
+                total_budget: form.total_budget
+              }
+
+              Decidim.traceability.update!(
+                budget,
+                form.current_user,
+                attributes,
+                visibility: "all"
+              )
+            end
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/lausanne/budgets/admin/update_project.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Lausanne
+    module Budgets
+      module Admin
+        # This command is executed when the user changes a Project from the admin
+        # panel.
+        class UpdateProject < Decidim::Lausanne::Budgets::Command
+          include ::Decidim::AttachmentMethods
+          include ::Decidim::GalleryMethods
+
+          # Initializes an UpdateProject Command.
+          #
+          # form - The form from which to get the data.
+          # project - The current instance of the project to be updated.
+          def initialize(form, project)
+            @form = form
+            @project = project
+            @attached_to = project
+          end
+
+          # Updates the project if valid.
+          #
+          # Broadcasts :ok if successful, :invalid otherwise.
+          def call
+            return broadcast(:invalid) if form.invalid?
+
+            if process_gallery?
+              build_gallery
+              return broadcast(:invalid) if gallery_invalid?
+            end
+
+            transaction do
+              update_project
+              link_proposals
+              create_gallery if process_gallery?
+              photo_cleanup!
+            end
+
+            broadcast(:ok)
+          end
+
+          private
+
+            attr_reader :project, :form, :gallery
+
+            def update_project
+              Decidim.traceability.update!(
+                project,
+                form.current_user,
+                scope: form.scope,
+                category: form.category,
+                title: form.title,
+                description: form.description,
+                excerpt: form.excerpt,
+                budget_amount: form.budget_amount,
+                selected_at: selected_at
+              )
+            end
+
+            def proposals
+              @proposals ||= project.sibling_scope(:proposals).where(id: form.proposal_ids)
+            end
+
+            def link_proposals
+              project.link_resources(proposals, "included_proposals")
+            end
+
+            def selected_at
+              return unless form.selected
+
+              Time.current
+            end
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/lausanne/budgets/cancel_order.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Lausanne
+    module Budgets
+      # A command with all the business to cancel an order.
+      class CancelOrder < Decidim::Lausanne::Budgets::Command
+        # Public: Initializes the command.
+        #
+        # order - The current order for the user.
+        def initialize(order)
+          @order = order
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid.
+        #
+        # Returns nothing.
+        def call
+          transaction do
+            cancel_order!
+          end
+          broadcast(:ok, @order)
+        end
+
+        private
+          def user_record
+            @order.user_record
+          end
+          # If the order is not linked to a user, 
+          # remove the user_record and the order.
+          # If the order is linked to a user, remove all the votes
+          def cancel_order!
+            @order.line_items.each do |line|
+              line.destroy!
+            end
+            unless user_record.user
+              @order.user_record.destroy!
+            end
+            @order.update(checked_out_at: nil)
+          end
+      end
+    end
+  end
+end

data/app/commands/decidim/lausanne/budgets/checkout.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Lausanne
+    module Budgets
+      # A command with all the business to checkout.
+      class Checkout < Decidim::Lausanne::Budgets::Command
+        # Public: Initializes the command.
+        #
+        # order - The current order for the user.
+        def initialize(order)
+          @order = order
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid.
+        # - :invalid if the there is an error.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid, order) unless checkout!
+
+          broadcast(:ok, order)
+        end
+
+        private
+
+          attr_reader :order
+
+          def checkout!
+            return unless order && order.valid?
+
+            @order.with_lock do
+              SendOrderSummaryJob.perform_later(@order)
+              @order.checked_out_at = Time.current
+              @order.save
+            end
+          end
+      end
+    end
+  end
+end

data/app/commands/decidim/lausanne/budgets/command.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Lausanne
+    module Budgets
+      # maintains compatibility with v0.26 which uses Rectify
+      if defined? ::Decidim::Command
+        class Command < ::Decidim::Command
+        end
+      else
+        class Command < ::Rectify::Command
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/lausanne/budgets/create_user_record.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Lausanne
+    module Budgets
+      class CreateUserRecord < Decidim::Lausanne::Budgets::Command
+        attr_reader :user_record, :budget, :current_user
+        def initialize(user_record, budget, current_user)
+          @user_record = user_record
+          @budget = budget
+          @current_user = current_user
+        end
+
+        def call
+          return broadcast(:invalid) unless budget
+          return broadcast(:invalid) if user_record.invalid?
+          new_user_record = nil
+          transaction do
+            new_user_record = UserRecord.create(
+              first_name: user_record.first_name,
+              last_name: user_record.last_name,
+              birthdate: user_record.birthdate,
+              iam_lausanne: user_record.iam_lausanne,
+              its_me: user_record.its_me,
+              allow_process_data: user_record.allow_process_data,
+              user: current_user || nil,
+              order: Order.create(
+                budget: budget
+              )
+            )
+          rescue e
+            broadcast(:invalid)
+          end
+          broadcast(:ok, new_user_record)
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/lausanne/budgets/remove_line_item.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Lausanne
+    module Budgets
+      # A command with all the business to add remove line items from orders
+      class RemoveLineItem < Decidim::Lausanne::Budgets::Command
+        # Public: Initializes the command.
+        #
+        # order - The current order for the user
+        # project - The the project to remove from the order
+        def initialize(order, project)
+          @order = order
+          @project = project
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid.
+        # - :invalid if the there is an error.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) if @order.checked_out?
+
+          remove_line_item
+          broadcast(:ok, @order)
+        end
+
+        private
+
+          attr_reader :project
+
+          def remove_line_item
+            @order.projects.destroy(project)
+          end
+      end
+    end
+  end
+end

data/app/commands/decidim/lausanne/budgets/update_user_record.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Lausanne
+    module Budgets
+      class UpdateUserRecord < Decidim::Lausanne::Budgets::Command
+        attr_reader :user_record, :budget, :current_user
+        def initialize(user_record, budget, current_user)
+          @user_record = user_record
+          @budget = budget
+          @current_user = current_user
+        end
+
+        def call
+          return broadcast(:invalid) unless budget
+          return broadcast(:invalid) if user_record.invalid?
+
+          new_user_record = nil
+          transaction do
+            new_user_record = UserRecord.create(
+              first_name: user_record.first_name,
+              last_name: user_record.last_name,
+              birthdate: user_record.birthdate,
+              iam_lausanne: user_record.iam_lausanne,
+              its_me: user_record.its_me,
+              allow_process_data: user_record.allow_process_data,
+              user: current_user || nil,
+              order: Order.create(
+                budget: budget
+              )
+            )
+          rescue e
+            broadcast(:invalid)
+          end
+          broadcast(:ok, new_user_record)
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/decidim/lausanne/budgets/needs_current_order.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module Lausanne
+    module Budgets
+      # Shared behaviour for controllers that need the current order to be present.
+      module NeedsCurrentOrder
+        extend ActiveSupport::Concern
+
+        included do
+          helper_method :current_order, :can_have_order?, :voted_for?, :user_record_for_budget?,
+          :user_record_submitted?
+
+          def user_record_for_budget?
+            return true if current_user_record.new_record?
+            current_user_record.order.id == current_order.id
+          end
+          def user_record_submitted?
+            !current_user_record.new_record?
+          end
+
+          def current_order
+            @current_order ||= Order.includes(:projects).find_or_initialize_by(
+              user_record: current_user_record,
+              budget: budget
+            )
+          end
+
+          def current_order=(order)
+            @current_order = order
+          end
+
+          def persisted_current_order
+            current_order if current_order&.persisted?
+          end
+
+          def can_have_order?
+            voting_open? &&
+            allowed_to?(:create, :order, budget: budget, workflow: current_workflow)
+          end
+
+          # Return true if the user has voted the project
+          def voted_for?(project)
+            current_order && current_order.projects.include?(project)
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/decidim/lausanne/budgets/orderable.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module Lausanne
+    module Budgets
+      # Common logic to sorting resources
+      module Orderable
+        extend ActiveSupport::Concern
+
+        included do
+          include Decidim::Orderable
+
+          private
+
+            # Available orders based on enabled settings
+            def available_orders
+              @available_orders ||= begin
+                available_orders = []
+                available_orders << "asc" 
+                available_orders << "most_voted" if votes_are_visible?
+                available_orders += %w(highest_cost lowest_cost)
+                available_orders
+              end
+            end
+
+            def default_order
+              available_orders.first
+            end
+
+            def votes_are_visible?
+              current_settings.show_votes?
+            end
+
+            def reorder(projects)
+              case order
+              when "highest_cost"
+                projects.order(budget_amount: :desc)
+              when "lowest_cost"
+                projects.order(budget_amount: :asc)
+              when "asc"
+                projects.order(Arel.sql("title->>'#{I18n.locale}' ASC"))
+              when "random"
+                projects.order_randomly(random_seed)
+              else
+                projects
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/lausanne/budgets/admin/application_controller.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Lausanne
+    module Budgets
+      module Admin
+        # This controller is the abstract class from which all other controllers of
+        # this engine inherit.
+        #
+        # Note that it inherits from `Decidim::Components::BaseController`, which
+        # override its layout and provide all kinds of useful methods.
+        class ApplicationController < Decidim::Admin::Components::BaseController
+          helper_method :budget, :projects, :project
+
+          def budget
+            @budget ||= LausanneBudget.where(component: current_component).includes(:projects).find_by(id: params[:lausanne_budget_id])
+          end
+
+          def projects
+            return unless budget
+
+            @projects ||= budget.projects
+          end
+
+          def project
+            return unless projects
+
+            @project ||= projects.find(params[:id])
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/lausanne/budgets/admin/attachment_collections_controller.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Lausanne
+    module Budgets
+      module Admin
+        # Controller that allows managing all the attachment collections for a budget.
+        #
+        class AttachmentCollectionsController < Admin::ApplicationController
+          include Decidim::Admin::Concerns::HasAttachmentCollections
+
+          def after_destroy_path
+            project_attachment_collections_path(project, project.component, current_participatory_space)
+          end
+
+          def collection_for
+            project
+          end
+
+          def project
+            @project ||= Decidim::Lausanne::Budgets::Project.find(params[:project_id])
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/lausanne/budgets/admin/attachments_controller.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Lausanne
+    module Budgets
+      module Admin
+        # Controller that allows managing all the attachments for a participatory
+        # process.
+        #
+        class AttachmentsController < Admin::ApplicationController
+          include Decidim::Admin::Concerns::HasAttachments
+
+          def after_destroy_path
+            lausanne_budget_projects_path(project.budget)
+          end
+
+          def attached_to
+            project
+          end
+
+          def project
+            @project ||= Decidim::Lausanne::Budgets::Project.find(params[:project_id])
+          end
+        end
+      end
+    end
+  end
+end