command_post 0.0.1

data/lib/command_post/identity/sequence_generator.rb

@@ -0,0 +1,44 @@
+require 'securerandom'
+require 'sequel'
+
+
+require_relative '../db/connection.rb'
+
+
+module CommandPost
+
+  class SequenceGenerator
+
+
+    def self.aggregate_id
+      @@DB ||= Connection.db_cqrs
+      val = 0
+      @@DB.fetch("SELECT nextval('aggregate');") do |row|
+        val = row[row.keys.first]
+      end
+      val
+    end
+
+    def self.transaction_id
+      @@DB ||= Connection.db_cqrs
+      val = 0
+      @@DB.fetch("SELECT nextval('transaction');") do |row|
+        val = row[row.keys.first]
+      end
+      val
+    end
+
+    def self.misc
+      @@DB ||= Connection.db_cqrs
+      val = 0
+      @@DB.fetch("SELECT nextval('misc');") do |row|
+        val = row[row.keys.first]
+      end
+      val
+    end
+
+  end
+
+end
+
+ 

data/lib/command_post/persistence/aggregate_pointer.rb

@@ -0,0 +1,18 @@
+
+module CommandPost
+
+
+  class AggregatePointer  < Hash
+    attr_accessor :aggregate_type, :aggregate_id
+    
+    def initialize hash
+        @aggregate_type =         hash[:aggregate_type]
+        @aggregate_id =           hash[:aggregate_id]
+        self[:aggregate_type] =  hash[:aggregate_type]
+        self[:aggregate_id] =    hash[:aggregate_id]
+        self[:class_name] =      'AggregatePointer'
+    end 
+
+  end
+
+end

data/lib/command_post/persistence/auto_load.rb

@@ -0,0 +1,70 @@
+require_relative '../util/hash_util'
+
+module CommandPost
+
+  module AutoLoad
+
+    def auto_load_fields
+
+      schema_fields.select {|key, value| value[:auto_load] == true }.keys
+    end
+    
+
+    def local_peristent_fields
+
+      schema_fields.select {|key, value| value[:location] == :local && value[:type].superclass == Persistence }.keys
+    end
+
+
+    def populate_auto_load_fields 
+      auto_load_fields.select {|x| @data.keys.include? x}.each do |field|
+        if @data[field].class == Array
+          if schema_fields[field][:location] == :remote
+            array_of_objects = Array.new 
+            array_of_pointers = @data[field]
+            array_of_pointers.each do |pointer|
+              if pointer.respond_to? :aggregate_pointer
+                pointer = pointer.aggregate_pointer
+              end
+              obj =  Aggregate.get_by_aggregate_id(Object.const_get(pointer[:aggregate_type]), pointer[:aggregate_id])
+              array_of_objects << obj
+            end
+            array_of_pointers.clear
+            @data[field].clear
+            @data[field] += array_of_objects
+          end
+        else
+          @data[field] = Aggregate.get_by_aggregate_id( schema_fields[field][:type], @data[field][:aggregate_id])
+        end
+      end
+    end
+
+    
+    def to_pretty_pp
+      len = 0
+      result  = ''
+      @data.keys.map{|key| len = key.length if (key.length > len) }
+
+      @data.keys.reject{|key| /aggregate/.match key}.each do |key|
+        label = "%#{len}s :" % key
+        if auto_load_fields.include? key 
+          result += "\n#{label} (remote object)"
+          result += (@data[key]).to_s
+        else
+          result +=  "#{label} #{@data[key]}"
+        end
+      end
+      result
+    end
+
+
+    def populate_local_persistent_objects
+      local_peristent_fields.each do |field|
+        klass = schema_fields[field][:type]
+        @data[field] = klass.load_from_hash klass, HashUtil.symbolize_keys(@data[field])
+        @data[field].populate_local_persitent_objects
+      end
+    end  
+
+  end
+end

data/lib/command_post/persistence/data_validation.rb

