rails_execution 0.1.5 → 0.1.8

data/app/controllers/rails_execution/tasks_controller.rb

@@ -2,10 +2,12 @@
 
 module RailsExecution
   class TasksController < ::RailsExecution::BaseController
+    LIMITED_FILTER_LIST = 100
 
     def index
       paging = ::RailsExecution::Services::Paging.new(page: params[:page], per_page: params[:per_page])
-      processing_tasks = ::RailsExecution::Task.processing.descending.includes(:owner)
+      processing_tasks = ::RailsExecution::Task.processing.preload(:owner, :labels)
+      processing_tasks = ::RailsExecution::Tasks::FilterService.new(processing_tasks, params, current_owner&.id).call
       @tasks = paging.call(processing_tasks)
     end
 
@@ -18,21 +20,11 @@ module RailsExecution
     def create
       raise(::RailsExecution::AccessDeniedError, 'Create task') unless can_create_task?
 
-      @task = ::RailsExecution::Task.new({
-        status: :created,
-        owner_id: current_owner&.id,
-        owner_type: ::RailsExecution.configuration.owner_model.to_s,
-        title: params.dig(:task, :title),
-        description: params.dig(:task, :description),
-        script: params.dig(:task, :script),
-      })
-      @task.assign_reviewers(params.dig(:task, :task_review_ids).to_a)
-      @task.syntax_status = ::RailsExecution::Services::SyntaxChecker.new(@task.script).call ? 'good' : 'bad'
-
-      if @task.save
-        @task.add_files(params[:attachments]&.permit!.to_h, current_owner) if ::RailsExecution.configuration.file_upload
-        ::RailsExecution.configuration.notifier.new(@task).after_create
-        flash[:notice] = 'Create the request is successful!'
+      result = ::RailsExecution::Tasks::CreateService.new(params, current_owner).call
+      @task = result.task
+      if result.error.nil?
+        ::RailsExecution::Services::CreateScheduledJob.new(@task).call if in_solo_mode? && can_schedule_task?(@task)
+        flash[:notice] = 'Create request successfully!'
         redirect_to action: :index
       else
         render action: :new
@@ -47,9 +39,12 @@ module RailsExecution
         owner_id: current_owner&.id,
         owner_type: ::RailsExecution.configuration.owner_model.to_s,
         title: current_task.title,
+        scheduled_at: current_task.scheduled_at,
+        repeat_mode: current_task.repeat_mode,
         description: current_task.description,
         script: current_task.script,
       })
+      @task.labels = current_task.labels
       @task.syntax_status = ::RailsExecution::Services::SyntaxChecker.new(@task.script).call ? 'good' : 'bad'
 
       render action: :new
@@ -65,6 +60,7 @@ module RailsExecution
       end
 
       if current_task.update(status: :closed)
+        ::RailsExecution::Services::RemoveScheduledJob.new(current_task).call if can_remove_scheduled_job?(current_task)
         current_task.activities.create(owner: current_owner, message: 'Closed the task')
         ::RailsExecution.configuration.notifier.new(current_task).after_close
         redirect_to(action: :show) and return
@@ -84,20 +80,26 @@ module RailsExecution
       raise(::RailsExecution::AccessDeniedError, 'Edit task') unless can_edit_task?(current_task)
 
       @task = current_task
+
       old_script = @task.script
       old_reviewer_ids = @task.task_reviews.pluck(:owner_id)
       checked_owner_ids = @task.task_reviews.checked.pluck(:owner_id)
+      old_scheduled_at = @task.scheduled_at
 
       update_data = {
         title: params.dig(:task, :title),
         description: params.dig(:task, :description),
+        scheduled_at: Time.zone.parse(params.dig(:task, :scheduled_at).to_s),
+        repeat_mode: params.dig(:task, :repeat_mode),
       }
 
       update_data[:script] = params.dig(:task, :script) if @task.in_processing?
       @task.assign_reviewers(params.dig(:task, :task_review_ids).to_a)
