decidim-admin 0.10.1 → 0.11.0.pre1

data/app/controllers/decidim/admin/areas_controller.rb

@@ -58,11 +58,13 @@ module Decidim
 
       def destroy
         authorize! :destroy, area
-        area.destroy!
 
-        flash[:notice] = I18n.t("areas.destroy.success", scope: "decidim.admin")
-
-        redirect_to areas_path
+        DestroyArea.call(area, current_user) do
+          on(:ok) do
+            flash[:notice] = I18n.t("areas.destroy.success", scope: "decidim.admin")
+            redirect_to areas_path
+          end
+        end
       end
 
       private

data/app/controllers/decidim/admin/{feature_permissions_controller.rb → component_permissions_controller.rb}

@@ -2,26 +2,26 @@
 
 module Decidim
   module Admin
-    # Controller that allows managing feature permissions.
+    # Controller that allows managing component permissions.
     #
-    class FeaturePermissionsController < Decidim::Admin::ApplicationController
-      helper_method :authorizations, :feature
+    class ComponentPermissionsController < Decidim::Admin::ApplicationController
+      helper_method :authorizations, :component
 
       def edit
-        authorize! :update, feature
+        authorize! :update, component
         @permissions_form = PermissionsForm.new(
           permissions: permission_forms
         )
       end
 
       def update
-        authorize! :update, feature
+        authorize! :update, component
         @permissions_form = PermissionsForm.from_params(params)
 
-        UpdateFeaturePermissions.call(@permissions_form, feature) do
+        UpdateComponentPermissions.call(@permissions_form, component) do
           on(:ok) do
-            flash[:notice] = t("feature_permissions.update.success", scope: "decidim.admin")
-            redirect_to features_path(current_participatory_space)
+            flash[:notice] = t("component_permissions.update.success", scope: "decidim.admin")
+            redirect_to components_path(current_participatory_space)
           end
 
           on(:invalid) do
@@ -33,9 +33,9 @@ module Decidim
       private
 
       def permission_forms
-        permissions = feature.permissions || {}
+        permissions = component.permissions || {}
 
-        @permission_forms ||= feature.manifest.actions.inject({}) do |result, action|
+        @permission_forms ||= component.manifest.actions.inject({}) do |result, action|
           form = PermissionForm.new(
             authorization_handler_name: permissions.dig(action, "authorization_handler_name"),
             options: permissions.dig(action, "options").try(:to_json)
@@ -51,8 +51,8 @@ module Decidim
         )
       end
 
-      def feature
-        @feature ||= current_participatory_space.features.find(params[:feature_id])
+      def component
+        @component ||= current_participatory_space.components.find(params[:component_id])
       end
     end
   end

data/app/controllers/decidim/admin/{features → components}/base_controller.rb

@@ -2,8 +2,8 @@
 
 module Decidim
   module Admin
-    module Features
-      # This controller is the abstract class from which all feature
+    module Components
+      # This controller is the abstract class from which all component
       # controllers in their admin engines should inherit from.
       class BaseController < Admin::ApplicationController
         skip_authorize_resource
@@ -16,28 +16,28 @@ module Decidim
         helper Decidim::Admin::ExportsHelper
         helper Decidim::Admin::BulkActionsHelper
 
-        helper_method :current_feature,
+        helper_method :current_component,
                       :current_participatory_space,
                       :parent_path
 
         before_action except: [:index, :show] do
-          authorize! :manage, current_feature
+          authorize! :manage, current_component
         end
 
         before_action on: [:index, :show] do
-          authorize! :read, current_feature
+          authorize! :read, current_component
         end
 
-        def current_feature
-          request.env["decidim.current_feature"]
+        def current_component
+          request.env["decidim.current_component"]
         end
 
         def current_participatory_space
-          current_feature.participatory_space
+          current_component.participatory_space
         end
 
         def parent_path
-          @parent_path ||= EngineRouter.admin_proxy(current_participatory_space).features_path
+          @parent_path ||= EngineRouter.admin_proxy(current_participatory_space).components_path
         end
       end
     end

