decidim-time_tracker 0.3

data/app/controllers/decidim/time_tracker/assignee_questionnaire_controller.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TimeTracker
+    class AssigneeQuestionnaireController < Decidim::TimeTracker::ApplicationController
+      include Decidim::Forms::Concerns::HasQuestionnaire
+
+      # only allows answers if not in preview mode
+      def preview
+        return show if request.method == "GET"
+
+        flash[":alert"] = I18n.t("questionnaire_in_preview_mode", scope: "decidim.time_tracker.time_tracker")
+        redirect_to preview_assignee_questionnaire_path
+      end
+
+      # overwrite this method to automatically accept TOS
+      def answer
+        enforce_permission_to :answer, :questionnaire
+
+        @form = form(Decidim::Forms::QuestionnaireForm).from_params(params, session_token: session_token, ip_hash: ip_hash)
+
+        Decidim::Forms::AnswerQuestionnaire.call(@form, current_user, questionnaire) do
+          on(:ok) do
+            # i18n-tasks-use t("decidim.forms.questionnaires.answer.success")
+            TosAcceptance.create!(assignee: Assignee.for(current_user), time_tracker: time_tracker)
+            flash[:notice] = I18n.t("answer.success", scope: i18n_flashes_scope)
+            redirect_to after_answer_path
+          end
+
+          on(:invalid) do
+            # i18n-tasks-use t("decidim.forms.questionnaires.answer.invalid")
+            flash.now[:alert] = I18n.t("answer.invalid", scope: i18n_flashes_scope)
+            render template: "decidim/forms/questionnaires/show"
+          end
+        end
+      end
+
+      def questionnaire_for
+        time_tracker.assignee_data
+      end
+
+      # only allows answers if not in preview mode
+      def allow_answers?
+        return false if current_user.blank?
+
+        return true if params[:action] == "preview" && current_user.admin?
+
+        current_component.published?
+      end
+
+      # Override so can answer only if is an assignation can view
+      # Also admins can preview it (but not answer)
+      def visitor_can_answer?
+        current_user.present?
+      end
+
+      def visitor_already_answered?
+        return false if params[:action] == "preview" && current_user.admin?
+
+        questionnaire.answered_by?(current_user)
+      end
+
+      # Returns the path to answer this questionnaire for normal users
+      # If the questionnaire is rendered in a preview route, then just do nothing with the responses
+      def update_url
+        return preview_assignee_questionnaire_path if params[:action] == "preview"
+
+        answer_assignee_questionnaire_path
+      end
+
+      def form_path
+        assignee_questionnaire_path
+      end
+
+      def after_answer_path
+        Decidim::EngineRouter.main_proxy(current_component).root_path
+      end
+    end
+  end
+end

data/app/controllers/decidim/time_tracker/milestones_controller.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TimeTracker
+    class MilestonesController < Decidim::TimeTracker::ApplicationController
+      include Decidim::FormFactory
+      include Decidim::TimeTracker::ApplicationHelper
+
+      helper_method :user, :activities
+
+      def index
+        return redirect_to root_path if user.blank?
+
+        enforce_permission_to :index, :milestones, user: user
+      end
+
+      # creates a milestone
+      def create
+        enforce_permission_to :create, :milestone, activity: activity
+
+        @form = form(MilestoneForm).from_params(milestone_params)
+
+        CreateMilestone.call(@form, current_user) do
+          on(:ok) do |_milestone|
+            flash[:notice] = I18n.t("milestones.create.success", scope: "decidim.time_tracker")
+            redirect_to milestones_path(nickname: current_user.nickname)
+          end
+          on(:invalid) do |_message|
+            flash[:alert] = I18n.t("milestones.create.error", scope: "decidim.time_tracker")
+            redirect_to root_path
+          end
+        end
+      end
+
+      private
+
+      # copies the title to the attachment
+      def milestone_params
+        unsafe = params.to_unsafe_h
+        unsafe["milestone"]["attachment"]["title"] = { I18n.locale => params[:milestone][:title] } if unsafe["milestone"]["attachment"].present?
+        unsafe
+      end
+
+      def root_path
+        Decidim::EngineRouter.main_proxy(current_component).root_path
+      end
+
+      def activity
+        @activity ||= Activity.active.find_by(id: params[:milestone][:activity_id])
+      end
+
+      def activities
+        @activities ||= Activity.select("DISTINCT ON (id) *")
+                                .where(id: Milestone.where(user: user).pluck(:activity_id))
+      end
+
+      def user
+        @user ||= Decidim::User.find_by(nickname: params[:nickname])
+      end
+    end
+  end
+end

