Class: PaperTrailHistory::VersionService

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

Overview

Service class for querying and managing PaperTrail version records

Class Method Summary collapse

Class Method Details

.all_version_classes ⇒ Object 



69
70
71
72
73
74
75
76
77
 
# File 'app/models/paper_trail_history/version_service.rb', line 69

def self.all_version_classes
  @all_version_classes ||= begin
    classes = Set.new
    TrackableModel.all.each do |trackable_model|
      classes.add(trackable_model.version_class)
    end
    classes.to_a
  end
end

.apply_date_range_filter(versions, params) ⇒ Object 



109
110
111
 
# File 'app/models/paper_trail_history/version_service.rb', line 109

def self.apply_date_range_filter(versions, params)
  filter_by_date_range(versions, params[:from_date], params[:to_date])
end

.apply_filters(versions, params) ⇒ Object 



101
102
103
104
105
106
107
 
# File 'app/models/paper_trail_history/version_service.rb', line 101

def self.apply_filters(versions, params)
  versions = filter_by_event(versions, params[:event]) if params[:event].present?
  versions = filter_by_whodunnit(versions, params[:whodunnit]) if params[:whodunnit].present?
  versions = apply_date_range_filter(versions, params) if date_range_params?(params)
  versions = search_object_changes(versions, params[:search]) if params[:search].present?
  versions
end

.apply_record_filters(versions, params) ⇒ Object 



124
125
126
127
128
 
# File 'app/models/paper_trail_history/version_service.rb', line 124

def self.apply_record_filters(versions, params)
  versions = filter_by_event(versions, params[:event]) if params[:event].present?
  versions = apply_date_range_filter(versions, params) if date_range_params?(params)
  versions
end

.available_events(model_name = nil) ⇒ Object 



45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'app/models/paper_trail_history/version_service.rb', line 45

def self.available_events(model_name = nil)
  if model_name
    trackable_model = TrackableModel.find(model_name)
    return [] unless trackable_model

    scope = trackable_model.version_class.where(item_type: trackable_model.item_type_for_versions)
  else
    scope = all_version_classes.flat_map(&:all)
    return scope.map(&:event).compact.uniq.sort
  end

  scope.distinct.pluck(:event).compact.sort
end

.base_versions_for_model(trackable_model) ⇒ Object 



97
98
99
 
# File 'app/models/paper_trail_history/version_service.rb', line 97

def self.base_versions_for_model(trackable_model)
  trackable_model.version_class.where(item_type: trackable_model.item_type_for_versions)
end

.base_versions_for_record(trackable_model, item_id) ⇒ Object 



117
118
119
120
121
122
 
# File 'app/models/paper_trail_history/version_service.rb', line 117

def self.base_versions_for_record(trackable_model, item_id)
  trackable_model.version_class.where(
    item_type: trackable_model.item_type_for_versions,
    item_id: item_id
  )
end

.date_range_params?(params) ⇒ Boolean

Returns:

  • (Boolean) 


113
114
115
 
# File 'app/models/paper_trail_history/version_service.rb', line 113

def self.date_range_params?(params)
  params[:from_date].present? || params[:to_date].present?
end

.filter_by_date_range(versions, from_date, to_date) ⇒ Object 



87
88
89
90
91
 
# File 'app/models/paper_trail_history/version_service.rb', line 87

def self.filter_by_date_range(versions, from_date, to_date)
  versions = versions.where(created_at: Date.parse(from_date)..) if from_date.present?
  versions = versions.where(created_at: ..Date.parse(to_date).end_of_day) if to_date.present?
  versions
end

.filter_by_event(versions, event) ⇒ Object 



79
80
81
 
# File 'app/models/paper_trail_history/version_service.rb', line 79

def self.filter_by_event(versions, event)
  versions.where(event: event)
end

.filter_by_whodunnit(versions, whodunnit) ⇒ Object 



83
84
85
 
# File 'app/models/paper_trail_history/version_service.rb', line 83

def self.filter_by_whodunnit(versions, whodunnit)
  versions.where(whodunnit: whodunnit)
end

.find_version_across_tables(version_id) ⇒ Object 



59
60
61
62
63
64
65
66
67
 
