decidim-posts 1.0.0

data/app/controllers/decidim/posts/posts_controller.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+# require_dependency "decidim/posts/application_controller"
+
+module Decidim
+  module Posts
+    class PostsController < Decidim::Posts::ApplicationController
+      include Decidim::ApplicationHelper
+      include FormFactory
+      include Flaggable
+      include Decidim::AttachmentsHelper
+      
+      helper_method :post_presenter, :form_presenter
+
+      def index
+        enforce_permission_to :read, :post
+
+        @posts = posts(filter_post_category).where(fixed: [false, nil])
+        @fixed_posts = posts.where(fixed: true).order(created_at: :desc)
+
+        @meetings = meetings(filter_post_category)
+
+        @non_fixed_objects = (@posts + @meetings).sort_by(&:created_at).reverse
+        @non_fixed_objects = Kaminari.paginate_array(@non_fixed_objects).page(params[:page]).per(20)
+      end
+
+      # action to load more posts and meetings on the index page via ajax
+      def load_more
+        enforce_permission_to :read, :post
+
+        @posts = posts(filter_post_category).where(fixed: false)
+        @meetings = meetings(filter_post_category)
+
+        @non_fixed_objects = (@posts + @meetings).sort_by(&:created_at).reverse
+        @non_fixed_objects = Kaminari.paginate_array(@non_fixed_objects).page(params[:page]).per(20)
+
+        render partial: "decidim/posts/posts/feed", locals: { objects: @non_fixed_objects }
+      end
+
+      def show
+        @post = Post.find(params[:id])
+
+        enforce_permission_to :read, :post
+
+        raise ActionController::RoutingError, "Not Found" unless @post
+      end
+
+      def new
+        enforce_permission_to :create, :post
+        @form = form(PostForm).from_params(post_creation_params)
+      end
+
+      def create
+        enforce_permission_to :create, :post
+
+        @form = form(PostForm).from_params(post_creation_params)
+
+        CreatePost.call(@form) do
+          on(:ok) do |post|
+            flash[:notice] = I18n.t("posts.create.success", scope: "decidim.posts")
+            # TODO: implement javascript to create a new post without reloading the page
+            # redirect_to decidim.root_path
+            # redirect_to current_component_path
+            redirect_to posts_path
+          end
+
+          on(:invalid) do
+            flash.now[:alert] = I18n.t("posts.create.invalid", scope: "decidim.posts")
+            redirect_to posts_path
+          end
+        end
+      end
+
+      def edit
+        @post = Post.find(params[:id])
+        enforce_permission_to :edit, :post, post: @post
+        @form = Decidim::Posts::PostForm.from_model(@post).with_context(context)
+      end
+
+      def update
+        @post = Post.find(params[:id])
+        enforce_permission_to :edit, :post, post: @post
+
+        @form = form(PostForm).from_params(params)
+        UpdatePost.call(@form, current_user, @post) do
+          on(:ok) do |post|
+            flash[:notice] = I18n.t("posts.update.success", scope: "decidim.posts")
+            redirect_to posts_path
+            # redirect_to Decidim::ResourceLocatorPresenter.new(@post).path
+          end
+
+          on(:invalid) do
+            flash.now[:alert] = I18n.t("posts.update.invalid", scope: "decidim.posts")
+            render :edit
+          end
+        end
+      end
+
+      def destroy
+        @post = Post.find(params[:id])
+        enforce_permission_to :delete, :post, post: @post
+
+        DestroyPost.call(@post, current_user) do
+          on(:ok) do
+            flash[:notice] = I18n.t("posts.destroy.success", scope: "decidim.posts")
+            redirect_to posts_path
+          end
+
+          on(:invalid) do
+            flash.now[:alert] = I18n.t("posts.destroy.invalid", scope: "decidim.posts")
+            redirect_to posts_path
+          end
+        end
+      end
+
+      def change_status
+        @post = Decidim::Posts::Post.find(params[:id])
+        # enable_comments: params[:status] ? true : false
+        if @post.update(status: params[:status], enable_comments: false)
+          render json: { message: 'Status updated successfully', new_content: cell("decidim/posts/post_host", @post).call(:show) }, status: :ok
+        else
+          render json: { error: 'Failed to update status' }, status: :unprocessable_entity
+        end
+
+      end
+
+      private
+
+      def post_categories
+        ["post", "host", "calendar", "survey", "sharecare"]
+      end
+
+      def allowed_post_categories
+        ["all"] + post_categories
+      end
+
+      def default_filter_post_category
+        return "host" if current_user.admin?
+
+        "all"
+      end
+
+      def filter_post_category
+        allowed_post_categories.include?(params[:filter_post_category]) ? params[:filter_post_category] : default_filter_post_category
+      end
+
+      def posts(filter_category=nil)
+        category = filter_category == "all" ? nil : filter_category
+
+        Decidim::Posts::Post
+                 .where(decidim_component_id: current_component.id)
+                 .filter_category(category)
+                 .order(created_at: :desc)
+                 .includes(:attachments)
+      end
+
+      def meetings(filter_category=nil)
+        category = filter_category == "all" ? nil : filter_category
+
+        if category.blank? || category == 'calendar'
+          meetings_component.blank? ? [] : Decidim::Meetings::Meeting.where(component: meetings_component).published.except_withdrawn
+        else
+          []
+        end
+      end
+
+      def post_presenter
+        @post_presenter ||= present(@post)
+      end
+
+      def form_presenter
+        @form_presenter ||= present(@form, presenter_class: Decidim::Posts::PostPresenter)
+      end
+
+      def post_creation_params
+        params[:post]
+      end
+
+      def participatory_space
+        @participatory_space ||= current_component.participatory_space
+      end
+
+      def meetings_component
+        @meetings_component ||= participatory_space.components.find_by(manifest_name: "meetings")
+      end
+
+      # def meeting_form
+      #   form(Decidim::Meetings::MeetingForm).from_params(params)
+      # end
+
+      def context
+        {
+          current_component: current_component,
+          current_organization: current_component.organization,
+          current_user:,
+          current_participatory_space: participatory_space
+        }
+      end
+
+    end
+  end
+end