data/app/controllers/decidim/admin/components_controller.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    # Controller that allows managing the Participatory Process' Components in the
+    # admin panel.
+    #
+    class ComponentsController < Decidim::Admin::ApplicationController
+      helper_method :manifest, :current_participatory_space
+
+      def index
+        authorize! :read, Component
+        @manifests = Decidim.component_manifests
+        @components = current_participatory_space.components
+      end
+
+      def new
+        authorize! :create, Component
+
+        @component = Component.new(
+          name: default_name(manifest),
+          manifest_name: params[:type],
+          participatory_space: current_participatory_space
+        )
+
+        @form = form(ComponentForm).from_model(@component)
+      end
+
+      def create
+        @form = form(ComponentForm).from_params(params)
+        authorize! :create, Component
+
+        CreateComponent.call(manifest, @form, current_participatory_space) do
+          on(:ok) do
+            flash[:notice] = I18n.t("components.create.success", scope: "decidim.admin")
+            redirect_to action: :index
+          end
+
+          on(:invalid) do
+            flash.now[:alert] = I18n.t("components.create.error", scope: "decidim.admin")
+            render action: "new"
+          end
+        end
+      end
+
+      def edit
+        @component = query_scope.find(params[:id])
+        authorize! :update, @component
+
+        @form = form(ComponentForm).from_model(@component)
+      end
+
+      def update
+        @component = query_scope.find(params[:id])
+        @form = form(ComponentForm).from_params(params)
+        authorize! :update, @component
+
+        UpdateComponent.call(@form, @component) do
+          on(:ok) do |settings_changed, previous_settings, current_settings|
+            handle_component_settings_change(previous_settings, current_settings) if settings_changed
+
+            flash[:notice] = I18n.t("components.update.success", scope: "decidim.admin")
+            redirect_to action: :index
+          end
+
+          on(:invalid) do
+            flash.now[:alert] = I18n.t("components.update.error", scope: "decidim.admin")
+            render action: "new"
+          end
+        end
+      end
+
+      def destroy
+        @component = query_scope.find(params[:id])
+        authorize! :destroy, @component
+
+        DestroyComponent.call(@component, current_user) do
+          on(:ok) do
+            flash[:notice] = I18n.t("components.destroy.success", scope: "decidim.admin")
+            redirect_to action: :index
+          end
+
+          on(:invalid) do
+            flash[:alert] = I18n.t("components.destroy.error", scope: "decidim.admin")
+            redirect_to action: :index
+          end
+        end
+      end
+
+      def publish
+        @component = query_scope.find(params[:id])
+        authorize! :update, @component
+
+        PublishComponent.call(@component, current_user) do
+          on(:ok) do
+            flash[:notice] = I18n.t("components.publish.success", scope: "decidim.admin")
+            redirect_to action: :index
+          end
+        end
+      end
+
+      def unpublish
+        @component = query_scope.find(params[:id])
+        authorize! :update, @component
+
+        UnpublishComponent.call(@component, current_user) do
+          on(:ok) do
+            flash[:notice] = I18n.t("components.unpublish.success", scope: "decidim.admin")
+            redirect_to action: :index
+          end
+        end
+      end
+
+      private
+
+      def query_scope
+        current_participatory_space.components
+      end
+
+      def manifest
+        Decidim.find_component_manifest(params[:type])
+      end
+
+      def default_name(manifest)
+        TranslationsHelper.multi_translation(
+          "decidim.components.#{manifest.name}.name",
+          current_organization.available_locales
+        )
+      end
+
+      def handle_component_settings_change(previous_settings, current_settings)
+        return if @component.participatory_space.allows_steps?
+
+        Decidim::SettingsChange.publish(
+          @component,
+          previous_settings["default_step"] || {},
+          current_settings["default_step"] || {}
+        )
+      end
+    end
+  end
+end

data/app/controllers/decidim/admin/concerns/has_private_users.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    module Concerns
+      # PrivateUsers can be related to any ParticipatorySpace, in order to
+      # manage the private users for a given type, you should create a new
+      # controller and include this concern.
+      #
+      # The only requirement is to define a `privatable_to` method that
+      # returns an instance of the model to relate the private_user to.
+      module HasPrivateUsers
+        extend ActiveSupport::Concern
+
+        included do
+          helper_method :privatable_to, :authorization_object, :collection
+
+          def index
+            authorize! :read, authorization_object
+
+            render template: "decidim/admin/participatory_space_private_users/index"
+          end
+
+          def new
+            authorize! :create, authorization_object
+            @form = form(ParticipatorySpacePrivateUserForm).from_params({}, privatable_to: privatable_to)
+            render template: "decidim/admin/participatory_space_private_users/new"
+          end
+
+          def create
+            authorize! :create, authorization_object
+            @form = form(ParticipatorySpacePrivateUserForm).from_params(params, privatable_to: privatable_to)
+
+            CreateParticipatorySpacePrivateUser.call(@form, current_user, current_participatory_space) do
+              on(:ok) do
+                flash[:notice] = I18n.t("participatory_space_private_users.create.success", scope: "decidim.admin")
+                redirect_to action: :index
+              end
+
+              on(:invalid) do
+                flash.now[:alert] = I18n.t("participatory_space_private_users.create.error", scope: "decidim.admin")
+                render template: "decidim/admin/participatory_space_private_users/new"
+              end
+            end
+          end
+
+          def destroy
+            @private_user = collection.find(params[:id])
+            authorize! :destroy, authorization_object
+            @private_user.destroy!
+
+            flash[:notice] = I18n.t("participatory_space_private_users.destroy.success", scope: "decidim.admin")
+
+            redirect_to after_destroy_path
+          end
+
+          def resend_invitation
+            @private_user = collection.find(params[:id])
+            authorize! :invite, authorization_object
+            InviteUserAgain.call(@private_user.user, "invite_private_user") do
+              on(:ok) do
+                flash[:notice] = I18n.t("users.resend_invitation.success", scope: "decidim.admin")
+              end
+
+              on(:invalid) do
+                flash[:alert] = I18n.t("users.resend_invitation.error", scope: "decidim.admin")
+              end
+            end
+
+            redirect_to after_destroy_path
+          end
+
+          # Public: Returns a String or Object that will be passed to `redirect_to` after
+          # destroying a private user. By default it redirects to the privatable_to.
+          #
+          # It can be redefined at controller level if you need to redirect elsewhere.
+          def after_destroy_path
+            privatable_to
+          end
+
+          # Public: The only method to be implemented at the controller. You need to
+          # return the object where the attachment will be attached to.
+          def privatable_to
+            raise NotImplementedError
+          end
+
+          # Public: The Class or Object to be used with the authorization layer to
+          # verify the user can manage the private users
+          #
+          # By default is the same as the privatable_to.
+          def authorization_object
+            privatable_to
+          end
+
+          def collection
+            @collection ||= privatable_to.participatory_space_private_users
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/admin/dashboard_controller.rb