# File 'app/models/paper_trail_history/version_service.rb', line 59

def self.find_version_across_tables(version_id)
  # Try to find the version in all possible version classes, using unscoped to bypass any default scope
  # and/or soft delete mechanism like acts_as_paranoid
  all_version_classes.each do |version_class|
    version = version_class.unscoped.find_by(id: version_id)
    return version if version
  end
  nil
end

.for_model(model_name, params = {}) ⇒ Object 



6
7
8
9
10
11
12
 
# File 'app/models/paper_trail_history/version_service.rb', line 6

def self.for_model(model_name, params = {})
  trackable_model = TrackableModel.find(model_name)
  return PaperTrail::Version.none unless trackable_model

  versions = base_versions_for_model(trackable_model)
  apply_filters(versions, params).order(created_at: :desc)
end

.for_record(model_name, item_id, params = {}) ⇒ Object 



14
15
16
17
18
19
20
 
# File 'app/models/paper_trail_history/version_service.rb', line 14

def self.for_record(model_name, item_id, params = {})
  trackable_model = TrackableModel.find(model_name)
  return PaperTrail::Version.none unless trackable_model

  versions = base_versions_for_record(trackable_model, item_id)
  apply_record_filters(versions, params).order(created_at: :desc)
end

.perform_version_restore(version) ⇒ Object 



140
141
142
143
144
145
146
 
# File 'app/models/paper_trail_history/version_service.rb', line 140

def self.perform_version_restore(version)
  if version.event == 'destroy'
    restore_destroyed_record(version)
  else
    restore_previous_version(version)
  end
end

.restore_destroyed_record(version) ⇒ Object 



148
149
150
151
152
 
# File 'app/models/paper_trail_history/version_service.rb', line 148

def self.restore_destroyed_record(version)
  restored_item = version.reify
  restored_item.save!
  { success: true, item: restored_item, message: I18n.t('paper_trail_history.messages.restore_from_deletion') }
end

.restore_previous_version(version) ⇒ Object 



154
155
156
157
 
# File 'app/models/paper_trail_history/version_service.rb', line 154

def self.restore_previous_version(version)
  version.reify.save!
  { success: true, item: version.item, message: I18n.t('paper_trail_history.messages.restore_to_previous') }
end

.restore_version(version_id) ⇒ Object 



22
23
24
25
26
27
28
29
 
# File 'app/models/paper_trail_history/version_service.rb', line 22

def self.restore_version(version_id)
  version = find_version_across_tables(version_id)
  return validate_version_for_restore(version) unless version_restorable?(version)

  perform_version_restore(version)
rescue StandardError => e
  { success: false, error: e.message }
end

.search_object_changes(versions, search_term) ⇒ Object 



93
94
95
 
# File 'app/models/paper_trail_history/version_service.rb', line 93

def self.search_object_changes(versions, search_term)
  versions.where('object_changes LIKE ? OR object LIKE ?', "%#{search_term}%", "%#{search_term}%")
end

.unique_whodunnits(model_name = nil) ⇒ Object 



31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'app/models/paper_trail_history/version_service.rb', line 31

def self.unique_whodunnits(model_name = nil)
  if model_name
    trackable_model = TrackableModel.find(model_name)
    return [] unless trackable_model

    scope = trackable_model.version_class.where(item_type: trackable_model.item_type_for_versions)
  else
    scope = all_version_classes.flat_map(&:all)
    return scope.map(&:whodunnit).compact.uniq.sort
  end

  scope.distinct.pluck(:whodunnit).compact.sort
end

.validate_version_for_restore(version) ⇒ Object 



134
135
136
137
138
 
# File 'app/models/paper_trail_history/version_service.rb', line 134

def self.validate_version_for_restore(version)
  return { success: false, error: I18n.t('paper_trail_history.errors.version_not_found') } unless version

  { success: false, error: I18n.t('paper_trail_history.errors.cannot_restore_create') }
end

.version_restorable?(version) ⇒ Boolean

Returns:

  • (Boolean) 


130
131
132
 
# File 'app/models/paper_trail_history/version_service.rb', line 130

def self.version_restorable?(version)
  version && version.event != 'create'
end