data/app/controllers/decidim/posts/reactions_controller.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Posts
+    class ReactionsController < Decidim::Components::BaseController
+      before_action :authenticate_user!
+
+      def create
+        enforce_permission_to(:create, :reaction, resource:)
+
+        reaction_type_id = params[:reaction_type_id]
+        user_group_id = params[:user_group_id]
+
+        AddReactionToResource.call(resource, current_user, user_group_id, reaction_type_id) do
+          on(:ok) do
+            resource.reload
+            render partial: "update_buttons_and_counters", locals: { resource: resource }
+            #render json: { success: true, reaction_type: @reaction.reaction_type }, status: :ok
+          end
+
+          on(:invalid) do
+            render json: { error: I18n.t("resource_reactions.create.error", scope: "decidim") }, status: :unprocessable_entity
+            #render json: { success: false, errors: @reaction.errors.full_messages }, status: :unprocessable_entity
+          end
+        end
+      end
+
+      def destroy
+        enforce_permission_to(:withdraw, :reaction, resource:)
+        
+        user_group_id = params[:user_group_id]
+        user_group = user_groups.find(user_group_id) if user_group_id
+
+        RemoveReactionFromResource.call(resource, current_user, user_group) do
+          on(:ok) do
+            resource.reload
+            render :update_buttons_and_counters
+          end
+        end
+      end
+
+      private
+
+      def resource
+        gid_param = params[:id] || params[:resource_id]
+        @resource ||= GlobalID::Locator.locate(GlobalID.parse(gid_param))
+      end
+
+      def user_groups
+        Decidim::UserGroups::ManageableUserGroups.for(current_user).verified
+      end
+    end
+  end
+end

data/app/controllers/decidim/posts/user_answers_controller.rb

@@ -0,0 +1,36 @@
+# app/controllers/decidim/posts/user_answers_controller.rb
+module Decidim
+  module Posts
+    class UserAnswersController < ApplicationController
+
+      def create
+        answer_id = params[:answer_id].to_i
+        checked = params[:checked].to_s.downcase == "true" ? true : false
+
+        answer = Answer.find(answer_id)
+
+        if checked
+          if answer.question.single_choice?
+            UserAnswer.where(decidim_user_id: current_user.id, decidim_posts_answer_id: answer.question.answers.pluck(:id)).destroy_all
+          end
+          UserAnswer.find_or_create_by(decidim_user_id: current_user.id, decidim_posts_answer_id: answer_id)
+        else
+          UserAnswer.where(decidim_user_id: current_user.id, decidim_posts_answer_id: answer_id).destroy_all
+        end
+
+        # get count of user_answers for all answers of the question
+        user_answers_counts = {}
+        answer.question.answers.each do |a|
+          user_answers_counts[a.id] = UserAnswer.where(decidim_posts_answer_id: a.id).count
+        end
+        result = {
+          user_answers: user_answers_counts,
+          survey_responses_count: answer.question.post.survey_responses_count
+        }
+
+        render json: result, status: :ok
+      end
+
+    end
+  end
+end