@@ -0,0 +1,113 @@
+
+
+
+module CommandPost
+
+  module DataValidation
+
+    def empty?
+
+      @data.nil? || @data == {}
+    end
+
+    def valid?
+      
+      verify_data.length == 0 
+    end
+
+    def data_errors
+
+      verify_data
+    end
+    
+    def verify_data  
+
+      errors = Array.new 
+
+      schema_fields.each do |field_name, field_info|
+        if missing_required_field(field_name, field_info) 
+
+          errors << "#{self.class}:#{field_name} - is a required field." 
+        end
+        if data_type_does_not_match_declaration(field_name, field_info) 
+
+          errors << "#{self.class}: #{field_name}: expected type: #{field_info[:type].name}, but received type #{@data[field_name].class.name}."  
+        end 
+        if allowed_values_declared_but_array_of_values_not_supplied(field_name, field_info) 
+
+          errors << "#{self.class}: #{field_name}: expected type: #{field_info[:type].name}, but received type #{@data[field_name].class.name}."  
+        end 
+        if value_not_among_the_list_of_allowed_values(field_name, field_info) 
+
+          errors << "#{self.class}: #{field_name}: The value supplied was not in the list of acceptable values."
+        end
+        if type_is_array_but_keyword___of___not_supplied(field_name, field_info)
+
+          errors << "#{self.class}: #{field_name}: is an Array, but the ':of' keyword was not set to declare the class type for objects in the array."
+        end 
+        if accepted_values_supplied_but_they_are_not_all_the_same_type(field_name, field_info)
+          
+          errors << "#{self.class}: #{field_name} is an Array and all objects should be of type #{expected_type} but one object was of type #{object_in_array.class}."
+        end
+        if field_is_array_of_remote_objects_but_array_has_values_other_than_persistence_or_identity(field_name, field_info)
+     
+          errors << "#{self.class}: #{field_name} is an Array and all objects should be of type #{expected_type} but one object was of type #{object_in_array.class} or of AggregatePointer." 
+        end
+      end
+      errors 
+    end
+
+    def missing_required_field field_name, field_info
+      puts "field_name is #{field_name} and has class of #{field_name.class}"
+      @data.keys.include?(field_name)==false && field_info[:required] == true
+    end
+
+    def data_type_does_not_match_declaration field_name, field_info
+
+      @data[field_name] != nil  &&  (@data[field_name].class !=  field_info[:type])
+    end
+
+    def allowed_values_declared_but_array_of_values_not_supplied field_name, field_info 
+
+      (@data[field_name] != nil)  &&  (@data[field_name].class !=  Array)  &&  (field_info[:allowed_values])  &&  (field_info[:allowed_values].class != Array) 
+    end
+
+    def value_not_among_the_list_of_allowed_values field_name, field_info
+
+      (@data[field_name] != nil)  &&  (@data[field_name].class !=  Array)  &&  (field_info[:allowed_values])  &&  (field_info[:allowed_values].include?(@data[field_name]) == false  )
+    end
+
+    def type_is_array_but_keyword___of___not_supplied field_name, field_info
+
+      (@data[field_name.to_s] != nil) && (@data[field_name].class == Array) && (field_info[:type] == Array) && (field_info[:local] == true) && ((!field_info.keys.include?(:of)) || field_info[:of].nil?)
+    end
+
+    def accepted_values_supplied_but_they_are_not_all_the_same_type(field_name, field_info)
+      if (@data[field_name.to_s] != nil) && (@data[field_name].class == Array) && (field_info[:type] == Array) && (field_info[:local] == true)
+        if field_info[:location] == :local
+          expected_type = field_info[:of]
+          @data[field_name.to_s].each do |object_in_array|
+            if object_in_array.class != expected_type 
+              return true
+            end
+          end
+        end
+      end    
+    end
+
+    def field_is_array_of_remote_objects_but_array_has_values_other_than_persistence_or_identity(field_name, field_info)
+      if (@data[field_name.to_s] != nil) && (@data[field_name].class == Array) && (field_info[:type] == Array) && (field_info[:location] == :remote)
+        # OK, :of was declared, forge ahead and check any objects in the array for the correct type (these are all local, no worries about aggregate pointer)
+        expected_type = field_info[:of]
+        @data[field_name.to_s].each do |object_in_array|
+          if (object_in_array.class != expected_type) && (object_in_array.class != AggregatePointer) 
+            return ["#{self.class}: #{field_name} is an Array and all objects should be of type #{expected_type} but one object was of type #{object_in_array.class} or of AggregatePointer."]
+          end
+        end
+      end 
+    end
+
+
+  end
+
+end

data/lib/command_post/persistence/persistence.rb

