trabajo-afectivo/app/models/history.rb

# Copyright (C) 2012-2014 Zammad Foundation, http://zammad-foundation.org/

class History < ApplicationModel
  load 'history/assets.rb'
  include History::Assets

  self.table_name = 'histories'
  belongs_to :history_type,             class_name: 'History::Type'
  belongs_to :history_object,           class_name: 'History::Object'
  belongs_to :history_attribute,        class_name: 'History::Attribute'
  #  before_validation :check_type, :check_object
  #  attr_writer :history_type, :history_object

  # rubocop:disable Style/ClassVars
  @@cache_type = {}
  @@cache_object = {}
  @@cache_attribute = {}
# rubocop:enable Style/ClassVars

=begin

add a new history entry for an object

  History.add(
    :history_type      => 'updated',
    :history_object    => 'Ticket',
    :history_attribute => 'state',
    :o_id              => ticket.id,
    :id_to             => 3,
    :id_from           => 2,
    :value_from        => 'open',
    :value_to          => 'pending reminder',
    :created_by_id     => 1,
    :created_at        => '2013-06-04 10:00:00',
    :updated_at        => '2013-06-04 10:00:00'
  )

=end

  def self.add(data)

    # return if we run import mode
    return if Setting.get('import_mode') && !data[:id]

    # lookups
    if data[:history_type]
      history_type = type_lookup( data[:history_type] )
    end
    if data[:history_object]
      history_object = object_lookup( data[:history_object] )
    end
    related_history_object_id = nil
    if data[:related_history_object]
      related_history_object = object_lookup( data[:related_history_object] )
      related_history_object_id = related_history_object.id
    end
    history_attribute_id = nil
    if data[:history_attribute]
      history_attribute = attribute_lookup( data[:history_attribute] )
      history_attribute_id = history_attribute.id
    end

    # create history
    record = {
      id: data[:id],
      o_id: data[:o_id],
      history_type_id: history_type.id,
      history_object_id: history_object.id,
      history_attribute_id: history_attribute_id,
      related_history_object_id: related_history_object_id,
      related_o_id: data[:related_o_id],
      value_from: data[:value_from],
      value_to: data[:value_to],
      id_from: data[:id_from],
      id_to: data[:id_to],
      created_at: data[:created_at],
      created_by_id: data[:created_by_id]
    }
    history_record = nil
    if data[:id]
      history_record = History.find_by( id: data[:id] )
    end
    if history_record
      history_record.update_attributes(record)
    else
      record_new = History.create(record)
      if record[:id]
        record_new.id = record[:id]
      end
      record_new.save
    end
  end

=begin

remove whole history entries of an object

  History.remove( 'Ticket', 123 )

=end

  def self.remove( requested_object, requested_object_id )
    history_object = History::Object.find_by( name: requested_object )
    return if !history_object
    History.where(
      history_object_id: history_object.id,
      o_id: requested_object_id,
    ).destroy_all
  end

=begin

return all history entries of an object

  history_list = History.list( 'Ticket', 123 )

returns

  history_list = [
    { ... },
    { ... },
    { ... },
    { ... },
  ]

return all history entries of an object and it's related history objects

  history_list = History.list( 'Ticket', 123, true )

returns

  history_list = [
    { ... },
    { ... },
    { ... },
    { ... },
  ]

return all history entries of an object and it's assets

  history = History.list( 'Ticket', 123, nil, true )

returns

  history = {
    :list   => list,
    :assets => assets,
  }

=end

  def self.list( requested_object, requested_object_id, related_history_object = nil, assets = nil )
    if !related_history_object
      history_object = object_lookup( requested_object )
      history = History.where( history_object_id: history_object.id )
                       .where( o_id: requested_object_id )
                       .order('created_at ASC, id ASC')
    else
      history_object_requested = object_lookup( requested_object )
      history_object_related   = object_lookup( related_history_object )
      history = History.where(
        '((history_object_id = ? AND o_id = ?) OR (history_object_id = ? AND related_o_id = ? ))',
        history_object_requested.id,
        requested_object_id,
        history_object_related.id,
        requested_object_id,
      )
                       .order('created_at ASC, id ASC')
    end
    asset_list = {}
    list = []
    history.each do |item|

      if assets
        asset_list = item.assets( asset_list )
      end

      data = item.attributes
      data['object']    = object_lookup_id( data['history_object_id'] ).name
      data['type']      = type_lookup_id( data['history_type_id'] ).name
      data.delete('history_object_id')
      data.delete('history_type_id')

      if data['history_attribute_id']
        data['attribute'] = attribute_lookup_id( data['history_attribute_id'] ).name
      end
      data.delete('history_attribute_id')

      data.delete( 'updated_at' )
      if data['id_to'].nil? && data['id_from'].nil?
        data.delete( 'id_to' )
        data.delete( 'id_from' )
      end
      if data['value_to'].nil? && data['value_from'].nil?
        data.delete( 'value_to' )
        data.delete( 'value_from' )
      end
      if !data['related_history_object_id'].nil?
        data['related_object'] = object_lookup_id( data['related_history_object_id'] ).name
      end
      data.delete( 'related_history_object_id' )

      if data['related_o_id'].nil?
        data.delete( 'related_o_id' )
      end

      list.push data
    end
    if assets
      return {
        list: list,
        assets: asset_list,
      }
    end
    list
  end

  def self.type_lookup_id( id )

    # use cache
    return @@cache_type[ id ] if @@cache_type[ id ]

    # lookup
    history_type = History::Type.lookup( id: id )
    @@cache_type[ id ] = history_type
    history_type
  end

  def self.type_lookup( name )

    # use cache
    return @@cache_type[ name ] if @@cache_type[ name ]

    # lookup
    history_type = History::Type.lookup( name: name )
    if history_type
      @@cache_type[ name ] = history_type
      return history_type
    end

    # create
    history_type = History::Type.create(
      name: name
    )
    @@cache_type[ name ] = history_type
    history_type
  end

  def self.object_lookup_id( id )

    # use cache
    return @@cache_object[ id ] if @@cache_object[ id ]

    # lookup
    history_object = History::Object.lookup( id: id )
    @@cache_object[ id ] = history_object
    history_object
  end

  def self.object_lookup( name )

    # use cache
    return @@cache_object[ name ] if @@cache_object[ name ]

    # lookup
    history_object = History::Object.lookup( name: name )
    if history_object
      @@cache_object[ name ] = history_object
      return history_object
    end

    # create
    history_object = History::Object.create(
      name: name
    )
    @@cache_object[ name ] = history_object
    history_object
  end

  def self.attribute_lookup_id( id )

    # use cache
    return @@cache_attribute[ id ] if @@cache_attribute[ id ]

    # lookup
    history_attribute = History::Attribute.lookup( id: id )
    @@cache_attribute[ id ] = history_attribute
    history_attribute
  end

  def self.attribute_lookup( name )

    # use cache
    return @@cache_attribute[ name ] if @@cache_attribute[ name ]

    # lookup
    history_attribute = History::Attribute.lookup( name: name )
    if history_attribute
      @@cache_attribute[ name ] = history_attribute
      return history_attribute
    end

    # create
    history_attribute = History::Attribute.create(
      name: name
    )
    @@cache_attribute[ name ] = history_attribute
    history_attribute
  end

  private

=begin

nothing to do on destroying history entries

=end

  def destroy_dependencies
  end

  class Object < ApplicationModel
  end

  class Type < ApplicationModel
  end

  class Attribute < ApplicationModel
  end

end