data/app/events/decidim/posts/resource_reacted_event.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Posts
+    class ResourceReactedEvent < Decidim::Events::SimpleEvent
+      i18n_attributes :reactor_nickname, :reactor_name, :reactor_path, :nickname, :resource_type
+
+      delegate :nickname, :name, to: :reactor, prefix: true
+
+      def nickname
+        reactor_nickname
+      end
+
+      def reactor_path
+        reactor.profile_path
+      end
+
+      def resource_text
+        return resource.body if resource.respond_to? :body
+        return resource.description if resource.respond_to? :description
+      end
+
+      def resource_type
+        resource.class.model_name.human
+      end
+
+      private
+
+      def reactor
+        @reactor ||= Decidim::UserPresenter.new(reactor_user)
+      end
+
+      def reactor_user
+        @reactor_user ||= Decidim::User.find_by(id: extra[:reactor_id])
+      end
+    end
+  end
+end

data/app/forms/decidim/posts/answer_form.rb

@@ -0,0 +1,13 @@
+module Decidim
+  module Posts
+    class AnswerForm < Decidim::Form
+      include Decidim::TranslatableAttributes
+
+      mimic :answer
+
+      attribute :title, Decidim::Attributes::CleanString
+
+      validates :title, presence: true
+    end
+  end
+end

data/app/forms/decidim/posts/post_form.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Posts
+    class PostForm < Decidim::Form
+      include Decidim::TranslatableAttributes
+      include Decidim::AttachmentAttributes
+      # include Decidim::HasUploadValidations # should be included by AttachmentForm
+
+      mimic :post
+
+      #attribute :body, Decidim::Attributes::CleanString
+      # attribute :body, String
+      attribute :body, Decidim::Attributes::CleanString
+      attribute :category, String
+      attribute :enable_comments, Boolean, default: true
+      #attribute :body_template, String
+      #attribute :user_group_id, Integer
+      #attribute :category_id, Integer
+      #attribute :scope_id, Integer
+      attribute :attachment, AttachmentForm
+      #attribute :suggested_hashtags, Array[String]
+      attribute :questions, Array[QuestionForm]
+      attribute :highlighted, Boolean
+      attribute :fixed, Boolean
+
+      attachments_attribute :documents
+
+      validates :body, presence: true#, etiquette: true
+      # validates :body, length: { in: 15..150 }
+      validates :category, presence: true
+      validate :questions_validator
+
+      # validate :body_is_not_bare_template
+      validate :notify_missing_attachment_if_errored
+
+      alias component current_component
+      # delegate :categories, to: :current_component
+
+      def map_model(model)
+        self.body = translated_attribute(model.body)
+        self.highlighted = model.highlighted
+        self.fixed = model.fixed
+        self.category = model.category
+        self.enable_comments = model.enable_comments
+
+        self.questions = model.questions.map do |question|
+          QuestionForm.from_model(question)
+        end
+
+        # @suggested_hashtags = Decidim::ContentRenderers::HashtagRenderer.new(body).extra_hashtags.map(&:name).map(&:downcase)
+
+        # presenter = PostPresenter.new(model)
+        # self.body = presenter.editor_body(all_locales: body.is_a?(Hash))
+
+        self.documents = model.attachments
+      end
+
+      # Finds the Category from the category_id.
+      #
+      # Returns a Decidim::Category
+      # def category
+      #   @category ||= categories.find_by(id: category_id)
+      # end
+
+      # def extra_hashtags
+      #   @extra_hashtags ||= (component_automatic_hashtags + suggested_hashtags).uniq
+      # end
+
+      # def suggested_hashtags
+      #   downcased_suggested_hashtags = super.to_set(&:downcase)
+      #   component_suggested_hashtags.select { |hashtag| downcased_suggested_hashtags.member?(hashtag.downcase) }
+      # end
+
+      # def suggested_hashtag_checked?(hashtag)
+      #   suggested_hashtags.member?(hashtag)
+      # end
+
+      # def component_automatic_hashtags
+      #   @component_automatic_hashtags ||= ordered_hashtag_list(current_component.current_settings.automatic_hashtags)
+      # end
+
+      # def component_suggested_hashtags
+      #   @component_suggested_hashtags ||= ordered_hashtag_list(current_component.current_settings.suggested_hashtags)
+      # end
+
+      def has_attachments?
+        post.has_attachments? && errors[:documents].empty? && documents.present?
+      end
+
+      def has_error_in_attachments?
+        errors[:documents].present?
+      end
+
+      private
+
+      # def body_is_not_bare_template
+      #   return if body_template.blank?
+
+      #   errors.add(:body, :cant_be_equal_to_template) if body.presence == body_template.presence
+      # end
+
+      # This method will add an error to the "documents" field only if there is any error
+      # in any other field. This is needed because when the form has an error, the attachment
+      # is lost, so we need a way to inform the user of this problem.
+      def notify_missing_attachment_if_errored
+        errors.add(:documents, :needs_to_be_reattached) if errors.any? && documents.present?
+      end
+
+      def questions_validator
+        @questions_validator ||= questions.reject(&:deleted).each do |question|
+          errors.add(:questions, I18n.t("decidim.posts.posts.form.question_too_short")) if question.title.length <= 3
+        end.map(&:title).uniq
+      end
+
+      # def ordered_hashtag_list(string)
+      #   string.to_s.split.compact_blank.uniq.sort_by(&:parameterize)
+      # end
+    end
+  end
+end

