command_post 0.0.1

data/lib/command_post/command/command.rb

@@ -0,0 +1,375 @@
+require 'pp'
+require File.expand_path(File.dirname(__FILE__) + '/../util/string_util')
+require File.expand_path(File.dirname(__FILE__) + '/../identity/identity')
+require File.expand_path(File.dirname(__FILE__) + '/../event_sourcing/aggregate_event')
+
+
+
+module CommandPost
+
+  class Command
+
+    def validate_persistent_fields object, errors
+      object.schema_fields.each do |field_name, field_info|
+        if field_info[:type].superclass == Persistence
+          if object.send(field_name.to_sym).valid? == false
+            errors += object.send(field_name.to_sym).data_errors
+          else
+            errors += validate_persistent_fields(object.send(field_name.to_sym), errors)
+          end
+        end
+      end
+      errors
+    end
+
+
+    def hashify_persistent_objects_before_save object
+      object.schema_fields.each do |field_name, field_info|
+        if field_info[:type].superclass == Persistence 
+          hashify_persistent_objects_before_save (object.send field_name.to_sym)
+          hash = object.send(field_name.to_sym).to_h
+          method_name = "#{field_name}=".to_sym
+          object.send(method_name, hash)
+        end
+      end
+    end
+
+
+
+    def self.auto_generate persistent_class
+      @@commands ||= Hash.new 
+      return if @@commands.keys.include? persistent_class 
+      @@commands[persistent_class] = []
+      self.create_field_correction_commands persistent_class
+      self.create_aggregate_creation_commands persistent_class
+    end 
+
+
+
+
+    def self.create_aggregate_creation_commands persistent_class 
+
+
+      modules = persistent_class.to_s.split('::').length - 1
+      parts = persistent_class.to_s.split('::')
+      if parts.length == 1
+        name = "Command#{persistent_class.to_s}Create#{persistent_class.to_s}"
+      elsif parts.length == 2
+        name = "Command#{parts[1]}Create#{parts[1]}"
+      end
+      klass = Object::const_set(name.intern, Class::new(Command) do end  )
+
+      if modules == 1
+        klass.const_set parts[0], klass
+      end
+
+
+      def_init = Array.new 
+      def_init <<  "def self.execute params, user_id " 
+      def_init << '  AggregateEvent.publish self.create_event( params, user_id)'
+      def_init <<  "end "
+
+
+      klass.instance_eval (def_init.join("\n"))
+
+
+
+
+      def_init = Array.new 
+
+      def_init << 'def self.build_web_submission_form  '
+      def_init << "  "
+
+      def_init << "  hash = Hash.new   "
+      def_init << "  hash['page_header'] = 'Create Person'"
+      def_init << "  hash['command_class'] = '#{klass.to_s}'"
+
+
+      def_init << "\n"
+      def_init << "  hash['current_state'] =  {} "
+
+      def_init << "  hash['new_state']  =  {   "
+
+
+      current_state = Array.new 
+      persistent_class.schema.each do |form_field, form_field_info|
+        current_state <<  " '#{form_field}' =>  {     'label' =>   '#{StringUtil.to_label(form_field, persistent_class.upcase?(form_field))}',   'html' =>   \"<input type='text' id='#{form_field}' name='#{form_field}'/>\" } "
+      end 
+
+      def_init << current_state.join(",  \n")
+
+      def_init << '   }'
+
+      def_init << "  hash['command_description'] = 'Submit command to create a new #{persistent_class.to_s}.'"
+      def_init << "  hash['command_sub_description'] = ''"
+
+      def_init << '  hash '
+
+
+      def_init << 'end'
+
+
+      klass.instance_eval (def_init.join("\n"))
+
+
+      def_init = Array.new 
+      def_init << 'def self.validate params'
+      def_init << '  []'
+      def_init << 'end '
+
+      klass.instance_eval (def_init.join("\n"))
+
+
+
+      fields = persistent_class.schema.keys.collect {|field| ":#{field}" }
+
+      array_of_fields = fields.join(',')
+
+      def_init = Array.new 
+      def_init << 'def self.fields'
+      def_init << "  [#{array_of_fields}]"   # I LEFT OFF HERE - TRYING TO PUT A STRINGIFIED LIST OF SYMBOLS INTO A HASH
+      def_init << 'end '
+
+      klass.instance_eval (def_init.join("\n"))
+
+
+      def_init = Array.new 
+      def_init << 'def self.aggregate_type'
+      def_init << "  #{persistent_class.to_s}"
+      def_init << 'end '
+
+      klass.instance_eval (def_init.join("\n"))
+
+
+      def_init = Array.new 
+      def_init << 'def self.event_description'
+      def_init << " Created Person"
+      def_init << 'end '
+
+      klass.instance_eval (def_init.join("\n"))
+
+      @@commands[persistent_class] << klass
+
+    end
+
+
+
+
+
+
+
+
+
+
+
+
+    def self.create_field_correction_commands persistent_class
+
+      persistent_class.schema.each do |field_name, field_info|
+
+
+        modules = persistent_class.to_s.split('::').length - 1
+        parts = persistent_class.to_s.split('::')
+
+        names = persistent_class.to_s.split('::')
+        if modules == 0
+          name = "Command#{persistent_class.to_s}Correct#{CommandPost::StringUtil.to_camel_case(field_name,persistent_class.upcase?(field_name))}"
+        elsif modules == 1
+          name = "Command#{names[1]}Correct#{CommandPost::StringUtil.to_camel_case(field_name,persistent_class.upcase?(field_name))}"
+        end
+
+
+        klass = Object::const_set(name, Class::new(Command) do end  )
+
+        if modules == 1
+          klass.const_set parts[0], klass
+        end
+
+
+
+        def_init = Array.new 
+        def_init <<  "def self.execute params, user_id " 
+        def_init << '  AggregateEvent.publish self.create_event( params, user_id)'
+        def_init <<  "end "
+        
+
+        klass.instance_eval (def_init.join("\n"))
+
+
+        def_init = Array.new 
+
+        def_init << 'def self.get_web_submission_form aggregate_id'
+        def_init << "  object = Aggregate.get_by_aggregate_id(#{persistent_class.to_s}, aggregate_id)"
+        def_init << "  "
+
+        def_init << "  hash = Hash.new   "
+
+
+        def_init << "  hash['command_class'] = '#{klass.to_s}'"
+        def_init << "  hash['page_header'] = 'Correct #{StringUtil.to_label(field_name, persistent_class.upcase?(field_name))}'"
+        def_init << "  hash['command_description'] = 'Command to correct #{field_name}.'"
+        def_init << "  hash['command_sub_description'] = ''"
+        def_init << "\n"
+        def_init << "  hash['current_state'] =  {"
+
+
+
+
+        current_state = Array.new 
+        persistent_class.schema.each do |form_field, form_field_info|
+          current_state  << "                              '#{StringUtil.to_label(form_field, persistent_class.upcase?(form_field))}' =>  object.#{form_field}.to_s  "
+        end 
+        def_init << current_state.join(",  ")
+        def_init << "                            }  "
+        def_init << "  hash['new_state']  =  { } "
+
+
+
+        def_init << "  hash"
+        def_init << 'end'
+
+
+
+  
+        klass.instance_eval (def_init.join("\n"))
+
+
+        def_init = Array.new 
+        def_init << 'def self.validate params'
+        def_init << ' []'
+        def_init << 'end '
+
+        klass.instance_eval (def_init.join("\n"))
+
+
+
+
+
+        def_init = Array.new 
+        def_init << 'def self.fields'
+        def_init << "  [:#{field_name}]"
+        def_init << 'end '
+
+        klass.instance_eval (def_init.join("\n"))
+
+
+
+
+        def_init = Array.new 
+        def_init << 'def self.aggregate_type'
+        def_init << "  #{persistent_class.to_s}"
+        def_init << 'end '
+
+        klass.instance_eval (def_init.join("\n"))
+
+
+
+
+
+
+        def_init = Array.new 
+        def_init << 'def self.event_description'
+        def_init << " 'Corrected #{field_name}.'"
+        def_init << 'end '
+
+        klass.instance_eval (def_init.join("\n"))
+
+
+
+
+
+        @@commands[persistent_class] << klass
+
+      end
+
+    end
+
+
+
+
+
+    def self.publish_event command_class, params, user_id 
+
+      event = AggregateEvent.new 
+      event.aggregate_type = command_class.aggregate_type
+      event.event_description
+      #if command_class.to_s.start_with?("Command#{command_class.aggregate_type.to_s}Create")
+      event.aggregate_id = 1000
+      #end
+      event.transaction_id = SequenceGenerator.transaction_id
+      event.user_id = user_id
+      event.event_description = 'Person created'
+      
+      object = command_class.aggregate_type.new
+
+
+
+      command_class.fields.each do |field|
+        info = command_class.aggregate_type.schema[field.to_s]
+        if info[:type] == Date 
+          dt = Date._parse(params[field])
+          date = Date.new(dt[:year], dt[:mon], dt[:mday])
+          object.send("#{field.to_s}=".to_sym, date     )
+        else
+          object.send("#{field.to_s}=".to_sym, params[field])
+        end
+      end
+
+
+      if params[:aggregate_id]
+        event.aggregate_id = params[:aggregate_id]
+        event.object = object
+      else 
+        event.object = object 
+      end 
+
+
+      event.publish
+
+
+    end
+
+
+    
+    def self.commands persistent_class
+      
+      @@commands[persistent_class]
+
+    end
+  end
+
+
+
+
+
+end
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

