Class: Katello::ContentViewVersion

Inherits:
Model
  • Object
show all
Includes:
ForemanTasks::Concerns::ActionSubject, Authorization::ContentViewVersion
Defined in:
app/models/katello/content_view_version.rb

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Model

#destroy!

Class Method Details

.component_of(versions) ⇒ Object 



67
68
69
 
# File 'app/models/katello/content_view_version.rb', line 67

def self.component_of(versions)
  joins(:content_view_version_composites).where("#{Katello::ContentViewVersionComponent.table_name}.composite_version_id" => versions)
end

.find_by_version(_key, operator, value) ⇒ Object 



49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'app/models/katello/content_view_version.rb', line 49

def self.find_by_version(_key, operator, value)
  conditions = ""
  if ['>', '<', '=', '<=', '>=', "<>", "!=", 'IN', 'NOT IN'].include?(operator) && value.to_f >= 0
    major, minor = value.split(".")
    case
    when /[<>]/ =~ operator
      minor ||= 0
      query = where("major #{operator} :major OR (major = :major AND minor #{operator} :minor)", :major => major, :minor => minor)
    when minor.nil?
      query = where("major #{operator} (:major)", :major => major)
    else
      query = where("major #{operator} (:major) and minor #{operator} (:minor)", :major => major, :minor => minor)
    end
    _, conditions = query.to_sql.split("WHERE")
  end
  { :conditions => conditions }
end

.for_version(version) ⇒ Object 



75
76
77
78
79
80
 
# File 'app/models/katello/content_view_version.rb', line 75

def self.for_version(version)
  major, minor = version.to_s.split('.')
  minor ||= 0
  query = where(:major => major, :minor => minor)
  query
end

.in_environment(env) ⇒ Object 



167
168
169
 
# File 'app/models/katello/content_view_version.rb', line 167

def self.in_environment(env)
  joins(:content_view_environments).where("#{Katello::ContentViewEnvironment.table_name}.environment_id" => env)
end

.with_library_repo(repo) ⇒ Object 



71
72
73
 
# File 'app/models/katello/content_view_version.rb', line 71

def self.with_library_repo(repo)
  joins(:repositories).where("#{Katello::Repository.table_name}.library_instance_id" => repo)
end

.with_puppet_module(puppet_module) ⇒ Object 



82
83
84
85
 
# File 'app/models/katello/content_view_version.rb', line 82

def self.with_puppet_module(puppet_module)
  joins(:content_view_puppet_environments)
    .where("#{Katello::ContentViewPuppetEnvironment.table_name}.id = ?", puppet_module.content_view_puppet_environments)
end

Instance Method Details

#active_history ⇒ Object 



93
94
95
 
# File 'app/models/katello/content_view_version.rb', line 93

def active_history
  self.history.select { |history| history.task.try(:pending) }
end

#archive_puppet_environment ⇒ Object 



188
189
190
 
# File 'app/models/katello/content_view_version.rb', line 188

def archive_puppet_environment
  content_view_puppet_environments.archived.first
end

#archived_repos ⇒ Object 



137
138
139
 
# File 'app/models/katello/content_view_version.rb', line 137

def archived_repos
  self.default? ? self.repositories : self.repos(nil)
end

#available_releases ⇒ Object 



117
118
119
 
# File 'app/models/katello/content_view_version.rb', line 117

def available_releases
  self.repositories.pluck(:minor).compact.uniq.sort
end

#check_ready_to_promote!(to_env) ⇒ Object 



263
264
265
266
 
# File 'app/models/katello/content_view_version.rb', line 263

def check_ready_to_promote!(to_env)
  fail _("Default content view versions cannot be promoted") if default?
  content_view.check_composite_action_allowed!(to_env)
end

#components_needing_errata(errata) ⇒ Object 



200
201
202
203
204
205
 
# File 'app/models/katello/content_view_version.rb', line 200