+      @task.assign_labels(params[:task_label_ids].to_a) if params.key?(:task_label_ids)
       @task.syntax_status = ::RailsExecution::Services::SyntaxChecker.new(update_data[:script]).call ? 'good' : 'bad'
 
       if @task.update(update_data)
+        ::RailsExecution::Services::RemoveScheduledJob.new(@task).call if (old_script != @task.script || @task.scheduled_at != old_scheduled_at) && can_remove_scheduled_job?(@task)
         @task.add_files(params[:attachments]&.permit!.to_h, current_owner) if ::RailsExecution.configuration.file_upload
         @task.activities.create(owner: current_owner, message: 'Updated the Task')
         ::RailsExecution.configuration.notifier.new(@task).after_update_script(current_owner, checked_owner_ids) if old_script != @task.script
@@ -110,18 +112,21 @@ module RailsExecution
 
     def completed
       paging = ::RailsExecution::Services::Paging.new(page: params[:page], per_page: params[:per_page])
-      completed_tasks = ::RailsExecution::Task.is_completed.descending.includes(:owner)
+      completed_tasks = ::RailsExecution::Task.is_completed.preload(:owner, :labels)
+      completed_tasks = ::RailsExecution::Tasks::FilterService.new(completed_tasks, params, current_owner&.id).call
       @tasks = paging.call(completed_tasks)
     end
 
     def closed
       paging = ::RailsExecution::Services::Paging.new(page: params[:page], per_page: params[:per_page])
-      closed_tasks = ::RailsExecution::Task.is_closed.descending.includes(:owner)
+      closed_tasks = ::RailsExecution::Task.is_closed.preload(:owner, :labels)
+      closed_tasks = ::RailsExecution::Tasks::FilterService.new(closed_tasks, params, current_owner&.id).call
       @tasks = paging.call(closed_tasks)
     end
 
     def reopen
       if current_task.update(status: :created)
+        ::RailsExecution::Services::CreateScheduledJob.new(current_task).call if in_solo_mode? && can_schedule_task?(current_task)
         current_task.activities.create(owner: current_owner, message: 'Re-opened the Task')
         ::RailsExecution.configuration.notifier.new(current_task).after_reopen
         flash[:notice] = 'Your task is re-opened'
@@ -133,6 +138,7 @@ module RailsExecution
 
     def reject
       if ::RailsExecution::Services::Approvement.new(current_task, reviewer: current_owner).reject
+        ::RailsExecution::Services::RemoveScheduledJob.new(current_task).call if can_remove_scheduled_job?(current_task)
         ::RailsExecution.configuration.notifier.new(current_task).after_reject(current_owner)
         flash[:notice] = 'Your decision is updated!'
       else
@@ -143,10 +149,11 @@ module RailsExecution
 
     def approve
       if ::RailsExecution::Services::Approvement.new(current_task, reviewer: current_owner).approve
+        ::RailsExecution::Services::CreateScheduledJob.new(current_task).call if can_schedule_task?(current_task)
         ::RailsExecution.configuration.notifier.new(current_task).after_approve(current_owner)
         flash[:notice] = 'Your decision is updated!'
       else
-        flash[:alert] = "Your decision is can't update!"
+        flash[:alert] = "Your decision isn't updated!"
       end
       redirect_to action: :show
     end
@@ -159,7 +166,7 @@ module RailsExecution
 
       execute_service = ::RailsExecution::Services::Execution.new(current_task)
       if execute_service.call
-        current_task.update(status: :completed)
+        current_task.update(status: :completed) unless current_task.repeatable?
         current_task.activities.create(owner: current_owner, message: 'Execute: The task is completed')
         ::RailsExecution.configuration.notifier.new(current_task).after_execute_success(current_owner)
         flash[:notice] = 'This task is executed'
@@ -171,6 +178,15 @@ module RailsExecution
       redirect_to(action: :show)
     end
 
+    def execute_in_background
+      unless can_execute_task?(current_task)
+        flash[:alert] = "This task can't execute: #{how_to_executable(current_task)}"
+        redirect_to(action: :show) and return
+      end
+      RailsExecution::Services::BackgroundExecution.new(current_task, current_owner).setup
+      redirect_to(action: :show)
+    end
+
     private
 
     def current_task
