decidim-time_tracker 0.3

data/app/helpers/decidim/time_tracker/admin/application_helper.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TimeTracker
+    module Admin
+      # Custom helpers, scoped to the time_tracker engine.
+      #
+      module ApplicationHelper
+        def change_assignation_status_button(assignation, success_path: nil)
+          path_reject = task_activity_assignation_path(assignation.task, assignation.activity, assignation, assignation_status: :rejected, success_path: success_path)
+          path_accept = task_activity_assignation_path(assignation.task, assignation.activity, assignation, assignation_status: :accepted, success_path: success_path)
+          label_reject = t("assignations.actions.reject", scope: "decidim.time_tracker.admin")
+          label_accept = t("assignations.actions.accept", scope: "decidim.time_tracker.admin")
+
+          icons = [
+            assignation.pending? || assignation.accepted? ? icon_link_to("x", path_reject, label_reject, method: :patch, class: "action-icon--status") : empty_icon,
+            assignation.pending? || assignation.rejected? ? icon_link_to("check", path_accept, label_accept, method: :patch, class: "action-icon--status") : empty_icon
+          ]
+
+          safe_join(icons)
+        end
+
+        def empty_icon
+          content_tag :a, class: "action-icon" do
+            content_tag :span do
+              icon("", aria_label: "", role: "img")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TimeTracker
+    # Custom helpers, scoped to the time_tracker engine.
+    #
+    module ApplicationHelper
+      include Decidim::TranslatableAttributes
+
+      def milestones_path(params = {})
+        Decidim::EngineRouter.main_proxy(current_component).milestones_path(params)
+      end
+
+      def tasks_label
+        translated_attribute(component_settings.tasks_label).presence || t("models.task.name", scope: "decidim.time_tracker")
+      end
+
+      def activities_label
+        translated_attribute(component_settings.activities_label).presence || t("models.activity.name", scope: "decidim.time_tracker")
+      end
+
+      def assignations_label
+        translated_attribute(component_settings.assignations_label).presence || t("models.assignation.name", scope: "decidim.time_tracker")
+      end
+
+      def time_events_label
+        translated_attribute(component_settings.time_events_label).presence || t("models.time_entry.name", scope: "decidim.time_tracker")
+      end
+
+      def milestones_label
+        translated_attribute(component_settings.milestones_label).presence || t("models.milestone.name", scope: "decidim.time_tracker")
+      end
+
+      # turns a number of seconds to a string 0h 0m 0s
+      def clockify_seconds(total_seconds, padded: false)
+        total_seconds = total_seconds.to_i
+
+        clock = {
+          hours: total_seconds / (60 * 60),
+          minutes: (total_seconds / 60) % 60,
+          seconds: total_seconds % 60
+        }
+
+        content_tag :span, class: "time-tracker--clock" do
+          safe_join(
+            clock.map do |label, value|
+              string_value = padded ? value.to_s.rjust(2, "0") : value
+              content_tag(:span, t("decidim.time_tracker.clock.#{label}", n: string_value), class: ("text-muted" if value.zero?))
+            end
+          )
+        end
+      end
+
+      def assignation_status_label(status)
+        klass = case status
+                when "accepted" then "success"
+                when "pending" then "warning"
+                when "rejected" then "danger"
+                end
+
+        content_tag :span, class: "#{klass} label" do
+          t("models.assignation.fields.statuses.#{status}", scope: "decidim.time_tracker")
+        end
+      end
+
+      def assignation_date(assignation)
+        if assignation.invited_at.present?
+          t("models.assignation.fields.invited_at", time: l(assignation.invited_at, format: :short), scope: "decidim.time_tracker")
+        elsif assignation.requested_at.present?
+          t("models.assignation.fields.requested_at", time: l(assignation.requested_at, format: :short), scope: "decidim.time_tracker")
+        end
+      end
+
+      def user_total_time_dedicated(user)
+        Assignation.where(user: user).sum(&:time_dedicated)
+      end
+
+      def user_joined_at(user)
+        Assignee.for(user).tos_accepted_at(time_tracker)
+      end
+
+      def user_last_milestone(user)
+        Milestone.where(user: user).order(created_at: :desc).first
+      end
+
+      def must_fill_in_data?
+        !current_assignee.tos_accepted?(time_tracker) && !activities_empty?
+      end
+
+      def activities_empty?
+        time_tracker.activities.active.empty?
+      end
+    end
+  end
+end