@@ -0,0 +1,157 @@
+
+require_relative '../event_sourcing/aggregate.rb'
+require_relative '../event_sourcing/aggregate_event.rb'
+require_relative '../persistence/persistence.rb'
+require_relative './schema_validation.rb'
+require_relative './data_validation.rb'
+require_relative './auto_load.rb'
+require_relative '../command/command.rb'
+
+module CommandPost
+
+  class Persistence 
+    include SchemaValidation
+    include DataValidation
+    include AutoLoad
+
+    def initialize 
+
+      @@fields ||= Hash.new
+      @aggregate_info_set = false
+      @data = Hash.new
+      self.class.init_schema self.class.schema
+      Command.auto_generate self.class
+    end
+
+
+    def schema_fields 
+      
+      @@fields[self.class]
+    end
+
+
+    def set_data data_hash
+      @data = data_hash
+      if @aggregate_info_set == false 
+        @aggregate_info_set = true
+      end
+    end
+
+
+    def get_data name 
+      if schema_fields[name][:location] == :local
+        if schema_fields[name][:type] == DateTime
+          return DateHelper.parse_date_time(@data[name]) 
+        elsif schema_fields[name][:type] == Time
+          DateHelper.parse_time(@data[name]) 
+        else
+          return @data[name]
+        end
+      else 
+        if @data[name].class == Hash && @data[name].keys == [:aggregate_type,:aggregate_id]  
+          Aggregate.get_by_aggregate_id(schema_fields[name][:type], @data[name][:aggregate_id])
+        else 
+          @data[name]
+        end
+      end
+    end
+
+
+    def method_missing(nm, *args)
+
+      name = nm.to_s
+      if name.end_with?('=') == false
+
+
+        if @data.keys.include? nm
+            get_data nm
+        else 
+          if schema_fields.keys.include? nm 
+            return nil
+          else
+            begin
+              super
+            rescue 
+              puts "#{nm} is not a defined field in #{self}"
+            end
+          end
+        end
+      else
+        nm = name.gsub(/\=/,'').to_sym
+        @data[nm] = args.first
+      end
+    end
+
+
+    def aggregate_type
+      self.class      
+      #@data[:aggregate_info][:aggregate_type]
+    end
+
+
+    def to_h 
+
+      @data
+    end
+
+
+    def self.all
+
+      Aggregate.where(self)
+    end
+
+
+    def self.init_schema fields
+      schema_error_messages =  SchemaValidation.validate_schema(fields)
+      if schema_error_messages.length > 0
+        raise ArgumentError, "The schema for #{self} had the following error(s): #{pp schema_error_messages}"
+      end
+      @@fields[self] ||= fields 
+    end
+
+ 
+    def self.load_from_hash the_class, string_hash
+
+      data_hash = HashUtil.symbolize_keys(string_hash)
+
+
+      if  (data_hash.keys.include?(:aggregate_info) == false)  && (the_class.included_modules.include?(CommandPost::Identity) == true)
+        data_hash[:aggregate_info] = Hash.new
+        data_hash[:aggregate_info][:aggregate_type] = the_class.to_s
+        data_hash[:aggregate_info][:version] = 1 
+        data_hash[:aggregate_info][:aggregate_id] = SequenceGenerator.aggregate_id
+      end
+
+
+      object =  the_class.new
+      object.set_data  data_hash
+      object.populate_auto_load_fields #unless self.bypass_auto_load == true
+      object.populate_local_persistent_objects
+      if (the_class.included_modules.include?(CommandPost::Identity) == true)
+        object.set_aggregate_lookup_value
+      end
+      object
+    end
+
+
+    def self.bypass_auto_load
+      @@bypass ||= Hash.new
+      @@bypass[self] ||= false 
+      @@bypass[self]
+    end
+
+    
+    def self.bypass_auto_load=(value)
+      @@bypass ||= Hash.new
+      @@bypass[self]=value 
+    end
+
+
+    def self.upcase? field_name
+      raise ArgumentError ,"field not found " if (schema.keys.include?(field_name) == false) 
+      field_info = schema[field_name]
+      field_info.keys.include?(:upcase) ? field_info[:upcase] : false
+    end
+
+  end
+end

data/lib/command_post/persistence/schema_validation.rb