@@ -179,14 +195,28 @@ module RailsExecution
     helper_method :current_task
 
     def reviewers
-      @reviewers ||= ::RailsExecution.configuration.reviewers.call.map do |reviewer|
-        ::OpenStruct.new(reviewer)
-      end
+      return @reviewers if defined?(@reviewers)
+
+      list = ::RailsExecution.configuration.reviewers.call
+      list = list.map { |reviewer| reviewer[:id] == current_owner.id ? nil : ::OpenStruct.new(reviewer) }
+      @reviewers = list.compact
     end
     helper_method :reviewers
 
+    def repeat_mode_options
+      @repeat_mode_options ||= {
+        'Does not repeat': :none,
+        'Daily': :daily,
+        'Weekly': :weekly,
+        'Monthly': :monthly,
+        'Anually': :anually,
+        'Every Weekday': :weekdays,
+      }
+    end
+    helper_method :repeat_mode_options
+
     def task_logs
-      @task_logs ||= ::RailsExecution.configuration.logging_files.call(current_task).select(&:present?)
+      @task_logs ||= ::RailsExecution.configuration.logging_files.call(current_task)
     end
     helper_method :task_logs
 
@@ -200,5 +230,35 @@ module RailsExecution
     end
     helper_method :reviewing_accounts
 
+    def filter_owners
+      @filter_owners ||= query_filter_owners
+    end
+    helper_method :filter_owners
+
+    def query_filter_owners
+      return ::RailsExecution.configuration.owner_model.constantize
+        .where(id: RailsExecution::Task.select(:owner_id).distinct)
+        .limit(LIMITED_FILTER_LIST)
+    end
+
+    def filter_labels
+      @filter_labels ||= RailsExecution::Label.order(:name)
+    end
+    helper_method :filter_labels
+
+    def current_filtered_owner
+      @current_filtered_owner ||= ::RailsExecution.configuration.owner_model.constantize.find_by(id: params[:owner_id])
+    end
+    helper_method :current_filtered_owner
+
+    def current_filtered_label
+      @current_filtered_label ||= ::RailsExecution::Label.find_by(id: params[:label_id])
+    end
+    helper_method :current_filtered_label
+
+    def comments_count_by_task
+      @comments_count_by_task ||= ::RailsExecution::Comment.where(task_id: @tasks.ids).group(:task_id).count
+    end
+    helper_method :comments_count_by_task
   end
 end

data/app/helpers/rails_execution/base_helper.rb

@@ -3,12 +3,14 @@ module RailsExecution
     include ActionView::Helpers::AssetUrlHelper
 
     def current_owner
-      return nil if in_solo_mode?
       return @current_owner if defined?(@current_owner)
       return nil if ::RailsExecution.configuration.owner_method.blank?
-
       @current_owner = self.send(::RailsExecution.configuration.owner_method)
     end
 
+    def normal_labels
+      @normal_labels ||= RailsExecution::Label.normal
+    end
+
   end
 end

data/app/helpers/rails_execution/policy_helper.rb

@@ -51,6 +51,7 @@ module RailsExecution
       return 'Script is empty' if task.script.blank?
       return "Task is closed" if task.is_closed?
       return "It's bad Syntax" if task.syntax_status_bad?
+      return "This task is being processed" if task.is_processing?
 
       unless in_solo_mode?
         return 'This task is not approved' unless task.is_approved?
@@ -60,5 +61,20 @@ module RailsExecution
       return "Can't executable by app policy" unless ::RailsExecution.configuration.task_executable.call(current_owner, task)
     end
 
+    def can_schedule_task?(task)
+      how_to_schedulable(task).blank?
+    end
+
+    def how_to_schedulable(task)
+      execute_message = how_to_executable(task)
+      return execute_message if execute_message
+      return "Time is not set for schedule" if task.scheduled_at.nil?
+      return "Scheduled at time in the past" if task.scheduled_at.past?
+    end
+
+    def can_remove_scheduled_job?(task)
+      task.jid.present?
+    end
+
   end
 end

