persistence superclass

persistence.rb

require 'pp'
require_relative './aggregate_pointer.rb'


class Persistence

  #---------------------------
  # class methods 
  #---------------------------
  


  def self.required

    'required'
  end
  def self.type 

    'type'
  end
  def self.location

    'location'
  end
  def self.local 

    'local'
  end
  def self.remote 

    'remote'
  end
  def self.load_from_hash the_class, data_hash 
     object =  the_class.new
     object.set_data  data_hash
     object
  end

 



  #---------------------------
  # instance methods 
  #---------------------------

  def initialize  fields
    @fields = fields
    @aggregate_info_set = false
    @data = Hash.new
  end

  def set_data data_hash
    if @aggregate_info_set == false 
      @aggregate_info_set = true
      @data = data_hash
    end
  end 

  def get_data name 
    if @fields[name][Persistence.location] == Persistence.local
      @data[name]
    else 
      if @data[name].class == Hash  
        cls = @fields[name][Persistence.type]
        cls.load_from_hash(cls, Aggregates.get_by_aggregate_id( @data[name]['aggregate_id']))
      end
    end
  end
 
  def method_missing(nm, *args)
    name = nm.to_s
    if name.end_with?('=') == false 
      if @data[name]
        get_data name 
      else 
        super
      end
    else
      field_name = name.gsub(/\=/,'')
      @data[field_name] = args.last
    end
  end

  def aggregate_lookup_value
  
    @data['aggregate_lookup_value']
  end

  def aggregate_id 
    
    @data['aggregate_info']['aggregate_id']
  end

  def aggregate_type
    
    @data['aggregate_info']['aggregate_type']
  end

  def to_h 

    @data
  end

  def verify_data  
    @data_errors = []
    data_ok = true
    @fields.each do |field_name, field_info|
      if @data[field_name.to_s].nil? && field_info[Persistence.required] == true
        data_ok = false
        @data_errors << "#{field_name}: required field is missing."
      end
      
      if field_info[Persistence.location] == Persistence.local
        if @data[field_name.to_s] && (@data[field_name].class != field_info[Persistence.type])
          data_ok = false 
          @data_errors << "#{field_name}: expected type: #{field_info[Persistence.type].name},   but received type #{@data[field_name].class.name}."
        end
      elsif field_info[Persistence.location] == Persistence.remote
        if @data[field_name.to_s] && (@data[field_name].class != AggregatePointer)
           @data_errors << "#{field_name}: remote field expected type AggregatePointer,   but received type #{@data[field_name].class.name}."
        end
      else
        raise Exception.new ("location was neither local nor remote.")
      end
    end
    data_ok
  end

  def data_errors
    verify_data
    @data_errors
  end

  def valid?

    verify_data 
  end

  def aggregate_pointer
   x = AggregatePointer.new(aggregate_type, aggregate_id)
   x
  end

  def get_checksum
    data = Array.new
    @data.keys.select {|x| x != 'aggregate_info'}.each {|x| data <<  @data[x] }
    sha = Digest::SHA2.new
    sha.update(data.join())
    sha.to_s
  end



end