data/app/controllers/decidim/time_tracker/reports/user_controller.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TimeTracker
+    module Reports
+      # The controller to handle the user's time_tracker report page.
+      class UserController < Decidim::ApplicationController
+        include Decidim::ComponentPathHelper
+        include Decidim::UserProfile
+
+        helper Decidim::TimeTracker::ApplicationHelper
+        helper_method :activities, :assignations, :total_time, :activity_path
+
+        def index
+          enforce_permission_to :read, :user, current_user: current_user
+        end
+
+        private
+
+        def activities
+          Decidim::TimeTracker::Activity.joins(:assignations).where("decidim_time_tracker_assignations.decidim_user_id": current_user.id).group_by(&:id)
+        end
+
+        def assignations
+          Assignation.where(user: current_user).sorted_by_status(:accepted, :pending, :rejected)
+        end
+
+        def activity_path(assignation)
+          EngineRouter.main_proxy(assignation.task.time_tracker.component).root_path(locale: params[:locale], activity: assignation.activity)
+        end
+
+        def total_time
+          assignations.map(&:time_dedicated).sum
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/time_tracker/time_events_controller.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TimeTracker
+    class TimeEventsController < Decidim::TimeTracker::ApplicationController
+      include Decidim::FormFactory
+
+      helper_method :activity, :task, :assignation
+
+      def start
+        enforce_permission_to :start, :time_events
+
+        form = form(TimeEventForm).from_params(activity: activity, assignation: assignation)
+        StartTimeEvent.call(form) do
+          on(:ok) do |time_event|
+            render json: { message: I18n.t("time_events.start.success", scope: "decidim.time_tracker"),
+                           id: time_event.id,
+                           start: time_event.start,
+                           startTime: time_event.start_time.iso8601,
+                           elapsedSeconds: activity.user_total_seconds(current_user) }
+          end
+          on(:already_active) do |time_event|
+            render json: { message: I18n.t("time_events.start.already_started", scope: "decidim.time_tracker"),
+                           error: I18n.t("time_events.start.already_started", scope: "decidim.time_tracker"),
+                           id: time_event.id }
+          end
+          on(:invalid) do |message|
+            render json: { message: I18n.t("time_events.start.error", scope: "decidim.time_tracker"),
+                           error: message }, status: :unprocessable_entity
+          end
+        end
+      end
+
+      def stop
+        enforce_permission_to :stop, :time_events
+
+        StopLastTimeEvent.call(current_user) do
+          on(:ok) do |time_event|
+            render json: { message: I18n.t("time_events.stop.success", scope: "decidim.time_tracker"),
+                           timeEvent: time_event.to_json }
+          end
+          on(:already_stopped) do |_time_event|
+            render json: { message: I18n.t("time_events.stop.error", scope: "decidim.time_tracker"),
+                           error: I18n.t("time_events.stop.already_stopped", scope: "decidim.time_tracker") }
+          end
+          on(:invalid) do |message|
+            render json: { message: I18n.t("time_events.stop.error", scope: "decidim.time_tracker"),
+                           error: message }, status: :unprocessable_entity
+          end
+        end
+      end
+
+      private
+
+      def task
+        Task.find(params[:task_id])
+      end
+
+      def activity
+        Activity.find(params[:activity_id])
+      end
+
+      def assignation
+        Assignation.find_by(user: current_user, activity: activity)
+      end
+    end
+  end
+end

data/app/controllers/decidim/time_tracker/time_tracker_controller.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TimeTracker
+    class TimeTrackerController < Decidim::TimeTracker::ApplicationController
+      include Decidim::FormFactory
+
+      helper_method :tasks, :assignation_milestones, :start_endpoint, :stop_endpoint, :requests_path, :questionnaire_path
+
+      def index
+        @form = form(MilestoneForm).from_params(
+          attachment: form(AttachmentForm).instance
+        )
+      end
+
+      private
+
+      def tasks
+        time_tracker.tasks
+      end
+
+      def assignation_milestones(activity)
+        Milestone.where(activity: activity).order(created_at: :desc).select("DISTINCT ON (decidim_user_id, created_at) *")
+      end
+
+      def start_endpoint(activity)
+        Decidim::EngineRouter.main_proxy(current_component).task_activity_start_path(activity.task, activity.id)
+      end
+
+      def stop_endpoint(activity)
+        Decidim::EngineRouter.main_proxy(current_component).task_activity_stop_path(activity.task, activity.id)
+      end
+
+      def requests_path(activity)
+        Decidim::EngineRouter.main_proxy(current_component).assignations_path(activity_id: activity.id)
+      end
+
+      def questionnaire_path(activity)
+        Decidim::EngineRouter.main_proxy(current_component).new_assignation_path(task_id: activity.task, activity_id: activity.id, id: activity.questionnaire.id)
+      end
+    end
+  end
+end

