Module: ActiveVersion::Query

Defined in:
lib/active_version/query.rb

Overview

Unified query builder for version records

Class Method Summary collapse

Class Method Details

.audits(record, opts = {}) ⇒ ActiveRecord::Relation

Query audits for a record

Parameters:

  • record (ActiveRecord::Base) —

    The record to query audits for

  • opts (Hash) (defaults to: {}) —

    Query options

Options Hash (opts):

  • :preload (Array) —

    Associations to preload

  • :order_by (Hash) —

    Order specification

Returns:

  • (ActiveRecord::Relation) —

    Audit relation



11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/active_version/query.rb', line 11

def audits(record, opts = {})
  audit_class = record.class.audit_class
  return audit_class.none unless audit_class

  auditable_column = ActiveVersion.column_mapper.column_for(record.class, :audits, :auditable)
  identity_map = if record.respond_to?(:active_version_audit_identity_map)
    record.active_version_audit_identity_map
  else
    primary_keys = Array(record.class.primary_key).map(&:to_s)
    if primary_keys.one?
      {"#{auditable_column}_id" => record.id}
    else
      primary_keys.zip(primary_keys.map { |column| record[column] }).to_h
    end
  end

  query = audit_class.where({"#{auditable_column}_type" => record.class.name}.merge(identity_map))

  query = query.preload(opts[:preload]) if opts[:preload]
  query = query.order(opts[:order_by]) if opts[:order_by]

  query
end

.revisions(record, opts = {}) ⇒ ActiveRecord::Relation

Query revisions for a record

Parameters:

  • record (ActiveRecord::Base) —

    The record to query revisions for

  • opts (Hash) (defaults to: {}) —

    Query options

Options Hash (opts):

  • :version (Integer) —

    Version number to filter by

Returns:

  • (ActiveRecord::Relation) —

    Revision relation



70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
 
# File 'lib/active_version/query.rb', line 70

def revisions(record, opts = {})
  revision_class = record.class.revision_class
  return revision_class.none unless revision_class

  identity_map = if record.respond_to?(:active_version_revision_identity_map)
    record.active_version_revision_identity_map
  else
    keys = Array(revision_class.source_foreign_key).map(&:to_s)
    if keys.one?
      {keys.first => record.id}
    else
      values = Array(record.class.primary_key).map { |column| record[column] }
      keys.zip(values).to_h
    end
  end
  query = revision_class.where(identity_map)

  if opts[:version]
    version_column = ActiveVersion.column_mapper.column_for(record.class, :revisions, :version)
    query = query.where(version_column => opts[:version])
  end

  version_column = ActiveVersion.column_mapper.column_for(record.class, :revisions, :version)
  query.order(version_column => :asc)
end

.translations(record, opts = {}) ⇒ ActiveRecord::Relation

Query translations for a record

Parameters:

  • record (ActiveRecord::Base) —

    The record to query translations for

  • opts (Hash) (defaults to: {}) —

    Query options

Options Hash (opts):

  • :locale (String, Symbol) —

    Locale to filter by

Returns:

  • (ActiveRecord::Relation) —

    Translation relation



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/active_version/query.rb', line 40

def translations(record, opts = {})
  translation_class = record.class.translation_class
  return translation_class.none unless translation_class

  identity_map = if record.respond_to?(:active_version_translation_identity_map)
    record.active_version_translation_identity_map
  else
    keys = Array(translation_class.source_foreign_key).map(&:to_s)
    if keys.one?
      {keys.first => record.id}
    else
      values = Array(record.class.primary_key).map { |column| record[column] }
      keys.zip(values).to_h
    end
  end
  query = translation_class.where(identity_map)

  if opts[:locale]
    locale_column = ActiveVersion.column_mapper.column_for(record.class, :translations, :locale)
    query = query.where(locale_column => opts[:locale])
  end

  query
end