data/app/helpers/rails_execution/rendering_helper.rb

@@ -1,5 +1,7 @@
 module RailsExecution
   module RenderingHelper
+    AVATAR_CLASS = 'bd-placeholder-img flex-shrink-0 me-2 rounded'
+    TRUNCATE_FILE_NAME_LENGTH = 20
 
     def render_user_info(user, avatar_size: '40x40')
       content_tag :div, class: 'user-info' do
@@ -9,16 +11,16 @@ module RailsExecution
     end
 
     def render_owner_avatar(owner, size: '32x32')
-      return nil if owner.blank?
+      return image_tag(asset_path('executions/robot.png'), size: size, class: AVATAR_CLASS) if owner.blank?
 
       avatar_url = RailsExecution.configuration.owner_avatar.call(owner)
       return nil if avatar_url.blank?
 
-      image_tag avatar_url, size: size, class: 'bd-placeholder-img flex-shrink-0 me-2 rounded'
+      image_tag avatar_url, size: size, class: AVATAR_CLASS
     end
 
     def render_owner_name(owner)
-      return nil if owner.blank?
+      return 'System' if owner.blank?
       return nil if RailsExecution.configuration.owner_name_method.blank?
 
       content_tag :span, owner.public_send(RailsExecution.configuration.owner_name_method)
@@ -39,6 +41,27 @@ module RailsExecution
       end
     end
 
+    def render_label(task_label)
+      content_tag :div do
+        concat content_tag :i, '', class: "bi bi-tag label-colors lc-#{task_label.color} bg-none"
+        concat content_tag :span, task_label.name, class: "badge rounded-pill mx-1 label-colors lc-#{task_label.color}"
+      end
+    end
+
+    def render_task_labels(task)
+      # to_a and sort_by instead of .order for avoid N+1 query to sort task labels for each task
+      task.labels.to_a.sort_by(&:name).reduce(''.html_safe) do |result, label|
+        case label.name
+        when 'repeat'
+          result + content_tag(:span, "repeat: #{task.repeat_mode}", class: "badge rounded-pill mx-1 label-tag label-colors lc-#{label.color}", data: { id: label.id })
+        when 'scheduled'
+          result + content_tag(:span, 'scheduled', class: "badge rounded-pill mx-1 label-tag label-colors lc-#{label.color}", data: { id: label.id })
+        else
+          result + content_tag(:span, label.name, class: "badge rounded-pill mx-1 label-tag label-colors lc-#{label.color}", data: { id: label.id })
+        end
+      end
+    end
+
     def task_reviewed_status(task)
       @task_reviewed_status ||= {}
       @task_reviewed_status[task] ||= task.task_reviews.find_by(owner_id: current_owner&.id)&.status&.inquiry
@@ -67,7 +90,7 @@ module RailsExecution
     end
 
     def re_get_file_name(url)
-      URI(url).path.split('/').last
+      URI(url).path.split('/').last&.truncate(TRUNCATE_FILE_NAME_LENGTH)
     end
 
     def re_badge_color(status)
@@ -86,6 +109,7 @@ module RailsExecution
         rejected: 'danger',
         approved: 'success',
         reviewing: 'secondary',
+        processing: 'warning',
         completed: 'success',
       }[text] || 'secondary'
     end

data/app/models/rails_execution/label.rb

@@ -0,0 +1,15 @@
+class RailsExecution::Label < RailsExecution::AppModel
+  SPECIAL_LABLES = ['scheduled', 'repeat']
+  COLORS = 'red pink purple deep-purple indigo blue light-blue cyan teal green orange deep-orange brown grey blue-grey'.split
+
+  has_many :task_labels, class_name: 'RailsExecution::TaskLabel'
+  has_many :tasks, through: :task_labels
+
+  validates :name, presence: true, uniqueness: { case_sensitive: false }
+  scope :normal, -> { where.not(name: SPECIAL_LABLES) }
+
+  def color
+    color_index = self.name.to_s.chars.sum(&:ord) % COLORS.size
+    COLORS[color_index]
+  end
+end

data/app/models/rails_execution/task.rb