data/lib/command_post/command_post.rb

@@ -0,0 +1,5 @@
+require "command_post/version"
+
+module CommandPost
+  
+end

data/lib/command_post/db/connection.rb

@@ -0,0 +1,12 @@
+
+module CommandPost
+
+  class Connection
+
+    def self.db_cqrs
+      Sequel.connect("postgres://localhost/cqrs?user=postgres&password=#{ENV['password']}")
+    end
+
+  end
+
+end

data/lib/command_post/db/postgresql.sql

@@ -0,0 +1,45 @@
+--drop table aggregate_events;
+--drop table aggregates;
+
+
+
+create table aggregate_events (
+
+    transaction_id      bigint primary key,  
+    aggregate_id        bigint,  
+    aggregate_type      varchar(100),
+    event_description   text,
+    content             text,
+    call_stack          text, 
+    user_id         	varchar(100) not null,
+    transacted          timestamp
+
+   )  ;
+
+create index aggregate_id_idx on aggregate_events(aggregate_id,aggregate_type);
+
+
+
+
+  
+create table aggregates (
+
+aggregate_id    		bigint not null primary key,
+aggregate_lookup_value  varchar(100) not null,
+aggregate_type    		varchar(100) not null,
+content         		text not null
+
+)  ; 
+
+create index aggregate_lookup_idx on aggregates(aggregate_lookup_value);
+
+
+
+
+  
+
+CREATE SEQUENCE aggregate START 1;
+
+CREATE SEQUENCE transaction START 1;
+
+CREATE SEQUENCE misc START 1;