def components_needing_errata(errata)
  component_repos = Repository.where(:content_view_version_id => self.components)
  library_repos = Repository.where(:id => component_repos.pluck(:library_instance_id)).with_errata(errata)
  component_repos -= component_repos.with_errata(errata) #find component repos without the errata
  component_repos.select { |repo| library_repos.include?(repo.library_instance) }.map(&:content_view_version).uniq
end

#default_content_view? ⇒ Boolean

Returns:

  • (Boolean) 


105
106
107
 
# File 'app/models/katello/content_view_version.rb', line 105

def default_content_view?
  default?
end

#deletable?(from_env) ⇒ Boolean

Returns:

  • (Boolean) 


179
180
181
182
 
# File 'app/models/katello/content_view_version.rb', line 179

def deletable?(from_env)
  !System.exists?(:environment_id => from_env, :content_view_id => self.content_view) ||
      self.content_view.versions.in_environment(from_env).count > 1
end

#docker_manifest_count ⇒ Object 



223
224
225
226
227
228
 
# File 'app/models/katello/content_view_version.rb', line 223

def docker_manifest_count
  manifest_counts = repositories.archived.docker_type.map do |repo|
    repo.docker_manifests.count
  end
  manifest_counts.sum
end

#docker_manifests ⇒ Object 



251
252
253
 
# File 'app/models/katello/content_view_version.rb', line 251

def docker_manifests
  DockerManifest.in_repositories(archived_repos).uniq
end

#docker_tag_count ⇒ Object 



234
235
236
237
238
239
 
# File 'app/models/katello/content_view_version.rb', line 234

def docker_tag_count
  tag_counts = repositories.archived.docker_type.map do |repo|
    repo.docker_tags.count
  end
  tag_counts.sum
end

#docker_tags ⇒ Object 



230
231
232
 
# File 'app/models/katello/content_view_version.rb', line 230

def docker_tags
  archived_repos.docker_type.flat_map(&:docker_tags)
end

#errata(errata_type = nil) ⇒ Object 



241
242
243
244
245
 
# File 'app/models/katello/content_view_version.rb', line 241

def errata(errata_type = nil)
  errata = Erratum.in_repositories(archived_repos).uniq
  errata = errata.of_type(errata_type) if errata_type
  errata
end

#get_repo_clone(env, repo) ⇒ Object 



162
163
164
165
 
# File 'app/models/katello/content_view_version.rb', line 162

def get_repo_clone(env, repo)
  lib_id = repo.library_instance_id || repo.id
  self.repos(env).where("#{Katello::Repository.table_name}.library_instance_id" => lib_id)
end

#in_composite? ⇒ Boolean

Returns:

  • (Boolean) 


109
110
111
 
# File 'app/models/katello/content_view_version.rb', line 109

def in_composite?
  composite_content_views.any?
end

#in_environment? ⇒ Boolean

Returns:

  • (Boolean) 


113
114
115
 
# File 'app/models/katello/content_view_version.rb', line 113

def in_environment?
  environments.any?
end

#last_event ⇒ Object 



97
98
99
 
# File 'app/models/katello/content_view_version.rb', line 97

def last_event
  self.history.order(:created_at).last
end

#name ⇒ Object 



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

def name
  "#{content_view} #{version}"
end

#next_incremental_version ⇒ Object 



121
122
123
 
# File 'app/models/katello/content_view_version.rb', line 121

def next_incremental_version
  "#{major}.#{minor + 1}"
end

#non_archive_repos ⇒ Object 



141
142
143
 
# File 'app/models/katello/content_view_version.rb', line 141

def non_archive_repos
  self.repositories.non_archived
end

#ostree_branch_count ⇒ Object 



219
220
221
 
# File 'app/models/katello/content_view_version.rb', line 219

def ostree_branch_count
  ostree_branches.count
end

#ostree_branches ⇒ Object 



247
248
249
 
# File 'app/models/katello/content_view_version.rb', line 247