@@ -1,21 +1,29 @@
 class RailsExecution::Task < RailsExecution::AppModel
 
-  PROCESSING_STATUSES = %w(created reviewing approved rejected)
+  PROCESSING_STATUSES = %w(created reviewing approved processing rejected)
+  ACTIVE_REPEAT_MODE = %w(hourly daily weekly monthly annually weekdays)
 
   has_many :activities, class_name: 'RailsExecution::Activity'
   has_many :comments, class_name: 'RailsExecution::Comment'
   has_many :task_reviews, class_name: 'RailsExecution::TaskReview'
+  has_many :task_labels, class_name: 'RailsExecution::TaskLabel'
+  has_many :labels, through: :task_labels
   attr_accessor :reviewer_ids
 
   validates :title, presence: true
   validates :status, presence: true
+  validate :validate_scheduled_at, if: :scheduled_at_changed?
+
+  before_validation :auto_assign_labels
 
   enum status: {
     created: 'created',
     reviewing: 'reviewing',
     approved: 'approved',
-    rejected: 'rejected',
+    processing: 'processing', # Processing by background job
     completed: 'completed',
+    failed: 'failed',
+    rejected: 'rejected',
     closed: 'closed',
   }, _prefix: :is
 
@@ -24,6 +32,16 @@ class RailsExecution::Task < RailsExecution::AppModel
     good: 'good',
   }, _prefix: true
 
+  enum repeat_mode: {
+    none: 'Does not repeat',
+    hourly: 'Hourly',
+    daily: 'Daily',
+    weekly: 'Weekly',
+    monthly: 'Monthly',
+    annually: 'Anually',
+    weekdays: 'Every weekday (Monday to Friday)',
+  }, _prefix: :repeat
+
   scope :processing, -> { where(status: PROCESSING_STATUSES) }
 
   before_update :re_assign_status
@@ -33,6 +51,14 @@ class RailsExecution::Task < RailsExecution::AppModel
     PROCESSING_STATUSES.include?(self.status)
   end
 
+  def scheduled?
+    self.scheduled_at? && self.repeat_none?
+  end
+
+  def repeatable?
+    ACTIVE_REPEAT_MODE.include?(self.repeat_mode)
+  end
+
   def assign_reviewers(ids)
     ids.each do |id|
       next if id.blank?
@@ -45,6 +71,10 @@ class RailsExecution::Task < RailsExecution::AppModel
     end
   end
 
+  def assign_labels(ids)
+    self.labels = RailsExecution::Label.where(id: ids.uniq)
+  end
+
   def reviewer_ids
     self.task_reviews.pluck(:owner_id)
   end
@@ -53,6 +83,23 @@ class RailsExecution::Task < RailsExecution::AppModel
     ::RailsExecution.configuration.file_uploader.new(self, attachments, owner: current_owner).call
   end
 
+  def repeat_mode_select_options
+    return RailsExecution::Task.repeat_modes if scheduled_at.nil?
+
+    options = RailsExecution::Task.repeat_modes.dup
+    options['hourly'] = self.scheduled_at.strftime('Hourly at minute %-M')
+    options['daily'] = self.scheduled_at.strftime('Daily at %H:%M')
+    options['weekly'] = self.scheduled_at.strftime('Weekly on %A at %H:%M')
+    options['monthly'] = self.scheduled_at.strftime('Monthly on %-d at %H:%M')
+    options['annually'] = self.scheduled_at.strftime('Annually on %B %-d at %H:%M')
+    options['weekdays'] = self.scheduled_at.strftime('Every weekday (Monday to Friday) at %H:%M')
+    return options
+  end
+
+  def next_time_at
+    ::RailsExecution::Services::CreateScheduledJob.new(self).calculate_next_time_at.strftime("%Y-%m-%d %H:%M")
+  end
+
   private
 
   def create_activity
@@ -62,10 +109,31 @@ class RailsExecution::Task < RailsExecution::AppModel
   def re_assign_status
     return if self.is_completed? || self.is_closed?
 