data/app/forms/decidim/posts/question_form.rb

@@ -0,0 +1,20 @@
+module Decidim
+  module Posts
+    class QuestionForm < Decidim::Form
+      include Decidim::TranslatableAttributes
+
+      mimic :question
+
+      attribute :title, Decidim::Attributes::CleanString
+      attribute :answers, Array[AnswerForm]
+      attribute :deleted, Boolean, default: false
+      attribute :question_type, String
+
+      validates :title, presence: true
+
+      def map_model(model)
+        self.title = translated_attribute(model.title)
+      end
+    end
+  end
+end

data/app/helpers/decidim/posts/admin/posts_helper.rb

@@ -0,0 +1,8 @@
+module Decidim
+  module Posts
+    module Admin
+      module PostsHelper
+      end
+    end
+  end
+end

data/app/helpers/decidim/posts/application_helper.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Posts
+    # Custom helpers, scoped to the feeds engine.
+    #
+    module ApplicationHelper
+      include PaginateHelper
+      include SanitizeHelper
+      # include Decidim::Posts::PostsHelper
+      include ::Decidim::EndorsableHelper
+      include ::Decidim::FollowableHelper
+      include Decidim::Comments::CommentsHelper
+
+      def posts_component_for_meeting(meeting)
+        meeting.component.participatory_space.components.find_by(manifest_name: "posts")
+      end
+    end
+  end
+end

data/app/helpers/decidim/posts/post_cells_helper.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Posts
+    module PostCellsHelper
+      include Decidim::Posts::ApplicationHelper
+      include Decidim::Posts::Engine.routes.url_helpers
+      include Decidim::LayoutHelper
+      include Decidim::ApplicationHelper
+      include Decidim::TranslationsHelper
+      include Decidim::ResourceReferenceHelper
+      include Decidim::TranslatableAttributes
+      include Decidim::CardHelper
+
+      delegate :body, :category, to: :model
+
+      def current_settings
+        model.component.current_settings
+      end
+
+      def component_settings
+        model.component.settings
+      end
+
+      def current_component
+        model.component
+      end
+
+      def participatory_space
+        @participatory_space ||= current_component.participatory_space
+      end
+
+    end
+  end
+end

data/app/helpers/decidim/posts/posts_helper.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Posts
+    # Custom helpers used in posts views
+    module PostsHelper
+      include Decidim::ApplicationHelper
+      include Decidim::TranslationsHelper
+      include Decidim::ResourceHelper
+      include Decidim::Meetings::ApplicationHelper
+
+      def calendar_months
+        [Date.current, Date.current.next_month]
+      end
+
+      def collection
+        @collection ||= meetings.limit(limit)
+      end
+
+      def meetings
+        @meetings ||= show_upcoming_meetings? ? upcoming_meetings : past_meetings
+      end
+
+      def limit
+        3
+      end
+
+      def participatory_space
+        @participatory_space ||= current_component.participatory_space
+      end
+
+    end
+  end
+end

data/app/helpers/decidim/posts/reaction_helper.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Posts
+    module ReactionHelper
+      def reaction_icon(icon_name)
+        emojis = {
+          "heart": "❤️",
+          "laugh": "😂",
+          "surprise": "😮",
+          "sad": "😢",
+          "angry": "😡",
+          "like": "👍"
+        }
+
+        return "？" unless emojis.key?(icon_name.to_sym)
+
+        emojis[icon_name.to_sym]
+      end
+    end
+  end
+end

data/app/models/decidim/posts/answer.rb

@@ -0,0 +1,13 @@
+module Decidim
+  module Posts
+    class Answer < Feeds::ApplicationRecord
+      include Decidim::TranslatableResource
+      include Decidim::TranslatableAttributes
+
+      belongs_to :question, class_name: "Decidim::Posts::Question", foreign_key: "decidim_posts_question_id"
+      has_many :user_answers, class_name: "Decidim::Posts::UserAnswer", dependent: :destroy, foreign_key: "decidim_posts_answer_id"
+
+      translatable_fields :title
+    end
+  end
+end

data/app/models/decidim/posts/application_record.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Posts
+    # Abstract class from which all models in this engine inherit.
+    class ApplicationRecord < ActiveRecord::Base
+      self.abstract_class = true
+    end
+  end
+end