@@ -14,7 +14,7 @@ module Decidim
       def latest_action_logs
         @latest_action_logs ||= Decidim::ActionLog
                                 .where(organization: current_organization)
-                                .includes(:participatory_space, :user, :resource, :feature, :version)
+                                .includes(:participatory_space, :user, :resource, :component, :version)
                                 .order(created_at: :desc)
                                 .first(20)
       end

data/app/controllers/decidim/admin/exports_controller.rb

@@ -4,17 +4,17 @@ module Decidim
   module Admin
     # This controller allows admins to manage proposals in a participatory process.
     class ExportsController < Decidim::Admin::ApplicationController
-      include Decidim::FeaturePathHelper
+      include Decidim::ComponentPathHelper
 
       def create
-        authorize! :manage, feature
+        authorize! :manage, component
         name = params[:id]
 
-        ExportJob.perform_later(current_user, feature, name, params[:format] || default_format)
+        ExportJob.perform_later(current_user, component, name, params[:format] || default_format)
 
         flash[:notice] = t("decidim.admin.exports.notice")
 
-        redirect_back(fallback_location: manage_feature_path(feature))
+        redirect_back(fallback_location: manage_component_path(component))
       end
 
       private
@@ -23,8 +23,8 @@ module Decidim
         "json"
       end
 
-      def feature
-        @feature ||= current_participatory_space.features.find(params[:feature_id])
+      def component
+        @component ||= current_participatory_space.components.find(params[:component_id])
       end
     end
   end

data/app/controllers/decidim/admin/impersonatable_users_controller.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    # Controller that lists users in order to perform impersonation actions on
+    # them
+    #
+    class ImpersonatableUsersController < Decidim::Admin::ApplicationController
+      layout "decidim/admin/users"
+
+      def index
+        authorize! :index, :impersonatable_users
+
+        @query = params[:q]
+        @state = params[:state]
+
+        @users = Decidim::Admin::UserFilter.for(collection, @query, @state)
+                                           .page(params[:page])
+                                           .per(15)
+      end
+
+      private
+
+      def collection
+        @collection ||= current_organization.users.where(admin: false, roles: [])
+      end
+    end
+  end
+end