data/lib/command_post/event_sourcing/aggregate.rb

@@ -0,0 +1,82 @@
+require 'pp'
+require 'securerandom'
+require 'json'
+require 'sequel'
+
+require_relative '../db/connection'
+require_relative '../identity/sequence_generator'
+require_relative '../util/hash_util'
+
+module CommandPost
+
+
+  $DB ||= Connection.db_cqrs
+
+  class Aggregate   
+   
+    @@prep_stmt_insert ||= $DB[:aggregates].prepare(:insert,  :insert_aggregate, :aggregate_id => :$aggregate_id, :aggregate_type => :$aggregate_type, :content => :$content, :aggregate_lookup_value => :$aggregate_lookup_value )
+    @@prep_stmt_update ||= $DB[:aggregates].prepare(:update,  :update_content_aggregate_lookup_value, :aggregate_id => :$aggregate_id, :content => :$content, :aggregate_lookup_value => :$aggregate_lookup_value )
+
+    
+
+    def self.replace object, aggregate_lookup_value
+
+
+      content = JSON.generate object
+      aggregate_id = object[:aggregate_info][:aggregate_id] 
+      aggregate_type = object[:aggregate_info][:aggregate_type] 
+      version = object[:aggregate_info][:version].to_i
+
+
+      if (version) == 1
+        @@prep_stmt_insert.call(:aggregate_id => aggregate_id, :aggregate_type => aggregate_type.to_s , :content => content, :aggregate_lookup_value => aggregate_lookup_value  ) 
+      else
+        $DB["UPDATE aggregates set content = ?, aggregate_lookup_value = ? where aggregate_id = ?", content,  aggregate_lookup_value,  aggregate_id ].update
+      end
+    end
+    
+
+
+    def self.get_by_aggregate_id aggregate_type ,aggregate_id 
+      hash = Hash.new
+      $DB.fetch("SELECT * FROM aggregates WHERE aggregate_id = ?",  aggregate_id ) do |row|
+        hash = JSON.parse(row[:content])
+      end
+      aggregate_type.load_from_hash( aggregate_type, HashUtil.symbolize_keys(hash))
+    end
+
+
+
+    def self.where(aggregate_type)
+      results = Array.new
+      $DB.fetch("SELECT * FROM aggregates WHERE aggregate_type = ?", aggregate_type.to_s) do |row|
+        hash =  JSON.parse(row[:content])
+        results << aggregate_type.load_from_hash( aggregate_type, HashUtil.symbolize_keys(hash))
+      end
+      results
+    end
+    
+
+
+    def self.exists? aggregate_type, aggregate_lookup_value  
+      $DB.fetch("SELECT count(*) as cnt FROM aggregates WHERE aggregate_type = ? and aggregate_lookup_value = ? ", aggregate_type.to_s, aggregate_lookup_value) do |rec|
+        return rec[:cnt].to_i > 0
+      end
+    end
+    
+
+
+    def self.get_aggregate_by_lookup_value aggregate_type, aggregate_lookup_value 
+      hash = Hash.new
+      $DB.fetch("SELECT content FROM aggregates WHERE aggregate_type = ? and aggregate_lookup_value = ? ", aggregate_type.to_s, aggregate_lookup_value) do |rec|
+        hash = JSON.parse(rec[:content])
+      end
+      if hash.nil? || hash == {}
+        {}
+      else
+        aggregate_type.load_from_hash( aggregate_type, HashUtil.symbolize_keys(hash))
+      end
+    end
+  end
+
+end