data/app/forms/decidim/time_tracker/admin/activity_form.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TimeTracker
+    module Admin
+      # This class holds a Form to create/update activity from Decidim's admin panel
+      class ActivityForm < Decidim::Form
+        include TranslatableAttributes
+
+        translatable_attribute :description, String
+
+        attribute :active, Boolean
+        attribute :start_date, Decidim::Attributes::TimeWithZone
+        attribute :end_date, Decidim::Attributes::TimeWithZone
+        attribute :max_minutes_per_day, Integer
+        attribute :requests_start_at, Decidim::Attributes::TimeWithZone
+
+        validates :start_date, presence: true
+        validates :end_date, presence: true, date: { after: :start_date }
+        validates :requests_start_at, presence: true, date: { before: :start_date }
+
+        validates :max_minutes_per_day, presence: true
+        validates :description, translatable_presence: true
+      end
+    end
+  end
+end

data/app/forms/decidim/time_tracker/admin/assignation_form.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TimeTracker
+    module Admin
+      class AssignationForm < Decidim::Form
+        mimic :assignation
+
+        attribute :user_id, Integer
+        attribute :existing_user, Boolean, default: false
+        attribute :name, String
+        attribute :email, String
+
+        validates :name, presence: true, unless: proc { |object| object.existing_user }
+        validates :email, presence: true, unless: proc { |object| object.existing_user }
+        validates :user, presence: true, if: proc { |object| object.existing_user }
+
+        def map_model(model)
+          self.user_id = model.decidim_user_id
+          self.existing_user = user_id.present?
+        end
+
+        def user
+          @user ||= current_organization.users.find_by(id: user_id)
+        end
+      end
+    end
+  end
+end

data/app/forms/decidim/time_tracker/admin/task_form.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TimeTracker
+    module Admin
+      # This class holds a Form to create/update task from Decidim's admin panel.
+      class TaskForm < Decidim::Form
+        include TranslatableAttributes
+
+        mimic :task
+
+        translatable_attribute :name, String
+
+        validates :name, translatable_presence: true
+
+        def time_tracker
+          @time_tracker ||= Decidim::TimeTracker::TimeTracker.find_by(component: current_component)
+        end
+      end
+    end
+  end
+end

data/app/forms/decidim/time_tracker/milestone_form.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TimeTracker
+    class MilestoneForm < Decidim::Form
+      mimic :milestone
+
+      attribute :activity_id, Integer
+      attribute :title, String
+      attribute :description, String
+      attribute :attachment, AttachmentForm
+
+      validates :activity_id, :title, presence: true
+      validates :activity, presence: true, if: ->(form) { form.activity_id.present? }
+      validate :notify_missing_attachment_if_errored
+
+      def activity
+        @activity ||= Activity.find_by(id: activity_id)
+      end
+
+      private
+
+      # This method will add an error to the `attachment` field only if there's
+      # 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(:attachment, :needs_to_be_reattached) if errors.any? && attachment.present?
+      end
+    end
+  end
+end

data/app/forms/decidim/time_tracker/time_event_form.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TimeTracker
+    class TimeEventForm < Decidim::Form
+      mimic :time_event
+
+      attribute :activity, Decidim::TimeTracker::Activity
+      attribute :assignation, Decidim::TimeTracker::Assignation
+      attribute :user_id, Integer
+      attribute :start, Integer
+      attribute :stop, Integer
+
+      validates :activity, presence: true
+      validates :assignation, presence: true
+
+      validate :assigned_to_activity?
+      validate :activity_is_active
+      validate :dates_are_valid
+      validates :stop, date: { after: ->(form) { form.start } }, if: ->(form) { form.stop.present? && form.start.present? }
+
+      def user
+        return Decidim::User.find(user_id) if user_id.present?
+
+        assignation.user
+      end
+
+      private
+
+      def assigned_to_activity?
+        errors.add(:assignation, :unassigned) unless activity.assignations.accepted.find_by(id: assignation&.id)
+      end
+
+      def activity_is_active
+        errors.add(:activity, :inactive) unless activity.active?
+      end
+
+      def dates_are_valid
+        [:start, :stop].each do |key|
+          next unless attributes[key]
+
+          errors.add(key, :date_format) unless attributes[key].is_a?(Time)
+        end
+      end
+    end
+  end
+end