-    if self.is_approved? && self.script_changed?
+    if self.is_approved? && (self.script_changed? || self.scheduled_at_changed?)
       self.status = :reviewing
       self.task_reviews.update_all(status: :reviewing)
     end
   end
 
+  def validate_scheduled_at
+    return if self.scheduled_at.blank?
+
+    errors.add(:scheduled_at, "Input schedule time #{scheduled_at} is in the past for non-repeat mode") if scheduled_at.past? && repeat_none?
+  end
+
+  def auto_assign_labels
+    scheduled_label = RailsExecution::Label.find_or_create_by(name: :scheduled)
+    repeat_label = RailsExecution::Label.find_or_create_by(name: :repeat)
+
+    final_label_ids = self.label_ids - [scheduled_label.id, repeat_label.id]
+
+    if self.scheduled?
+      final_label_ids << scheduled_label.id
+    elsif self.repeatable?
+      final_label_ids << repeat_label.id
+    end
+
+    self.label_ids = final_label_ids
+  end
+
 end

data/app/models/rails_execution/task_label.rb

@@ -0,0 +1,6 @@
+class RailsExecution::TaskLabel < RailsExecution::AppModel
+  belongs_to :task, class_name: 'RailsExecution::Task'
+  belongs_to :label, class_name: 'RailsExecution::Label'
+
+  validates :task, uniqueness: { scope: :label }
+end

data/app/services/rails_execution/tasks/create_service.rb

@@ -0,0 +1,62 @@
+class RailsExecution::Tasks::CreateService
+
+  def initialize(params, current_owner)
+    @params = params
+    @current_owner = current_owner
+    @task = nil
+    @error = nil
+  end
+
+  def call
+    initialize_task
+    create_task
+  rescue => e
+    @error = e.to_s
+  ensure
+    return self
+  end
+
+  attr_reader :error
+  attr_reader :task
+
+  private
+
+  attr_reader :params
+  attr_reader :current_owner
+
+  def initialize_task
+    @task = ::RailsExecution::Task.new({
+      status: :created,
+      owner_id: current_owner&.id,
+      owner_type: ::RailsExecution.configuration.owner_model.to_s,
+      title: params.dig(:task, :title),
+      description: params.dig(:task, :description),
+      script: params.dig(:task, :script),
+      scheduled_at: parsed_scheduled_at,
+      repeat_mode: params.dig(:task, :repeat_mode)
+    })
+
+    @task.assign_reviewers(params.dig(:task, :task_review_ids).to_a)
+    @task.assign_labels(params[:task_label_ids].to_a)
+    @task.syntax_status = ::RailsExecution::Services::SyntaxChecker.new(@task.script).call ? 'good' : 'bad'
+  end
+
+  def scheduled_at
+    @scheduled_at ||= params.dig(:task, :scheduled_at)
+  end
+
+  def parsed_scheduled_at
+    @parsed_scheduled_at ||= scheduled_at.blank? ? nil : Time.zone.parse(scheduled_at)
+  rescue
+    raise 'Invalid input for scheduling time'
+  end
+
+  def create_task
+    if @task.save
+      @task.add_files(params[:attachments]&.permit!.to_h, current_owner) if ::RailsExecution.configuration.file_upload
+      ::RailsExecution.configuration.notifier.new(@task).after_create
+    else
+      raise @task.errors.messages.values.flatten.first
+    end
+  end
+end

data/app/services/rails_execution/tasks/filter_service.rb