@@ -0,0 +1,137 @@
+require 'pp'
+
+  module SchemaValidation
+
+    def self.validate_schema fields 
+
+      errors = Array.new
+      fields.keys.each do |field_name| 
+        errors += self.validate_field_name field_name
+        errors += self.validate_keywords       field_name, fields[field_name] 
+        errors += self.validate_required       field_name, fields[field_name] if fields[field_name].keys.include? :required 
+        errors += self.validate_type           field_name, fields[field_name] if fields[field_name].keys.include? :type 
+        errors += self.validate_location       field_name, fields[field_name] if fields[field_name].keys.include? :location 
+        errors += self.validate_auto_load      field_name, fields[field_name] if fields[field_name].keys.include? :auto_load 
+        errors += self.validate_allowed_values field_name, fields[field_name] if fields[field_name].keys.include? :allowed_values 
+      end
+      errors 
+    end
+
+    def self.validate_keywords field_name, field_info 
+      errors = Array.new 
+      
+      if field_name == :lookup
+        errors = self.validate_lookup field_name, field_info
+      else 
+        keywords = [:required, :type, :of, :location, :auto_load, :allowed_values, :upcase ]
+        field_info.keys.each do |key| 
+          if keywords.include?(key)==false 
+            errors << "Field Name: #{field_name} :  #{key} is an invalid keyword." 
+          end
+        end
+      end
+      errors 
+    end
+    
+    def self.validate_lookup field_name, field_info
+      errors = Array.new 
+      keywords = [:use ]
+      field_info.keys.each do |key| 
+        if keywords.include?(key)==false 
+          errors << "Lookup Field has invalid keyword '#{key}'." 
+        end
+      end
+      errors 
+    end 
+
+
+    def self.validate_allowed_values field_name, field_info 
+      if field_info[:allowed_values].class != Array
+         return ["Field Name  '#{field_name}' :   :allowed_values was specified but the allowed_values must be contained in an Array." ]
+      end
+      types = Hash.new 
+
+      field_info.each{|x| types[x.type] = 0 }
+      if types.keys.count != 1
+       return ["Field Name  '#{field_name}' :   :allowed_values the values were not all of the same type - or no values were specified. " ]
+      end 
+      []
+    end
+    
+
+    def self.validate_auto_load field_name, field_info 
+      if [true,false].include?(field_info[:auto_load])==false
+         return ["Field Name  '#{field_name}' :   :auto_load was specified with an invalid value. Must be 'true' or 'false'." ]
+      end 
+      if (field_info[:type] == Array) 
+        if !field_info[:of].kind_of?(CommandPost::Persistence)  == false  
+          return ["Field Name  '#{field_name}' :   When :auto_load is true and :type is Array, then :of must be a kind_of CommandPost::Persistence." ]
+        end
+      else 
+        if field_info[:type].superclass.to_s != 'CommandPost::Persistence'
+          return ["Field Name  '#{field_name}' :   When :auto_load is true  then :type must be kind_of CommandPost::Persistence." ]
+        end 
+      end
+      []
+    end
+    
+
+    def self.validate_location field_name, field_info 
+      if [:local,:remote].include?(field_info[:location]) == false
+         return ["Field Name  '#{field_name}' :   :location was specified with an invalid value. Must be ':remote' or ':local'." ]
+      end 
+      if field_info[:location] == :remote
+        if (field_info[:type] == Array) 
+          if !field_info[:of]
+            return ["Field Name  '#{field_name}' :   :type is Array, but :of is not present. Use ':of => <type>' to decare the type contained by Array." ]
+          end
+          if field_info[:of].included_modules.include?(CommandPost::Identity) == false 
+            return ["Field Name  '#{field_name}' :   When :location is :remote and :type is Array, then :of must be a type that includes module CommandPost::Identity." ]
+          end
+        else 
+          if field_info[:type].included_modules.include?(CommandPost::Identity) == false 
+            return ["Field Name  '#{field_name}' :   When :location is :remote then :type must be a type that includes module CommandPost::Identity." ]
+          end 
+        end
+      else 
+        # location is :local
+        if (field_info[:type] == Array)
+
+          if field_info[:of].included_modules.include?(CommandPost::Identity) 
+            return ["Field Name  '#{field_name}' :   When :location is :local and :type is Array, then :of cannot be an instance of CommandPost::Identity." ]
+          end
+        else 
+          if field_info[:type].included_modules.include?(CommandPost::Identity)  
+            return ["Field Name  '#{field_name}' :   When :location is :local then :type cannot be an instance of CommandPost::Identity." ]
+          end
+        end
+      end
+      []
+    end
+    
+
+    def self.validate_type field_name, field_info 
+      if (field_info[:type] == Array) && (field_info.keys.include?(:of) == false)
+         return ["Field Name  '#{field_name}' :   :type is Array, but :of is not present. Use ':of => <type>' to decare the type contained by Array." ]
+      end
+      []
+    end
+    
+
+    def self.validate_required field_name, field_info 
+      if [true,false].include?(field_info[:required]) == false
+         return ["Field Name  '#{field_name}' :   :required was specified with an invalid value. Must be 'true' or 'false'." ]
+      end
+      []
+    end
+    
+
+    def self.validate_field_name field_name  
+      if field_name.class != Symbol
+         return ["Field Name  '#{field_name}' :   :field_name must be a Symbol." ]
+      end
+      []
+    end
+
+
+  end