data/lib/command_post/event_sourcing/aggregate_event.rb

@@ -0,0 +1,107 @@
+require_relative './aggregate.rb'
+
+
+module CommandPost
+
+  class AggregateEvent  
+
+    attr_accessor :aggregate_type, :aggregate_id, :content, :transaction_id, :transacted, :event_description , :object, :changes, :user_id, :call_stack
+
+    @@prepared_statement ||= $DB[:aggregate_events].prepare(:insert,  :insert_aggregate_event, 
+                                            :aggregate_type => :$aggregate_type, 
+                                            :aggregate_id => :$aggregate_id, 
+                                            :content => :$content, 
+                                            :transaction_id => :$transaction_id, 
+                                            :transacted => :$transacted, 
+                                            :event_description => :$event_description,
+                                            :user_id => :$user_id   )
+    @@required_by_txn = [ "aggregate_type", "aggregate_id", "event_description", "content", "transaction_id", "transacted" ]
+
+    def initialize
+      @transaction_id = SequenceGenerator.transaction_id
+      @transacted = Time.now 
+      @object = @changes = nil
+    end
+
+    def publish 
+      if changes
+        save_event changes
+      elsif object
+        @aggregate_lookup_value = object.aggregate_lookup_value
+        save_event object.to_h
+      else
+        raise 'Event has no state to publish.'
+      end
+    end
+    
+    def self.publish event 
+      event.publish
+    end
+
+    
+
+
+
+    def self.get_history_by_aggregate_id aggregate_id 
+      hash = Hash.new
+      cnt = 0
+      results = Array.new 
+      $DB.fetch("SELECT * FROM aggregate_events WHERE aggregate_id = ? order by transacted",  aggregate_id ) do |row|
+        hash = JSON.parse(row[:content])
+        results << "==================================================================================="
+        results << "Version: #{cnt += 1} "
+        results << "Event Description: #{row[:event_description]}  "
+        results << "Change Made By:    #{row[:user_id]}"
+        results << "------   change data ------------"
+        results << hash.pretty_inspect
+      end
+      results
+    end
+
+
+
+    private
+    def save_event change 
+
+      puts "@aggregate_type       = #{@aggregate_type}   "
+      puts "@aggregate_id         = #{@aggregate_id}  "
+      puts "@transaction_id       = #{@transaction_id}   "
+      puts "@transacted           = #{@transacted}   "
+      puts "@event_description    = #{@event_description}   "
+      puts "@user_id              = #{@user_id}   "
+
+
+      json = JSON.generate(change)
+      @@prepared_statement.call(
+                            :aggregate_type => @aggregate_type.to_s, 
+                            :aggregate_id => @aggregate_id,
+                            :content => json, 
+                            :transaction_id => @transaction_id, 
+                            :transacted => @transacted, 
+                            :event_description => @event_description,
+                            :user_id => @user_id
+                              )
+      Aggregate.replace  get_current_object, @aggregate_lookup_value
+    end
+
+
+
+    def get_current_object 
+
+      version = 0
+      accumulated_object = Hash.new 
+      $DB.fetch("SELECT * FROM aggregate_events WHERE aggregate_id = ? order by transacted", @aggregate_id) do |row|
+        accumulated_object.merge!(HashUtil.symbolize_keys(JSON.parse(row[:content])))
+        aggregate_details = Hash.new
+        aggregate_details[:aggregate_type] = row[:aggregate_type]
+        aggregate_details[:aggregate_id] = row[:aggregate_id]
+        aggregate_details[:version] = "#{version += 1}"  
+        aggregate_details[:most_recent_transaction] = row[:transaction_id]
+        accumulated_object[:aggregate_info] =  aggregate_details
+      end
+
+      accumulated_object 
+    end
+  end
+
+end 

