foreman-tasks 0.15.11 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4df371b5aa1cfdad4ad156735395fab15e6542eba6418d53985c8181e12ad5ea
-  data.tar.gz: 14a678308db6edb2aabcb753400cf33b8f00a820170f2613e40ef63ae6462580
+  metadata.gz: a562e9a32057e45cbf20bcc2d511ee03580cee1181af686965683bccfc1d6f8e
+  data.tar.gz: bcffaac1d9efb02ef8677394c7af554058aad577d5e1a7ce9b32c66ac21206f1
 SHA512:
-  metadata.gz: c665d42181bf30b86106da534c3cbb644a11fdc289af03c7dff951999991c952fdd99b2dc18caead3d525f3dbe46952b770dab17a0b944662de62309fd160be5
-  data.tar.gz: 991d4ededda66b5ae4ef7320febaa856300b7e512110893adc661c38df3e080e18889d880c849fcb5dd1791bf70063efa18ab5860a0f761756920a37b5804e8f
+  metadata.gz: e7acf7b281043c1ad3a3c0fcb45436258caf1f11a06295c5e4b69b43f8bbe5ea450d61e25346d638198c72596e1ac3e86fdad1eff2f092d4fc3254cb8e551d5f
+  data.tar.gz: e5c9234ef7ccd241c17ef37892a79d04b6de918034d1e305093bea7b54ce125dce88cb1c9360f4a7dab1674eefbd00db20b3848a445ea297eeaab37c271cd855

data/app/controllers/foreman_tasks/tasks_controller.rb

@@ -12,18 +12,26 @@ module ForemanTasks
 
     def index
       params[:order] ||= 'started_at DESC'
-      respond_with_tasks resource_base
+      respond_to do |format|
+        format.html do
+          @tasks = filter(resource_base)
+          render :index, layout: !request.xhr?
+        end
+        format.csv do
+          @tasks = filter(resource_base, paginate: false)
+          csv_response(@tasks, [:id, :action, :state, :result, 'started_at.in_time_zone', 'ended_at.in_time_zone', :username], ['Id', 'Action', 'State', 'Result', 'Started At', 'Ended At', 'User'])
+        end
+      end
     end
 
     def summary
-      scope = resource_base.search_for(current_taxonomy_search).select(:id)
-      render json: Task::Summarizer.new(Task.where(:id => scope), params[:recent_timeframe].to_i).summary
+      render json: Task::Summarizer.new(resource_base, params[:recent_timeframe].to_i).summary
     end
 
     def sub_tasks
-      # @task is used when rendering breadcrumbs
-      @task = resource_base.find(params[:id])
-      respond_with_tasks @task.sub_tasks
+      task   = resource_base.find(params[:id])
+      @tasks = filter(task.sub_tasks)
+      render :index
     end
 
     def cancel_step
@@ -95,19 +103,6 @@ module ForemanTasks
 
     private
 
-    def respond_with_tasks(scope)
-      respond_to do |format|
-        format.html do
-          @tasks = filter(scope)
-          render :index, layout: !request.xhr?
-        end
-        format.csv do
-          @tasks = filter(scope, paginate: false)
-          csv_response(@tasks, [:id, :action, :state, :result, 'started_at.in_time_zone', 'ended_at.in_time_zone', :username], ['Id', 'Action', 'State', 'Result', 'Started At', 'Ended At', 'User'])
-        end
-      end
-    end
-
     def restrict_dangerous_actions
       render_403 unless Setting['dynflow_allow_dangerous_actions']
     end

data/app/helpers/foreman_tasks/foreman_tasks_helper.rb

@@ -122,26 +122,6 @@ module ForemanTasks
       render :partial => 'common/trigger_form', :locals => { :f => f, :triggering => triggering }
     end
 