data/lib/command_post/util/hash_util.rb

@@ -0,0 +1,23 @@
+
+ 
+
+class HashUtil
+
+
+  def self.symbolize_keys(hash)
+    hash.inject({}){|result, (key, value)|
+      new_key = case key
+                when String then key.to_sym
+                else key
+                end
+      new_value = case value
+                  when Hash then symbolize_keys(value)
+                  else value
+                  end
+      result[new_key] = new_value
+      result
+    }
+  end
+  
+end
+

data/lib/command_post/util/string_util.rb

@@ -0,0 +1,18 @@
+
+
+module CommandPost
+  class StringUtil
+
+    def self.to_camel_case(field, upcase)
+      string = field.to_s
+      upcase == true ? string.upcase : string.split('_').collect{|x| x.slice(0,1).capitalize + x.slice(1..-1) }.join()  
+    end
+
+    def self.to_label(field, upcase)
+      string = field.to_s
+       upcase == true ? string.upcase : string.split('_').collect{|x| x.slice(0,1).capitalize + x.slice(1..-1) }.join(' ')  
+    end
+
+
+  end  
+end

data/lib/command_post/version.rb

@@ -0,0 +1,3 @@
+module CommandPost
+  VERSION = "0.0.1"
+end

data/spec/command_post/identity/identity_lookup_value_aggregate_id_spec.rb

@@ -0,0 +1,89 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../command_post/require')
+
+
+class Test003Person < CommandPost::Persistence 
+  include CommandPost::Identity
+
+  def initialize
+    super
+  end
+  def self.schema 
+    fields = Hash.new
+    fields[  :first_name        ] = { :required => true,       :type => String,    :location => :local  } 
+    fields[  :last_name         ] = { :required => true,       :type => String,    :location => :local  } 
+    fields[  :ssn               ] = { :required => true,       :type => String,    :location => :local  } 
+    fields[  :lookup            ] = { :use => :aggregate_id }
+    fields 
+  end 
+end
+
+
+
+describe CommandPost::Identity do 
+  it 'as the name suggestions, provides the means for objects to have an identity that is used in retrieving it from the database' do 
+
+    params = Hash.new  # like a web request... 
+    params['first_name']  = 'John'                                              #hash key is a string to mimic a web post/put
+    params['last_name']   = 'Doe'                                               #hash key is a string to mimic a web post/put
+    params['ssn']         = "%09d" %  CommandPost::SequenceGenerator.misc       #hash key is a string to mimic a web post/put
+
+
+    #----------------------------------------------------------------
+    # The code below will eventually be replaced by the 
+    # 'handle' method of the CommandXXXXXX class.
+    #----------------------------------------------------------------
+
+    object = Test003Person.load_from_hash Test003Person, params
+    event = CommandPost::AggregateEvent.new 
+    event.aggregate_id = object.aggregate_id
+    event.object = object
+    event.aggregate_type =  Test003Person
+    event.event_description = 'hired'
+    event.user_id = 'test' 
+    event.publish
+
+
+    #----------------------------------------------------------------
+    # Retrieve the object by both aggregate_id and aggregate_lookup_value
+    # Both ways should retrieve the same object and the fields of both
+    # should match the original values used to create the object.
+    #----------------------------------------------------------------
+
+    saved_person = CommandPost::Aggregate.get_by_aggregate_id Test003Person, event.aggregate_id 
+    saved_person2 = CommandPost::Aggregate.get_aggregate_by_lookup_value Test003Person,  saved_person.aggregate_lookup_value
+
+    
+    params['first_name'].must_equal saved_person.first_name
+    params['last_name'].must_equal saved_person.last_name
+    params['ssn'].must_equal saved_person.ssn
+
+    params['first_name'].must_equal saved_person2.first_name
+    params['last_name'].must_equal saved_person2.last_name
+    params['ssn'].must_equal saved_person2.ssn
+  end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+