data/app/jobs/decidim/time_tracker/stop_counter_job.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This jobs stops a counter if is over timed
+  module TimeTracker
+    class StopCounterJob < ApplicationJob
+      queue_as :default
+
+      # time_event - the counter to stop, only stopped if it's due time is reached
+      def perform(time_event)
+        @time_event = time_event
+        return if @time_event.stopped?
+        return if time_available?
+
+        @time_event.stop!
+      end
+
+      private
+
+      def time_available?
+        date = Time.zone.at(@time_event.start)
+        last_elapsed = @time_event.seconds_elapsed
+        remaining = @time_event.activity.user_remaining_for_date(@time_event.user, date)
+
+        remaining > last_elapsed
+      end
+    end
+  end
+end

data/app/models/decidim/time_tracker/activity.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TimeTracker
+    # The data store for a Activity in the Decidim::TimeTracker component. It
+    # stores a description and other useful information related to an activity.
+    class Activity < ApplicationRecord
+      include Decidim::Traceable
+      include Decidim::Loggable
+
+      self.table_name = :decidim_time_tracker_activities
+
+      belongs_to :task,
+                 class_name: "Decidim::TimeTracker::Task"
+
+      has_many :assignations,
+               class_name: "Decidim::TimeTracker::Assignation",
+               dependent: :destroy
+
+      has_many :time_events,
+               class_name: "Decidim::TimeTracker::TimeEvent"
+
+      has_many :milestones,
+               class_name: "Decidim::TimeTracker::Milestone"
+
+      scope :active, -> { where(active: true) }
+
+      delegate :questionnaire, to: :task
+
+      # total number of seconds spent by the user
+      # not counting current counters
+      def user_total_seconds(user)
+        time_events.where(user: user).sum(&:total_seconds).to_i
+      end
+
+      def user_total_seconds_for_date(user, date)
+        time_events.started_between(date.beginning_of_day, date.end_of_day).where(user: user).sum(&:total_seconds).to_i
+      end
+
+      # Total number of seconds spent by the user
+      # and counting any possible running counters
+      def user_seconds_elapsed(user)
+        total = user_total_seconds(user)
+        total += last_event_for(user).seconds_elapsed if last_event_for(user)
+        total
+      end
+
+      def counter_active_for?(user)
+        return false unless last_event_for(user)
+
+        !last_event_for(user).stopped?
+      end
+
+      # Returns how many seconds are available for this task in the current day
+      # this can be less than the activity is allowed due the change of date
+      def remaining_seconds_for_today
+        @remaining_seconds_for_today ||= [max_minutes_per_day * 60, (Time.current.end_of_day - Time.current).to_i].min
+      end
+
+      # how many seconds ara available for this task and user for the current day
+      def user_remaining_for_date(user, date)
+        total_seconds = user_total_seconds_for_date(user, date)
+        remaining = max_minutes_per_day * 60
+        remaining = remaining_seconds_for_today if date.beginning_of_day == Date.current
+
+        [remaining - total_seconds, 0].max
+      end
+
+      def user_remaining_for_today(user)
+        user_remaining_for_date(user, Date.current)
+      end
+
+      def assignation_pending?(user)
+        assignations.pending.where(user: user).count.positive?
+      end
+
+      def assignation_accepted?(user)
+        assignations.accepted.where(user: user).count.positive?
+      end
+
+      def assignation_rejected?(user)
+        assignations.rejected.where(user: user).count.positive?
+      end
+
+      def has_assignation?(user)
+        assignations.where(user: user).count.positive?
+      end
+
+      def has_questions?
+        questionnaire.questions.any?
+      end
+
+      def allow_answers_for?(user)
+        return false if status == :inactive
+
+        return false unless has_questions?
+
+        assignation_accepted?(user)
+      end
+
+      def answered_by?(user)
+        questionnaire.answered_by? session_token(user)
+      end
+
+      # used as a unique idenfier when answering the task associated questionnaire
+      def session_token(user)
+        "#{Digest::SHA1.hexdigest(user.id.to_s)}-#{id}"
+      end
+
+      # Returns a identificative (I18n) string about the current status of activity
+      # Returns:
+      # :open if user can track time
+      # :finished if current date is passed end date
+      # :not_started if current date has not reach start date
+      # :inactive if current status is inactive
+      def status
+        return :inactive unless active?
+        return :not_started if start_date > Time.current.beginning_of_day
+        return :finished if end_date < Time.current.beginning_of_day
+
+        :open
+      end
+
+      def self.log_presenter_class_for(_log)
+        Decidim::TimeTracker::AdminLog::ActivityPresenter
+      end
+
+      private
+
+      def last_event_for(user)
+        time_events.last_for(user)
+      end
+    end
+  end
+end

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

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