-    def task_breadcrumb_item(task, active = false)
-      item = { :caption => format_task_input(task) }
-      item[:url] = url_for(foreman_tasks_task_path(task.id)) unless active
-      item
-    end
-
-    def index_breadcrumb_item
-      item = { :caption => _('Tasks') }
-      item[:url] = foreman_tasks_tasks_url if action_name != 'index'
-      item
-    end
-
-    def breadcrumb_items
-      items = [index_breadcrumb_item]
-      return items if action_name == 'index'
-      items << task_breadcrumb_item(@task, action_name == 'show')
-      items << { :caption => _('Sub tasks') } if action_name == 'sub_tasks'
-      items
-    end
-
     private
 
     def future_mode_fieldset(f, triggering)

data/app/lib/actions/bulk_action.rb

@@ -46,7 +46,7 @@ module Actions
     def create_sub_plans
       action_class = input[:action_class].constantize
       target_class = input[:target_class].constantize
-      targets = target_class.unscoped.where(:id => current_batch)
+      targets = target_class.where(:id => current_batch)
 
       missing = Array.new((current_batch - targets.map(&:id)).count) { nil }
 

data/app/models/foreman_tasks/lock.rb

@@ -118,11 +118,6 @@ module ForemanTasks
         build_link(resource, uuid).available?
       end
 
-      # Records the information about the user that triggered the task
-      def owner!(user, uuid)
-        build_owner(user, uuid).save!
-      end
-
       private
 
       def all_lock_names(resource, include_links = false)
@@ -166,10 +161,6 @@ module ForemanTasks
         build(uuid, resource, LINK_LOCK_NAME, false)
       end
 
