decidim-time_tracker 0.3

data/app/commands/decidim/time_tracker/admin/update_task.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TimeTracker
+    module Admin
+      # A command with all the business logic when updating an task
+      class UpdateTask < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # form - A form object with the params.
+        def initialize(task, form, user)
+          @task = task
+          @form = form
+          @user = user
+        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) if form.invalid?
+
+          update_task!
+          broadcast(:ok)
+        end
+
+        private
+
+        attr_reader :form
+
+        def update_task!
+          Decidim.traceability.update!(
+            @task,
+            @user,
+            name: form.name
+          )
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/time_tracker/create_milestone.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TimeTracker
+    # A command with all the business logic when a user creates a new milestone.
+    class CreateMilestone < Rectify::Command
+      include ::Decidim::AttachmentMethods
+      # Public: Initializes the command.
+      #
+      # form - A form object with the params.
+      def initialize(form, current_user)
+        @form = form
+        @current_user = current_user
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid, together with the milestone.
+      # - :invalid if the form wasn't valid and we couldn't proceed.
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid, form.errors) if form.invalid?
+
+        if attachment_present?
+          build_attachment
+          return broadcast(:invalid, form.attachment.errors) if attachment_invalid?
+        end
+
+        transaction do
+          create_milestone!
+          create_attachment if attachment_present?
+        end
+
+        broadcast(:ok, @milestone)
+      end
+
+      private
+
+      attr_reader :form, :current_user, :milestone, :attachment
+
+      def create_milestone!
+        @milestone = Decidim::TimeTracker::Milestone.create!(
+          title: form.title,
+          description: form.description,
+          user: current_user,
+          activity: form.activity
+        )
+        @attached_to = @milestone
+      end
+
+      def attachment_present?
+        @form.attachment && @form.attachment.file.present?
+      end
+    end
+  end
+end

data/app/commands/decidim/time_tracker/create_request_assignation.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TimeTracker
+    # A command with all the business logic when requesting to be an assignation
+    class CreateRequestAssignation < Rectify::Command
+      def initialize(activity, user)
+        @activity = activity
+        @user = user
+      end
+
+      # Creates the assignation if valid.
+      #
+      # Broadcasts :ok if successful, :invalid otherwise.
+      def call
+        begin
+          create_request_assignation
+        rescue StandardError
+          return broadcast(:invalid)
+        end
+
+        broadcast(:ok, activity)
+      end
+
+      private
+
+      attr_reader :activity
+
+      def create_request_assignation
+        Decidim::TimeTracker::Assignation.create!(
+          activity: @activity,
+          user: @user,
+          status: :pending,
+          requested_at: Time.current
+        )
+      end
+    end
+  end
+end

data/app/commands/decidim/time_tracker/start_time_event.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TimeTracker
+    # A command with all the business logic when creating a time event
+    class StartTimeEvent < Rectify::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, form.errors&.first&.second) if form.invalid?
+
+        return broadcast(:already_active, @time_entry) if already_active?
+
+        return broadcast(:invalid, form.errors&.first&.second) if activity_invalid?
+
+        begin
+          stop_previous_activity
+          create_time_event!
+          StopCounterJob.set(wait: form.activity.remaining_seconds_for_today.seconds).perform_later(@time_entry)
+        rescue StandardError => e
+          return broadcast(:invalid, e.message)
+        end
+
+        broadcast(:ok, @time_entry)
+      end
+
+      attr_reader :form
+
+      private
+
+      def activity_invalid?
+        unless activity_started?
+          form.errors.add(:activity, :not_started)
+          return true
+        end
+
+        if activity_finished?
+          form.errors.add(:activity, :finished)
+          return true
+        end
+
+        unless time_available?
+          form.errors.add(:activity, :no_time_available)
+          return true
+        end
+      end
+
+      def create_time_event!
+        @time_entry = Decidim::TimeTracker::TimeEvent.create!(
+          user: form.user,
+          assignation: form.assignation,
+          activity: form.activity,
+          start: start_time.to_i
+        )
+      end
+
+      def start_time
+        form.start.presence || Time.current
+      end
+
+      def stop_previous_activity
+        previous = TimeEvent.where.not(activity: form.activity).last_for(form.user)
+
+        return unless previous
+        return if previous.stopped? && previous.stop.to_i < start_time.to_i
+
+        previous.stop!
+      end
+
+      def already_active?
+        @time_entry = TimeEvent.where(activity: form.activity).last_for(form.user)
+
+        return false unless @time_entry
+        return false if @time_entry.stopped?
+
+        elapsed = (start_time.to_i - @time_entry.start) + form.activity.user_total_seconds_for_date(form.user, start_time)
+        elapsed < form.activity.remaining_seconds_for_today
+      end
+
+      def activity_started?
+        form.activity.start_date.beginning_of_day <= start_time
+      end
+
+      def activity_finished?
+        form.activity.end_date.end_of_day <= start_time
+      end
+
+      def time_available?
+        form.activity.user_total_seconds_for_date(form.user, start_time) < form.activity.remaining_seconds_for_today
+      end
+    end
+  end
+end

