Class: JobInvocationComposer::ApiParams

Inherits:
Object
  • Object
show all
Defined in:
app/models/job_invocation_composer.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(api_params) ⇒ ApiParams

Returns a new instance of ApiParams.



101
102
103
 
# File 'app/models/job_invocation_composer.rb', line 101

def initialize(api_params)
  @api_params = api_params
end

Instance Attribute Details

#api_params ⇒ Object (readonly)

Returns the value of attribute api_params.



99
100
101
 
# File 'app/models/job_invocation_composer.rb', line 99

def api_params
  @api_params
end

Instance Method Details

#concurrency_control_params ⇒ Object 



145
146
147
148
149
150
 
# File 'app/models/job_invocation_composer.rb', line 145

def concurrency_control_params
  {
    :level => api_params.fetch(:concurrency_control, {})[:concurrency_level],
    :time_span => api_params.fetch(:concurrency_control, {})[:time_span],
  }
end

#filter_provider_inputs(api_params) ⇒ Object 



166
167
168
169
170
171
 
# File 'app/models/job_invocation_composer.rb', line 166

def filter_provider_inputs(api_params)
  return [] if template.provider.provider_input_namespace.empty?
  inputs = api_params[template.provider.provider_input_namespace].to_h
  provider_input_names = template.provider.provider_inputs.map(&:name)
  inputs.select { |key, value| provider_input_names.include? key }.map { |key, value| { :name => key, :value => value } }
end

#params ⇒ Object 



105
106
107
108
109
110
111
112
113
114
 
# File 'app/models/job_invocation_composer.rb', line 105

def params
  { :job_category => template.job_category,
    :targeting => targeting_params,
    :triggering => triggering_params,
    :description_format => api_params[:description_format],
    :remote_execution_feature_id => api_params[:remote_execution_feature_id],
    :concurrency_control => concurrency_control_params,
    :execution_timeout_interval => api_params[:execution_timeout_interval] || template.execution_timeout_interval,
    :template_invocations => template_invocations_params }.with_indifferent_access
end

#targeting_params ⇒ Object

Raises:

  • (::Foreman::Exception) 


116
117
118
119
120
 
# File 'app/models/job_invocation_composer.rb', line 116

def targeting_params
  raise ::Foreman::Exception, _('Cannot specify both bookmark_id and search_query') if api_params[:bookmark_id] && api_params[:search_query]

  api_params.slice(:targeting_type, :bookmark_id, :search_query, :randomized_ordering).merge(:user_id => User.current.id)
end

#template ⇒ Object 



173
174
175
 
# File 'app/models/job_invocation_composer.rb', line 173

def template
  @template ||= JobTemplate.authorized(:view_job_templates).find(api_params[:job_template_id])
end

#template_invocations_params ⇒ Object 



152
153
154
155
156
157
158
159
160
161
162
163
164
 
# File 'app/models/job_invocation_composer.rb', line 152

def template_invocations_params
  template_invocation_params = { :template_id => template.id, :effective_user => api_params[:effective_user] }
  template_invocation_params[:provider_input_values] = filter_provider_inputs api_params
  template_invocation_params[:input_values] = api_params.fetch(:inputs, {}).to_h.map do |name, value|
    input = template.template_inputs_with_foreign.find { |i| i.name == name }
    unless input
      raise ::Foreman::Exception, _('Unknown input %{input_name} for template %{template_name}') %
          { :input_name => name, :template_name => template.name }
    end
    { :template_input_id => input.id, :value => value }
  end
  [template_invocation_params]
end

#triggering_params ⇒ Object

Raises:

  • (::Foreman::Exception) 


122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
 
# File 'app/models/job_invocation_composer.rb', line 122

def triggering_params
  raise ::Foreman::Exception, _('Cannot specify both recurrence and scheduling') if api_params[:recurrence].present? && api_params[:scheduling].present?

  if api_params[:recurrence].present?
    {
      :mode => :recurring,
      :cronline => api_params[:recurrence][:cron_line],
      :end_time => format_datetime(api_params[:recurrence][:end_time]),
      :input_type => :cronline,
      :max_iteration => api_params[:recurrence][:max_iteration],
    }
  elsif api_params[:scheduling].present?
    {
      :mode => :future,
      :start_at_raw => format_datetime(api_params[:scheduling][:start_at]),
      :start_before_raw => format_datetime(api_params[:scheduling][:start_before]),
      :end_time_limited => api_params[:scheduling][:start_before] ? true : false,
    }
  else
    {}
  end
end