data/lib/command_post/identity/identity.rb

@@ -0,0 +1,75 @@
+
+module CommandPost
+
+
+  module Identity
+
+ 
+    def aggregate_lookup_value
+      field = (schema_fields[:lookup][:use])
+      (self.send field.to_sym).to_s
+    end
+
+    def aggregate_id 
+
+      @data[:aggregate_info][:aggregate_id]
+    end
+    
+
+    def aggregate_pointer
+
+      AggregatePointer.new(aggregate_info)
+    end
+    
+
+    def self.generate_checksum value 
+      sha = Digest::SHA2.new
+      sha.update(value)
+      sha.to_s 
+    end
+    
+
+    def checksum  
+      data = Array.new
+      @data.keys.select {|x| x != :aggregate_info}.each {|x| data <<  @data[x] }
+      Identity.generate_checksum(data.join())
+    end
+    
+
+    def self.select (&block) 
+      Aggregate.where(self).select
+    end
+    
+
+    def aggregate_info
+      if @data.keys.include? :aggregate_info
+        @data[:aggregate_info]
+      else
+        raise "A request was made for 'AggregateInfo at a time when it was not present in object state."
+      end
+    end
+    
+
+    def self.find aggregate_id
+
+      Aggregate.get_by_aggregate_id self, aggregate_id
+    end
+    
+  end
+
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+