-      def build_owner(user, uuid = nil)
-        build(uuid, user, OWNER_LOCK_NAME, false)
-      end
-
       def build(uuid, resource, lock_name, exclusive)
         new(task_id:       uuid,
             name:          lock_name,

data/app/models/foreman_tasks/task.rb

@@ -3,6 +3,7 @@ require 'securerandom'
 module ForemanTasks
   class Task < ApplicationRecord
     include Authorizable
+    extend Search
 
     def check_permissions_after_save
       # there's no create_tasks permission, tasks are created as a result of internal actions, in such case we
@@ -29,10 +30,7 @@ module ForemanTasks
     has_many :task_groups, :through => :task_group_members
     has_many :recurring_logic_task_groups, -> { where :type => 'ForemanTasks::TaskGroups::RecurringLogicTaskGroup' },
              :through => :task_group_members, :source => :task_group
-    # in fact, the task has only one owner but Rails don't let you to
-    # specify has_one relation though has_many relation
-    has_many :owners, -> { where(['foreman_tasks_locks.name = ?', Lock::OWNER_LOCK_NAME]) },
-             :through => :locks, :source => :resource, :source_type => 'User'
+    belongs_to :user
 
     scoped_search :on => :id, :complete_value => false
     scoped_search :on => :action, :complete_value => false
@@ -46,17 +44,15 @@ module ForemanTasks
     scoped_search :on => :parent_task_id, :complete_value => true
     scoped_search :relation => :locks,  :on => :resource_id, :complete_value => false, :rename => 'location_id', :ext_method => :search_by_taxonomy, :only_explicit => true
     scoped_search :relation => :locks,  :on => :resource_id, :complete_value => false, :rename => 'organization_id', :ext_method => :search_by_taxonomy, :only_explicit => true
-    scoped_search :relation => :locks,  :on => :resource_type, :complete_value => true, :rename => 'resource_type', :ext_method => :search_by_generic_resource
-    scoped_search :relation => :locks,  :on => :resource_id, :complete_value => false, :rename => 'resource_id', :ext_method => :search_by_generic_resource
-    scoped_search :relation => :owners,
-                  :on => :id,
+    scoped_search :relation => :locks,  :on => :resource_type, :complete_value => true, :rename => 'resource_type', :ext_method => :search_by_generic_resource, :only_explicit => true
+    scoped_search :relation => :locks,  :on => :resource_id, :complete_value => false, :rename => 'resource_id', :ext_method => :search_by_generic_resource, :only_explicit => true
+    scoped_search :on => :user_id,
                   :complete_value => true,
-                  :rename => 'owner.id',
-                  :ext_method => :search_by_owner,
+                  :rename => 'user.id',
                   :validator => ->(value) { ScopedSearch::Validators::INTEGER.call(value) || value == 'current_user' },
-                  :aliases => ['user.id']
-    scoped_search :relation => :owners,  :on => :login, :complete_value => true, :rename => 'owner.login', :ext_method => :search_by_owner, :aliases => [:user]
-    scoped_search :relation => :owners,  :on => :firstname, :complete_value => true, :rename => 'owner.firstname', :ext_method => :search_by_owner
+                  :aliases => ['owner.id'], :ext_method => :search_by_owner, :only_explicit => true
+    scoped_search :relation => :user, :on => :login, :rename => 'user.login', :complete_value => true, :aliases => ['owner.login', 'user'], :ext_method => :search_by_owner, :only_explicit => true
+    scoped_search :relation => :user, :on => :firstname, :rename => 'user.firstname', :complete_value => true, :aliases => ['owner.firstname'], :ext_method => :search_by_owner, :only_explicit => true
     scoped_search :relation => :task_groups, :on => :id, :complete_value => true, :rename => 'task_group.id', :validator => ScopedSearch::Validators::INTEGER
 
     scope :active, -> {  where('foreman_tasks_tasks.state != ?', :stopped) }
@@ -77,11 +73,11 @@ module ForemanTasks
     end
 
     def owner
-      owners.first
+      user
     end
 
     def username
-      owner.try(:login)
+      owner
     end
 
     def execution_type
@@ -150,7 +146,7 @@ module ForemanTasks
 
     # used by Foreman notifications framework
     def notification_recipients_ids
-      owner_ids
+      [owner.id]
     end
 
     def build_notifications
@@ -165,64 +161,6 @@ module ForemanTasks
       notifications
     end
 
-    def self.search_by_generic_resource(key, operator, value)
-      key = 'resource_type' if key.blank?
-      key_name = connection.quote_column_name(key.sub(/^.*\./, ''))
-      condition = sanitize_sql_for_conditions(["foreman_tasks_locks.#{key_name} #{operator} ?", value])
-
-      { :conditions => condition, :joins => :locks }
-    end
-
-    def self.search_by_taxonomy(key, operator, value)
-      uniq_suffix = SecureRandom.hex(3)
-      resource_type = key == 'location_id' ? 'Location' : 'Organization'
-
-      joins = <<-SQL
-      LEFT JOIN foreman_tasks_locks AS foreman_tasks_locks_taxonomy#{uniq_suffix}
-      ON (foreman_tasks_locks_taxonomy#{uniq_suffix}.task_id = foreman_tasks_tasks.id AND
-          foreman_tasks_locks_taxonomy#{uniq_suffix}.resource_type = '#{resource_type}')
-      SQL
-      # Select only those tasks which either have the correct taxonomy or are not related to any
-      sql = "foreman_tasks_locks_taxonomy#{uniq_suffix}.resource_id #{operator} ? OR foreman_tasks_locks_taxonomy#{uniq_suffix}.resource_id IS NULL"
-      { :conditions => sanitize_sql_for_conditions([sql, value]), :joins => joins }
-    end
-
-    def self.search_by_owner(key, operator, value)
-      return { :conditions => '0 = 1' } if value == 'current_user' && User.current.nil?
-
-      key = 'owners.login' if key == 'user'
-      # using uniq suffix to avoid colisions when searching by two different owners via ScopedSearch
-      uniq_suffix = SecureRandom.hex(3)
-      key_name = connection.quote_column_name(key.sub(/^.*\./, ''))
-      value.sub!('*', '%%')
-      condition = if key.blank?
-                    sanitize_sql_for_conditions(["users#{uniq_suffix}.login #{operator} ? or users#{uniq_suffix}.firstname #{operator} ? ", value, value])
-                  elsif key =~ /\.id\Z/
-                    value = User.current.id if value == 'current_user'
-                    sanitize_sql_for_conditions(["foreman_tasks_locks_owner#{uniq_suffix}.resource_id #{operator} ?", value])
-                  else
-                    placeholder, value = operator == 'IN' ? ['(?)', value.split(',').map(&:strip)] : ['?', value]
-                    sanitize_sql_for_conditions(["users#{uniq_suffix}.#{key_name} #{operator} #{placeholder}", value])
-                  end
-      { :conditions => condition, :joins => joins_for_user_search(key, uniq_suffix) }
-    end
-
-    def self.joins_for_user_search(key, uniq_suffix)
-      joins = <<-SQL
-      INNER JOIN foreman_tasks_locks AS foreman_tasks_locks_owner#{uniq_suffix}
-                 ON (foreman_tasks_locks_owner#{uniq_suffix}.task_id = foreman_tasks_tasks.id AND
-                     foreman_tasks_locks_owner#{uniq_suffix}.resource_type = 'User' AND
-                     foreman_tasks_locks_owner#{uniq_suffix}.name = '#{Lock::OWNER_LOCK_NAME}')
-      SQL
-      if key !~ /\.id\Z/
-        joins << <<-SQL
-        INNER JOIN users as users#{uniq_suffix}
-                   ON (users#{uniq_suffix}.id = foreman_tasks_locks_owner#{uniq_suffix}.resource_id)
-        SQL
-      end
-      joins
-    end
-
     def progress
       case state.to_s
       when 'running', 'paused'

data/app/models/foreman_tasks/task/dynflow_task.rb

@@ -208,7 +208,8 @@ module ForemanTasks
     def self.new_for_execution_plan(execution_plan_id, data)
       new(:external_id => execution_plan_id,
           :state => data[:state].to_s,
-          :result => data[:result].to_s)
+          :result => data[:result].to_s,
+          :user_id => User.current.try(:id))
     end
 
     def self.model_name

data/app/models/foreman_tasks/task/search.rb

@@ -0,0 +1,52 @@
+module ForemanTasks
+  class Task
+    module Search
+      def search_by_generic_resource(key, operator, value)
+        key = 'resource_type' if key.blank?
+        key_name = connection.quote_column_name(key.sub(/^.*\./, ''))
+        condition = sanitize_sql_for_conditions(["foreman_tasks_locks.#{key_name} #{operator} ?", value])
+
+        { :conditions => condition, :joins => :locks }
+      end
+
+      def search_by_taxonomy(key, operator, value)
+        uniq_suffix = SecureRandom.hex(3)
+        resource_type = key == 'location_id' ? 'Location' : 'Organization'
+
+        joins = <<-SQL
+        LEFT JOIN foreman_tasks_locks AS foreman_tasks_locks_taxonomy#{uniq_suffix}
+        ON (foreman_tasks_locks_taxonomy#{uniq_suffix}.task_id = foreman_tasks_tasks.id AND
+            foreman_tasks_locks_taxonomy#{uniq_suffix}.resource_type = '#{resource_type}')
+        SQL
+        # Select only those tasks which either have the correct taxonomy or are not related to any
+        sql = "foreman_tasks_locks_taxonomy#{uniq_suffix}.resource_id #{operator} ? OR foreman_tasks_locks_taxonomy#{uniq_suffix}.resource_id IS NULL"
+        { :conditions => sanitize_sql_for_conditions([sql, value]), :joins => joins }
+      end
+
+      def search_by_owner(key, operator, value)
+        return { :conditions => '0 = 1' } if value == 'current_user' && User.current.nil?
+
+        key = 'owners.login' if key == 'user'
+        # using uniq suffix to avoid colisions when searching by two different owners via ScopedSearch
+        uniq_suffix = SecureRandom.hex(3)
+        key_name = connection.quote_column_name(key.sub(/^.*\./, ''))
+        value.sub!('*', '%%')
+        condition = if key.blank?
+                      sanitize_sql_for_conditions(["users_#{uniq_suffix}.login #{operator} ? or users_#{uniq_suffix}.firstname #{operator} ? ", value, value])
+                    elsif key =~ /\.id\Z/
+                      value = User.current.id if value == 'current_user'
+                      sanitize_sql_for_conditions(["foreman_tasks_tasks.user_id #{operator} ?", value])
+                    else
+                      placeholder, value = operator == 'IN' ? ['(?)', value.split(',').map(&:strip)] : ['?', value]
+                      sanitize_sql_for_conditions(["users_#{uniq_suffix}.#{key_name} #{operator} #{placeholder}", value])
+                    end
+        { :conditions => condition, :joins => joins_for_user_search(key, uniq_suffix) }
+      end
+
+      def joins_for_user_search(key, uniq_suffix)
+        return '' if key =~ /\.id\Z/
+        "INNER JOIN users AS users_#{uniq_suffix} ON users_#{uniq_suffix}.id = foreman_tasks_tasks.user_id"
+      end
+    end
+  end
+end

data/app/views/foreman_tasks/tasks/index.html.erb

@@ -10,9 +10,6 @@
       yo: 'ya'
   }.to_json) %>
 <% end %>
-<% content_for(:breadcrumbs) do %>
-  <% breadcrumbs(:items => breadcrumb_items) %>
-<% end %>
 
 <% title _("Tasks") %>
 <% title_actions csv_link, help_button %>

data/app/views/foreman_tasks/tasks/show.html.erb

@@ -1,7 +1,15 @@
 <% stylesheet 'foreman_tasks/tasks' %>
 
 <%= breadcrumbs(
-  items: breadcrumb_items,
+  items: [
+    {
+      caption: _('Tasks'),
+      url: url_for(foreman_tasks_tasks_path)
+    },
+    {
+      caption: format_task_input(@task)
+    }
+  ],
   name_field: 'action',
   resource_url: foreman_tasks_api_tasks_path,
   switcher_item_url: foreman_tasks_task_path(:id => ':id')

data/db/migrate/20180927120509_add_user_id.foreman_tasks.rb

@@ -0,0 +1,40 @@
+class AddUserId < ActiveRecord::Migration[5.0]
+  def up
+    add_reference :foreman_tasks_tasks, :user, :foreign_key => true
+
+    return if User.unscoped.find_by(:login => User::ANONYMOUS_ADMIN).nil?
+    User.as_anonymous_admin do
+      user_locks.select(:resource_id).distinct.pluck(:resource_id).each do |owner_id|
+        tasks = ForemanTasks::Task.joins(:locks).where(:locks => user_locks.where(:resource_id => owner_id))
+        tasks.update_all(:user_id => owner_id)
+        user_locks.where(:resource_id => owner_id).delete_all
+      end
+    end
+  end
+
+  def down
+    User.as_anonymous_admin do
+      ForemanTasks::Task.select(:user_id).distinct.pluck(:user_id).compact.each do |user_id|
+        ForemanTasks::Task.where(:user_id => user_id).select(:id).find_in_batches do |group|
+          group.each { |task| create_lock user_id, task }
+        end
+      end
+    end
+
+    remove_column :foreman_tasks_tasks, :user_id
+  end
+
+  private
+
+  def create_lock(user_id, task)
+    ForemanTasks::Lock.new(:name          => ForemanTasks::Lock::OWNER_LOCK_NAME,
+                           :resource_type => User.name,
+                           :resource_id   => user_id,
+                           :task_id       => task.id,
+                           :exclusive     => false).save!
+  end
+
+  def user_locks
+    ForemanTasks::Lock.where(:name => ForemanTasks::Lock::OWNER_LOCK_NAME)
+  end
+end

data/lib/foreman_tasks/dynflow/persistence.rb

@@ -36,7 +36,6 @@ module ForemanTasks
       when :planning
         task = ::ForemanTasks::Task::DynflowTask.where(:external_id => execution_plan_id).first
         task.update_from_dynflow(data)
-        Lock.owner!(::User.current, task.id) if ::User.current && ::User.current.id.present?
       else
         if (task = ::ForemanTasks::Task::DynflowTask.where(:external_id => execution_plan_id).first)
           unless task.state.to_s == data[:state].to_s

data/lib/foreman_tasks/tasks/export_tasks.rake

@@ -244,7 +244,6 @@ namespace :foreman_tasks do
 
     tasks = ForemanTasks::Task.search_for(filter)
 
-    puts _("Exporting all tasks matching filter #{filter}")
     puts _("Gathering #{tasks.count} tasks.")
     if format == 'html'
       Dir.mktmpdir('task-export') do |tmp_dir|
@@ -256,6 +255,7 @@ namespace :foreman_tasks do
         tasks.each_with_index do |task, count|
           File.open(File.join(tmp_dir, "#{task.id}.html"), 'w') { |file| file.write(PageHelper.pagify(renderer.render_task(task))) }
           puts "#{count + 1}/#{total}"
+          count += 1
         end
 
         File.open(File.join(tmp_dir, 'index.html'), 'w') { |file| file.write(PageHelper.pagify(PageHelper.generate_index(tasks))) }

data/lib/foreman_tasks/version.rb

@@ -1,3 +1,3 @@
 module ForemanTasks
-  VERSION = '0.15.11'.freeze
+  VERSION = '0.16.0'.freeze
 end

data/test/controllers/tasks_controller_test.rb

@@ -41,41 +41,6 @@ module ForemanTasks
           response = JSON.parse(@response.body)
           assert_equal 0, response['stopped']['total']
         end
-
-        describe 'taxonomy scoping' do
-          before do
-            @organizations = [0, 0].map { FactoryBot.create(:organization) }
-            @locations = [0, 0].map { FactoryBot.create(:location) }
-            @tasks = [0, 0].map { FactoryBot.create(:some_task) }
-            @tasks.zip(@organizations, @locations).each do |task, org, loc|
-              Lock.link!(org, task.id)
-              Lock.link!(loc, task.id)
-            end
-          end
-
-          it 'does not limit if unset' do
-            get(:summary, params: { recent_timeframe: 24 }, session: set_session_user)
-            assert_response :success
-            response = JSON.parse(@response.body)
-            assert_equal 2, response['stopped']['total']
-          end
-
-          it 'finds only tasks with matching taxonomies' do
-            get(:summary, params: { recent_timeframe: 24 },
-                          session: set_session_user.merge(:organization_id => @organizations.first, :location_id => @locations.first))
-            assert_response :success
-            response = JSON.parse(@response.body)
-            assert_equal 1, response['stopped']['total']
-          end
-
-          it 'find no tasks when taxonomy combination contains no tasks' do
-            get(:summary, params: { recent_timeframe: 24 },
-                          session: set_session_user.merge(:organization_id => @organizations.first, :location_id => @locations.last))
-            assert_response :success
-            response = JSON.parse(@response.body)
-            assert_equal 0, response['stopped']['total']
-          end
-        end
       end
 
       it 'supports csv export' do
@@ -102,17 +67,6 @@ module ForemanTasks
                           session: set_session_user(User.current)
           assert_response :not_found
         end
-
-        it 'supports csv export' do
-          parent = FactoryBot.create(:some_task, :action => 'Some action')
-          child = FactoryBot.create(:some_task, :action => 'Child action')
-          child.parent_task_id = parent.id
-          child.save!
-          get(:sub_tasks, params: { id: parent.id, format: :csv }, session: set_session_user)
-          assert_response :success
-          assert_equal 2, response.body.lines.size
-          assert_include response.body.lines[1], 'Child action'
-        end
       end
 
       describe 'taxonomy scoping' do