def ostree_branches
  OstreeBranch.in_repositories(archived_repos).uniq
end

#package_count ⇒ Object 



215
216
217
 
# File 'app/models/katello/content_view_version.rb', line 215

def package_count
  Katello::Rpm.in_repositories(self.repositories.archived).count
end

#package_group_count ⇒ Object 



259
260
261
 
# File 'app/models/katello/content_view_version.rb', line 259

def package_group_count
  package_groups.count
end

#package_groups ⇒ Object 



255
256
257
 
# File 'app/models/katello/content_view_version.rb', line 255

def package_groups
  PackageGroup.in_repositories(archived_repos).uniq
end

#packages ⇒ Object 



207
208
209
 
# File 'app/models/katello/content_view_version.rb', line 207

def packages
  Rpm.in_repositories(archived_repos).uniq
end

#products(env = nil) ⇒ Object 



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

def products(env = nil)
  if env
    repos(env).map(&:product).uniq(&:id)
  else
    self.repositories.map(&:product).uniq(&:id)
  end
end

#promotable?(environment) ⇒ Boolean

Returns:

  • (Boolean) 


184
185
186
 
# File 'app/models/katello/content_view_version.rb', line 184

def promotable?(environment)
  environments.include?(environment.prior) || environments.empty? && environment == organization.library
end

#puppet_env(env) ⇒ Object 



133
134
135
 
# File 'app/models/katello/content_view_version.rb', line 133

def puppet_env(env)
  self.content_view_puppet_environments.in_environment(env).first
end

#puppet_module_count ⇒ Object 



211
212
213
 
# File 'app/models/katello/content_view_version.rb', line 211

def puppet_module_count
  puppet_modules.count
end

#puppet_modules ⇒ Object 



192
193
194
195
196
197
198
 
# File 'app/models/katello/content_view_version.rb', line 192

def puppet_modules
  if archive_puppet_environment
    archive_puppet_environment.puppet_modules
  else
    []
  end
end

#removable? ⇒ Boolean

Returns:

  • (Boolean) 


171
172
173
174
175
176
177
 
# File 'app/models/katello/content_view_version.rb', line 171

def removable?
  if environments.blank?
    content_view.promotable_or_removable?
  else
    content_view.promotable_or_removable? && KTEnvironment.where(:id => environments).any_promotable?
  end
end

#repos(env) ⇒ Object 



129
130
131
 
# File 'app/models/katello/content_view_version.rb', line 129

def repos(env)
  self.repositories.in_environment(env)
end

#repos_ordered_by_product(env) ⇒ Object 



153
154
155
156
157
158
159
160
 
# File 'app/models/katello/content_view_version.rb', line 153

def repos_ordered_by_product(env)
  # The repository model has a default scope that orders repositories by name;
  # however, for content views, it is desirable to order the repositories
  # based on the name of the product the repository is part of.
  Repository.send(:with_exclusive_scope) do
    self.repositories.joins(:product).in_environment(env).order("#{Katello::Product.table_name}.name asc")
  end
end

#to_s ⇒ Object 



87
88
89
 
# File 'app/models/katello/content_view_version.rb', line 87

def to_s
  name
end

#validate_destroyable!(skip_environment_check = false) ⇒ Object 



268
269
270
271
272
273
274
275
276
277
278
279
280
281
 
# File 'app/models/katello/content_view_version.rb', line 268

def validate_destroyable!(skip_environment_check = false)
  unless organization.being_deleted?
    if !skip_environment_check && in_environment?
      fail _("Cannot delete version while it is in environments: %s") %
               environments.map(&:name).join(",")
    end

    if in_composite?
      fail _("Cannot delete version while it is in use by composite content views: %s") %
               composite_content_views.map(&:name).join(",")
    end
  end
  true
end

#version ⇒ Object 



125
126
127
 
# File 'app/models/katello/content_view_version.rb', line 125

def version
  "#{major}.#{minor}"
end