data/app/models/decidim/time_tracker/assignation.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TimeTracker
+    # The data store for an assignation in the Decidim::TimeTracker component.
+    class Assignation < ApplicationRecord
+      include Decidim::Traceable
+      include Decidim::Loggable
+
+      self.table_name = :decidim_time_tracker_assignations
+
+      belongs_to :user,
+                 foreign_key: "decidim_user_id",
+                 class_name: "Decidim::User"
+
+      belongs_to :invited_by_user,
+                 class_name: "Decidim::User",
+                 optional: true
+
+      belongs_to :activity,
+                 class_name: "Decidim::TimeTracker::Activity"
+
+      has_one :task,
+              class_name: "Decidim::TimeTracker::Task",
+              through: :activity
+
+      has_many :time_events,
+               class_name: "Decidim::TimeTracker::TimeEvent",
+               dependent: :nullify
+
+      has_many :milestones,
+               class_name: "Decidim::TimeTracker::Milestone",
+               through: :user
+
+      enum status: [:pending, :accepted, :rejected]
+
+      def assignee
+        Assignee.for(user)
+      end
+
+      def time_dedicated
+        time_events.sum(&:total_seconds)
+      end
+
+      def time_dedicated_to(activity)
+        time_events.where(activity: activity).sum(&:total_seconds)
+      end
+
+      def can_change_status?
+        time_events.empty?
+      end
+
+      # rubocop:disable Lint/UselessAssignment
+      def self.sorted_by_status(*statuses)
+        accepted = self.accepted.sort_by(&:time_dedicated).reverse
+        pending = self.pending
+        rejected = self.rejected
+
+        statuses.map { |status| send(status) }.sum
+      end
+      # rubocop:enable Lint/UselessAssignment
+
+      def self.log_presenter_class_for(_log)
+        Decidim::TimeTracker::AdminLog::AssignationPresenter
+      end
+    end
+  end
+end

data/app/models/decidim/time_tracker/assignee.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TimeTracker
+    # The data store for an assignee in the Decidim::TimeTracker component.
+    class Assignee < ApplicationRecord
+      self.table_name = :decidim_time_tracker_assignees
+
+      belongs_to :user,
+                 foreign_key: "decidim_user_id",
+                 class_name: "Decidim::User"
+
+      has_many :tos_acceptances,
+               class_name: "Decidim::TimeTracker::TosAcceptance"
+
+      def self.for(user)
+        find_or_create_by(user: user)
+      end
+
+      def tos_accepted_at(time_tracker)
+        tos_acceptances.find_by(time_tracker: time_tracker)&.created_at
+      end
+
+      def tos_accepted?(time_tracker)
+        tos_acceptances.exists?(time_tracker: time_tracker)
+      end
+    end
+  end
+end

data/app/models/decidim/time_tracker/assignee_data.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TimeTracker
+    # The data store for a AssigneeData in the Decidim::TimeTracker component.
+    class AssigneeData < ApplicationRecord
+      include Decidim::Forms::HasQuestionnaire
+
+      self.table_name = :decidim_time_tracker_assignee_data
+
+      belongs_to :time_tracker,
+                 class_name: "Decidim::TimeTracker::TimeTracker"
+
+      delegate :questions, :answers, to: :questionnaire
+
+      delegate :organization, :component, to: :time_tracker
+    end
+  end
+end

data/app/models/decidim/time_tracker/milestone.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TimeTracker
+    # The data store for a Milestone in the Decidim::TimeTracker component.
+    class Milestone < ApplicationRecord
+      include Decidim::HasAttachments
+      include Decidim::Resourceable
+
+      self.table_name = :decidim_time_tracker_milestones
+
+      belongs_to :user,
+                 foreign_key: "decidim_user_id",
+                 class_name: "Decidim::User"
+
+      belongs_to :activity,
+                 class_name: "Decidim::TimeTracker::Activity"
+
+      has_one :task,
+              through: :activity,
+              class_name: "Decidim::TimeTracker::Task"
+
+      delegate :component, to: :task
+      delegate :organization, to: :user
+    end
+  end
+end