@@ -0,0 +1,49 @@
+class RailsExecution::Tasks::FilterService
+
+  def initialize(tasks_query_object, params, current_user_id = nil)
+    @tasks_query_object = tasks_query_object
+    @params = params
+    @current_user_id = current_user_id
+  end
+
+  def call
+    filter_by_owner
+    filter_by_label
+    filter_by_keyword
+    order_by_recently_updated
+
+    return @tasks_query_object.descending
+  end
+
+  private
+
+  attr_reader :params
+  attr_reader :current_user_id
+
+  def filter_by_owner
+    if params[:my_task] == '1' && current_user_id
+      @tasks_query_object = @tasks_query_object.where(owner_id: current_user_id)
+    elsif params[:owner_id].present?
+      @tasks_query_object = @tasks_query_object.where(owner_id: params[:owner_id])
+    end
+  end
+
+  def filter_by_label
+    return if params[:label_id].blank?
+
+    filtered_task_ids = RailsExecution::TaskLabel.where(label_id: params[:label_id]).select(:task_id)
+    @tasks_query_object = @tasks_query_object.where(id: filtered_task_ids)
+  end
+
+  def filter_by_keyword
+    return if params[:keyword].blank?
+
+    @tasks_query_object = @tasks_query_object.where("rails_execution_tasks.title LIKE ?", "%#{params[:keyword]}%")
+  end
+
+  def order_by_recently_updated
+    sort_by = params[:recently_updated] == '1' ? { updated_at: :desc } : { updated_at: :asc }
+    @tasks_query_object = @tasks_query_object.order(sort_by)
+  end
+
+end

data/app/views/rails_execution/shared/_paging.html.haml

@@ -1,7 +1,7 @@
 - return if total_pages <= 1
 - original_params = params.permit!.to_h
 
-- gap_number = 2
+- gap_number = 1
 - page_numbers = (1..total_pages).to_a
 - begin_paging = (1..(1 + gap_number)).to_a
 - middle_paging = page_numbers & ((page - gap_number)..(page + gap_number)).to_a

data/app/views/rails_execution/tasks/_actions.html.haml

@@ -2,7 +2,9 @@
   = re_card_content do
     .text-center
       - if can_execute_task?(current_task)
-        = link_to 'Execute NOW!!!', execute_task_path(current_task), class: 'btn btn-primary', method: :patch, data: { confirm: 'Are you sure?' }
+        = link_to 'Execute NOW!!!', execute_task_path(current_task), class: 'btn btn-block btn-primary', method: :patch, data: { confirm: 'Are you sure?' }
+        - if RailsExecution.configuration.task_background
+          = link_to 'Execute in background!', execute_in_background_task_path(current_task), class: 'btn btn-block btn-secondary', method: :patch, data: { confirm: 'Are you sure?' }
       - else
         %p.text-danger.mb-0.fw-bold
           %i.bi.bi-x-octagon.me-1

data/app/views/rails_execution/tasks/_activities.html.haml

@@ -2,21 +2,27 @@
   = re_card_content do
     %h5.section-title Logs
     %ul.list-unstyled#task-logs
-      - task_logs.each do |task_log|
-        %li.fs-13.row.mb-3
-          .col.text-muted
-            %i.bi.bi-journal-text
-            = re_get_file_name(task_log)
-          .col-3.text-end= link_to 'Download', task_log, target: :_blank, class: 'text-muted click2download'
+      - task_logs.each do |task_log, created_at|
+        %li.row.g-0.vetical-align-middle
+          .col.d-flex.align-items-center= re_get_file_name(task_log)
+          - if created_at
+            .col-auto.pe-3
+              .activitiy-time.text-muted.text-end
+                %span.fs13px= created_at.strftime('%Y/%m/%d')
+                %p.mb-0= created_at.strftime('%H:%M')
+          .col-auto.text-center
+            = link_to task_log, target: :_blank, class: 'text-muted click2download' do
+              %i.bi.bi-download.fs-5
+              %p.small.mb-0 Download
 
 = re_card_content id: 'activities-section' do
   %h5.section-title Activities
   %ul.list-unstyled
     - current_task.activities.descending.preload(:owner).each do |activitiy|
-      %li.row
+      %li.row.g-0.vetical-align-middle.mb-3
         .col
           = render_user_info(activitiy.owner, avatar_size: '20x20')
-          %p.normal-text.mt-1= activitiy.message
-        .col-3.text-end.activitiy-time
+          %p.mb-0.normal-text.mt-1= activitiy.message
+        .col-auto.text-end.activitiy-time
           %span.fs13px.text-muted= activitiy.created_at.strftime('%Y/%m/%d')
-          %p.text-muted= activitiy.created_at.strftime('%H:%M')
+          %p.mb-0.text-muted= activitiy.created_at.strftime('%H:%M')