data/app/controllers/decidim/admin/impersonations_controller.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    # Controller that allows impersonating managed users at the admin panel.
+    #
+    class ImpersonationsController < Decidim::Admin::ApplicationController
+      layout "decidim/admin/users"
+
+      helper_method :available_authorization_handlers,
+                    :other_available_authorizations,
+                    :creating_managed_user?
+
+      skip_authorization_check only: [:close_session]
+
+      def new
+        authorize! :impersonate, user
+
+        @form = form(ImpersonateUserForm).from_params(
+          user: user,
+          handler_name: handler_name,
+          authorization: Decidim::AuthorizationHandler.handler_for(
+            handler_name,
+            user: user
+          )
+        )
+      end
+
+      def create
+        authorize! :impersonate, user
+
+        @form = form(ImpersonateUserForm).from_params(
+          user: user,
+          handler_name: handler_name,
+          reason: params[:impersonate_user][:reason],
+          authorization: Decidim::AuthorizationHandler.handler_for(
+            handler_name,
+            params[:impersonate_user][:authorization].merge(user: user)
+          )
+        )
+
+        ImpersonateUser.call(@form) do
+          on(:ok) do
+            flash[:notice] = I18n.t("impersonations.create.success", scope: "decidim.admin") if creating_managed_user?
+            redirect_to decidim.root_path
+          end
+
+          on(:invalid) do
+            flash.now[:alert] = I18n.t("impersonations.create.error", scope: "decidim.admin")
+            render :new
+          end
+        end
+      end
+
+      def close_session
+        CloseSessionManagedUser.call(user, current_user) do
+          on(:ok) do
+            flash[:notice] = I18n.t("impersonations.close_session.success", scope: "decidim.admin")
+            redirect_to impersonatable_users_path
+          end
+
+          on(:invalid) do
+            flash.now[:alert] = I18n.t("impersonations.close_session.error", scope: "decidim.admin")
+            redirect_to decidim.root_path
+          end
+        end
+      end
+
+      private
+
+      def user
+        @user ||= if creating_managed_user?
+                    new_managed_user
+                  else
+                    current_organization.users.find(params[:impersonatable_user_id])
+                  end
+      end
+
+      def new_managed_user
+        Decidim::User.find_or_initialize_by(
+          organization: current_organization,
+          managed: true,
+          name: params.dig(:impersonate_user, :name)
+        ) do |u|
+          u.admin = false
+          u.tos_agreement = true
+        end
+      end
+
+      def creating_managed_user?
+        params[:impersonatable_user_id] == "new_managed_user"
+      end
+
+      def handler_name
+        authorization = params.dig(:impersonate_user, :authorization)
+        return available_authorization_handlers.first.name unless authorization
+
+        authorization[:handler_name]
+      end
+
+      def other_available_authorizations
+        return [] if available_authorization_handlers.size == 1
+
+        other_available_authorization_handlers.map do |authorization_handler|
+          Decidim::AuthorizationHandler.handler_for(authorization_handler.name)
+        end
+      end
+
+      def other_available_authorization_handlers
+        Decidim::Verifications::Adapter.from_collection(
+          current_organization.available_authorization_handlers - [handler_name]
+        )
+      end
+
+      def available_authorization_handlers
+        Decidim::Verifications::Adapter.from_collection(
+          current_organization.available_authorization_handlers
+        )
+      end
+    end
+  end
+end

data/app/controllers/decidim/admin/logs_controller.rb

@@ -15,7 +15,7 @@ module Decidim
         @logs ||= Decidim::ActionLog
                   .where(organization: current_organization)
                   .order(created_at: :desc)
-                  .includes(:participatory_space, :user, :resource, :feature, :version)
+                  .includes(:participatory_space, :user, :resource, :component, :version)
                   .page(params[:page])
                   .per(20)
       end

data/app/controllers/decidim/admin/managed_users/impersonation_logs_controller.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    module ManagedUsers
+      # Controller that allows inspecting impersonation logs
+      #
+      class ImpersonationLogsController < Decidim::Admin::ApplicationController
+        layout "decidim/admin/users"
+
+        skip_authorization_check
+
+        def index
+          @impersonation_logs = Decidim::ImpersonationLog.where(user: user).order(started_at: :desc).page(params[:page]).per(15)
+        end
+
+        private
+
+        def user
+          @user ||= current_organization.users.find(params[:impersonatable_user_id])
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/admin/managed_users/promotions_controller.rb

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 
-require_dependency "decidim/admin/application_controller"
-
 module Decidim
   module Admin
     module ManagedUsers
       # Controller that allows promoting managed users at the admin panel.
       #
-      class PromotionsController < Admin::ApplicationController
+      class PromotionsController < Decidim::Admin::ApplicationController
         layout "decidim/admin/users"
 
         def new
@@ -22,7 +20,7 @@ module Decidim
           PromoteManagedUser.call(@form, user, current_user) do
             on(:ok) do
               flash[:notice] = I18n.t("managed_users.promotion.success", scope: "decidim.admin")
-              redirect_to managed_users_path
+              redirect_to impersonatable_users_path
             end
 
             on(:invalid) do
@@ -35,7 +33,7 @@ module Decidim
         private
 
         def user
-          @user ||= current_organization.users.managed.find(params[:managed_user_id])
+          @user ||= current_organization.users.managed.find(params[:impersonatable_user_id])
         end
       end
     end

data/app/controllers/decidim/admin/newsletters_controller.rb

@@ -62,7 +62,7 @@ module Decidim
 
         UpdateNewsletter.call(@newsletter, @form, current_user) do
           on(:ok) do |newsletter|
-            flash.now[:notice] = I18n.t("newsletters.update.success", scope: "decidim.admin")
+            flash[:notice] = I18n.t("newsletters.update.success", scope: "decidim.admin")
             redirect_to action: :show, id: newsletter.id
           end