data/app/commands/decidim/time_tracker/stop_last_time_event.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TimeTracker
+    # Stops the last event for the user
+    class StopLastTimeEvent < Rectify::Command
+      # Public: Initializes the command.
+      #
+      # form - A form object with the params.
+      def initialize(current_user)
+        @current_user = current_user
+      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(:already_stopped, @last_entry) if last_entry.stopped?
+
+        begin
+          stop_time_event!
+        rescue StandardError => e
+          return broadcast(:invalid, e.message)
+        end
+
+        broadcast(:ok, @last_entry)
+      end
+
+      attr_reader :current_user, :form
+
+      private
+
+      def last_entry
+        @last_entry ||= Decidim::TimeTracker::TimeEvent.last_for(current_user)
+      end
+
+      def stop_time_event!
+        last_entry.stop!
+      end
+    end
+  end
+end

data/app/controllers/concerns/decidim/time_tracker/admin/filterable_assignations.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module TimeTracker
+    module Admin
+      module FilterableAssignations
+        extend ActiveSupport::Concern
+
+        included do
+          include Decidim::Admin::Filterable
+
+          private
+
+          def base_query
+            assignations_collection
+          end
+
+          def search_field_predicate
+            :user_name_or_user_nickname_or_user_email_cont
+          end
+
+          def filters
+            [:activity_id_eq, :activity_task_id_eq]
+          end
+
+          def filters_with_values
+            {
+              activity_id_eq: time_tracker.activities.pluck(:id),
+              activity_task_id_eq: time_tracker.tasks.pluck(:id)
+            }
+          end
+
+          def dynamically_translated_filters
+            [:activity_id_eq, :activity_task_id_eq]
+          end
+
+          def translated_activity_id_eq(id)
+            translated_attribute(Activity.find_by(id: id).description)
+          end
+
+          def translated_activity_task_id_eq(id)
+            translated_attribute(Task.find_by(id: id).name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TimeTracker
+    class ActivityQuestionnaireController < 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_task_activity_form_path(activity_id: activity.id, id: activity.questionnaire)
+      end
+
+      def questionnaire_for
+        time_tracker
+      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?
+
+        activity.allow_answers_for? 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_task_activity_form_path(activity_id: activity.id, id: activity.questionnaire) if params[:action] == "preview"
+
+        answer_task_activity_form_path(activity_id: activity.id, id: activity.questionnaire)
+      end
+
+      def form_path
+        task_activity_form_path(activity_id: activity.id, id: activity.questionnaire)
+      end
+
+      def after_answer_path
+        Decidim::EngineRouter.main_proxy(current_component).root_path
+      end
+
+      # Override so can answer only if is an assignation can view
+      # Also admins can preview it (but not answer)
+      def visitor_can_answer?
+        return false if current_user.blank?
+
+        return true if params[:action] == "preview" && current_user.admin?
+
+        activity.assignation_accepted? current_user
+      end
+
+      # Override to allow respond users once per-activity
+      def visitor_already_answered?
+        return false if current_user.blank?
+
+        return false if params[:action] == "preview" && current_user.admin?
+
+        activity.questionnaire.answered_by?(session_token)
+      end
+
+      private
+
+      # Override to enable response once for each activity
+      def session_token
+        activity.session_token(current_user)
+      end
+
+      def activity
+        @activity ||= Activity.find(params[:activity_id])
+      end
+    end
+  end
+end

data/app/controllers/decidim/time_tracker/admin/activities_controller.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TimeTracker
+    module Admin
+      class ActivitiesController < Admin::ApplicationController
+        include Decidim::TimeTracker::ApplicationHelper
+        helper_method :activities, :current_task, :current_activity, :activities_label
+
+        def new
+          enforce_permission_to :create, :activities
+
+          @form = form(ActivityForm).instance
+        end
+
+        def edit
+          enforce_permission_to :update, :activity, activity: current_activity
+          @form = form(ActivityForm).from_model(current_activity, task: current_task, activity: current_activity)
+        end
+
+        def create
+          enforce_permission_to :create, :activities
+
+          @form = form(ActivityForm).from_params(params)
+
+          CreateActivity.call(@form, current_task) do |_activity|
+            on(:ok) do
+              flash[:notice] = I18n.t("activities.create.success", scope: "decidim.time_tracker.admin")
+              redirect_to EngineRouter.admin_proxy(current_component).edit_task_path(current_task)
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = I18n.t("activities.create.error", scope: "decidim.time_tracker.admin")
+              render :new
+            end
+          end
+        end
+
+        def update
+          enforce_permission_to :update, :activity, activity: current_activity
+          @form = form(ActivityForm).from_params(params, task: current_task, activity: current_activity)
+          UpdateActivity.call(current_activity, @form, current_user) do
+            on(:ok) do
+              flash[:notice] = I18n.t("activities.update.success", scope: "decidim.time_tracker.admin")
+              redirect_to EngineRouter.admin_proxy(current_component).edit_task_path(current_task)
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = I18n.t("activities.update.error", scope: "decidim.time_tracker.admin")
+              render :edit
+            end
+          end
+        end
+
+        def destroy
+          enforce_permission_to :destroy, :activity, activity: current_activity
+
+          DestroyActivity.call(current_activity, current_user) do
+            on(:ok) do
+              flash[:notice] = I18n.t("activities.destroy.success", scope: "decidim.time_tracker.admin")
+              redirect_to EngineRouter.admin_proxy(current_component).edit_task_path(current_task)
+            end
+          end
+        end
+
+        private
+
+        def activities
+          @activities = Decidim::TimeTracker::Activity.where(task: current_task.id)
+        end
+
+        def current_task
+          @current_task ||= Task.find(params[:task_id])
+        end
+
+        def current_activity
+          @current_activity ||= Activity.find_by(id: params[:id])
+        end
+      end
+    end
+  end
+end