iab-InsuranceBizLogic 0.1.2

data/lib/models/modbdbxmlje.rb

@@ -0,0 +1,135 @@
+module BDBXMLJE
+  include Java 
+  require 'date'
+  require 'pathname'
+  require 'lib/db.jar'
+  require 'lib/dbxml.jar'
+
+  # Include all the Java and JE classes that we need. 
+
+  include_class 'java.io.File' do |p, c|
+    "J#{c}"
+  end
+
+  include_class ['com.sleepycat.db.Environment','com.sleepycat.db.EnvironmentConfig'] do |p, c|
+    "J#{c}"
+  end
+  include_class 'com.sleepycat.db.Cursor'
+  include_class 'com.sleepycat.db.Database'
+  include_class 'com.sleepycat.db.DatabaseConfig'
+  include_class 'com.sleepycat.db.DatabaseType'
+  include_class 'com.sleepycat.db.DatabaseEntry'
+  include_class 'com.sleepycat.db.OperationStatus'
+  include_class 'com.sleepycat.db.Transaction'
+  
+  include_class 'com.sleepycat.bind.tuple.IntegerBinding'
+  include_class 'com.sleepycat.bind.tuple.StringBinding'
+  
+  include_class 'com.sleepycat.dbxml.XmlManager'
+  include_class 'com.sleepycat.dbxml.XmlManagerConfig'
+  include_class 'com.sleepycat.dbxml.XmlDocument'
+  include_class 'com.sleepycat.dbxml.XmlTransaction'
+  
+  #setup DB_ROOT to point to IABDB location
+  unless defined?(DB_ROOT)
+    db_path = APP_CONFIG['dbpath']
+    db_path = Pathname.new(db_path).cleanpath(true).to_s
+    DB_ROOT = db_path
+    DB_NAME = APP_CONFIG['dbcontainer']
+  end
+  
+  def setup_env
+    #setup UUID state file
+    UUID.config(:state_file => "#{DB_ROOT}/uuid.state",
+                  :sequence => rand(0x100000000),
+                  :mac_addr => '00:19:e3:36:60:f5')
+
+    begin
+      envConf = JEnvironmentConfig.new()
+      envConf.setAllowCreate(true)
+      envConf.setTransactional(true)
+      envConf.setInitializeCache(true);      
+
+      f = JFile.new(DB_ROOT)
+      $env = JEnvironment.new(f, envConf);
+      
+      manConf = XmlManagerConfig.new()
+      manConf.setAllowExternalAccess(true)
+      $man = XmlManager.new($env,manConf)
+      
+      if (!File.exist?("#{DB_ROOT}/#{DB_NAME}"))
+        $con = $man.createContainer(DB_NAME)
+      else
+        $con = $man.openContainer(DB_NAME)
+      end
+      
+      $base = "."
+    rescue NativeException => e
+      puts "Native exception's cause: #{e.cause}"
+      raise
+    end
+  end
+
+  def create_key_and_doc(msg)
+    key = UUID.new
+    create_doc(msg,key)
+    key
+  end
+  
+  def read_doc(key)
+    $con.getDocument(key).getContentAsString() 
+  end
+  
+  def create_doc(msg,key)
+    #removed the transaction bit since causes error when running inside Tomcat under JRuby
+    #txn = $man.createTransaction()
+    a = $man.createDocument()
+    a.setContent(msg)
+    a.setName(key)
+    $con.putDocument(key,msg)
+    #$con.putDocument(txn,key,msg)
+    #txn.commit()
+  end
+  
+  def replace_doc(msg,key)
+    #removed the transaction bit since causes error when running inside Tomcat under JRuby
+    #txn = $man.createTransaction()
+    #a = $con.getDocument(txn,key)
+    a = $con.getDocument(key)
+    a.setContent(msg)
+    #$con.updateDocument(txn,a)
+    $con.updateDocument(a)
+    #txn.commit
+  end
+  
+  def find(query)
+    cxt = $man.createQueryContext()
+    results = $man.query(query, cxt)
+    if (results.size() == 0) then
+      return nil
+    end
+    #results is essentially an array of result lines
+    #a single result will span a number of output lines, e.g. outer joined
+    #MTA info will appear with a CRLF separator
+    #the following code makes up single logical result rows based on the lines between
+    #successive pairs of {} braces
+    #
+    #it should be noted that the result set from the xqueries is intended to be
+    #a valid ruby block
+    #this allows the result to be used to instantiate an active record object
+    #with no further manipulation required    
+    rows = []
+    i = 0
+    while results.hasNext()
+      if rows[i] == nil
+        rows[i] = ""
+      end
+      r = results.next().asString()
+      rows[i] << r.chomp
+      if (r.match(']}'))
+        i = i + 1
+      end 
+    end   
+    rows
+  end
+end

data/lib/models/persist.rb

@@ -0,0 +1,50 @@
+# Copyright (c) 2007-2008 Orangery Technology Limited 
+# You can redistribute it and/or modify it under the same terms as Ruby.
+#
+$:.unshift(File.dirname(__FILE__))
+require 'rubygems'
+require 'uuid'
+require 'rexml/document'
+require 'singleton'
+require 'modbdbxml' unless defined?(JRUBY_VERSION)
+require 'modbdbxmlje' if defined?(JRUBY_VERSION)
+
+class Persist
+  include BDBXML unless defined?(JRUBY_VERSION)
+  include BDBXMLJE if defined?(JRUBY_VERSION)
+
+  include Singleton
+  
+  def initialize
+    setup_env
+  end
+  
+  def put(key,request)
+    begin
+      if (key == 'UUID') then
+        key = UUID.new
+        create_doc(request,key)
+      else
+        replace_doc(request,key)
+      end
+      key
+    end
+  end
+  
+  def get(key)
+    read_doc(key)
+  end
+  
+  #get with the insistence the document will be there
+  #if not then create it
+  def get!(key,request)
+    result=""
+    begin
+      result = read_doc(key)
+    rescue Exception => e #document not found
+      create_doc(request,key)
+      result = read_doc(key)
+    end
+    return result
+  end
+end

data/lib/processengine/HashEnhancement.rb

@@ -0,0 +1,59 @@
+class Hash
+
+  def deep_merge0(hash)
+        target = dup
+
+        hash.keys.each do |key|
+          if hash[key].is_a? Hash and self[key].is_a? Hash
+            target[key] = target[key].deep_merge(hash[key])
+            next
+          end
+
+         target[key] = hash[key]
+        end
+
+        target
+      end
+
+      def deep_merge!(second)
+        second.each_pair do |k,v|
+          if self[k].is_a?(Hash) and second[k].is_a?(Hash)
+            self[k].deep_merge!(second[k])
+          else
+            self[k] = second[k]
+          end
+        end
+      end
+
+
+       def deep_merge2(other)
+         deep_proc = Proc.new { |k, s, o|
+             if s.kind_of?(Hash) && o.kind_of?(Hash)
+                next s.merge(o, &deep_proc)
+             end
+             next o
+          }
+          merge(other, &deep_proc)
+       end
+
+
+       def deep_merge(second)
+          merger = proc { |key,v1,v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
+          self.merge(second, &merger)
+       end
+
+
+       def keep_merge(hash)
+          target = dup
+          hash.keys.each do |key|
+             if hash[key].is_a? Hash and self[key].is_a? Hash
+                target[key] = target[key].keep_merge(hash[key])
+                next
+             end
+             #target[key] = hash[key]
+             target.update(hash) { |key, *values| values.flatten.uniq }
+          end
+          target
+       end
+
+    end

data/lib/processengine/communicator.rb

@@ -0,0 +1,18 @@
+# Copyright (c) 2007-2008 Orangery Technology Limited 
+# You can redistribute it and/or modify it under the same terms as Ruby.
+#
+require 'processengine/engine'
+
+class Communicator
+  
+  @@instance = Communicator.new
+  
+  def self.instance
+    @@instance
+  end
+  
+  def handle(session,process,params)
+    eng = PEngine.new
+    eng.push(session,process,params)
+  end
+end

data/lib/processengine/engine.rb

@@ -0,0 +1,171 @@
+# Copyright (c) 2007-2008 Orangery Technology Limited 
+# You can redistribute it and/or modify it under the same terms as Ruby.
+#
+require 'models/persist'
+require 'cgi'
+require 'net/http' 
+
+require 'servicebroker/broker'
+require 'Marshaller'
+
+require 'bizLogic/applymta'
+require 'bizLogic/search'
+require 'bizLogic/payment'
+require 'bizLogic/diff'
+require 'bizLogic/continualQNB'
+require 'bizLogic/VPMSHelper'
+
+require 'processengine/HashEnhancement'
+
+class PEngine
+  include XMLDiff
+  include Marshaller
+  
+  include ApplyMTA
+  include Search
+  include Payment
+  include RefineQuote
+  include VPMSHelper
+
+  PRODUCTMODELS = Hash.new
+  
+  def deriveActiveRecordDefinitionOfProduct(product)
+      if (PRODUCTMODELS.has_key?(product))
+        productModel = PRODUCTMODELS[product.to_sym]
+      else
+        require 'ProductInterpreter'
+        oilfile = File.join("#{DY_MODELS}/#{product}/DSL/product.oil")
+        open(oilfile) {|f| @contents = f.read }
+        dsl = @contents.to_s
+        if (!dsl.include?("product :#{product}"))
+          raise "#{DY_MODELS}/#{product}/DSL/product.oil does NOT contain a product defintion for #{product}"
+        end
+        productModel = ProductInterpreter.execute(dsl)
+        PRODUCTMODELS[product.to_sym] = productModel
+      end
+      productModel
+  end
+
+  def addDefaults(p1)
+    #adds default values where no value currently exists
+    #these values should be extracted from the data model!!
+    p2 = {"ContentsCoverCoverDetailOtherContentsSumInsured" => {"Amount" => "1000000"},
+        "ContentsCoverCoverDetailOtherStockSumInsured" => {"Amount" => "1000000"},
+        "ContentsCoverCoverDetailTargetStockSumInsured" => {"Amount" => "1000000"},
+        "BuildingsCoverCoverDetailShopFrontCoverDetailSumInsured" => {"Amount" => "1000000"},
+        "BuildingsCoverCoverDetailTenantsImprovementsCoverDetailSumInsured" => {"Amount" => "1000000"},
+        "BookDebtsCoverCoverDetailSumInsured" => {"Amount" => "1000000"},
+        "BusinessInterruptionCoverCoverDetailSumInsured" => {"Amount" => "1000000"},
+        "EmployersLiabilityCoverCoverDetailSumInsured" => {"Amount" => "1000000"},
+        "GlassCoverCoverDetailSumInsured" => {"Amount" => "1000000"},
+        "LossOfLicenceCoverCoverDetailSumInsured" => {"Amount" => "1000000"},
+        "MoneyCoverCoverDetailSumInsured" => {"Amount" => "1000000"},
+        "ProductLiabilityCoverCoverDetailSumInsured" => {"Amount" => "1000000"},
+        "PublicLiabilityCoverCoverDetailSumInsured" => {"Amount" => "1000000"}}
+      
+    p2.each do |k,v|
+      if p1.has_key?(k)
+          v.each do |ik,iv|
+            if (!p1[k].has_key?(ik) or p1[k][ik].length == 0)
+              #puts "replacing value for:#{k},#{ik}"
+              p1[k][ik] = iv
+            end
+          end
+      else
+        #puts "replacing value for:#{k}"
+        p1[k] = v
+      end
+    end
+    return p1
+  end
+  
+  def push(session,process,params)
+    package = 'CommercialProperty'
+    persist = Persist.instance
+
+    case process
+    when "ProcessDefinition"
+      require 'RailsProcessInterpreter'
+      open("#{PRODUCT_ROOT.gsub(/%product/,session[:product])}/DSL/processes.oil") {|f| @contents = f.read }
+      dsl = @contents.to_s
+      action_methods = RailsProcessInterpreter.execute(dsl)
+      action_methods
+
+    when "GetNBQuote"
+      eval(deriveActiveRecordDefinitionOfProduct(session[:product]))
+      xml = createXMLMessage(session[:product],params,false) { |k,v| "<#{k}>#{v}</#{k}>" }
+      key = persist.put("UUID",xml)
+      session[:policyKey] = key
+
+      if APP_CONFIG['use_rating_engine']
+        nvpxml = buildVPMSMessage(session[:product],package,session[:brand],params)
+        response = callVPMS(nvpxml)
+        parseVPMSresponse(response,session[:product])
+        xml = mergeIntoXMLDoc(xml,@premiums)
+      end
+      prepareModels(session[:product],xml)
+      #cmd = SBroker.RequestRatingService("NB",session[:product],true,false,false)
+      #quote = cmd.call(xml)
+
+    when "RefineNBQuote"
+      eval(deriveActiveRecordDefinitionOfProduct(session[:product]))
+      origxml = persist.get(session[:policyKey])
+      h = prepareModels(session[:product],origxml)
+      params = h.deep_merge(params)
+      combinedxml = createXMLMessage(session[:product],params,false) { |k,v| "<#{k}>#{v}</#{k}>" }
+      key = persist.put(session[:policyKey],combinedxml)
+     
+      if APP_CONFIG['use_rating_engine']
+        nvpxml = buildVPMSMessage(session[:product],package,session[:brand],params)
+        response = callVPMS(nvpxml)
+        parseVPMSresponse(response,session[:product])
+        combinedxml = mergeIntoXMLDoc(combinedxml,@premiums)
+      end
+      
+      prepareModels(session[:product],combinedxml)
+
+    when "Search"
+      executeSearch(session[:product],params)      
+
+    when "FindPolicyOrQuote"
+      xml = persist.get(params[:choosen][:one])
+      prepareModels(session[:product],xml)
+
+    when "SectionRating"
+      "1553.25"
+
+    when "MTAReason"
+      xml = persist.get(session[:policyKey])
+      prepareModels(session[:product],xml)      
+
+    when "GetMTAQuote"
+      #db = Persist.instance
+      origImage = persist.get(session[:policyKey])
+      #TODO: the origImage will need any MTAs layering on there
+      xml = createXMLMessage(session[:product],params,false) { |k,v| "<#{k}>#{v}</#{k}>" }      
+      applyMTA(session[:mtaStartDate],session[:mtaEndDate],session[:policyKey],origImage,xml)
+      prepareModels(session[:product],xml)
+
+    when "PolicyDocumentation"
+       #get XML quote/policy document
+      xml = persist.get(session[:policyKey])
+      #call the rating engine (again!) until we've preserved the quote
+      cmd = SBroker.RequestRatingService("NB",session[:product],true,false,false)
+      quote = cmd.call(xml)
+      prepareModels(session[:product],xml)
+
+    when "Checkout"
+      next_url = setup_payment(params)
+      next_url
+
+    when "ConfirmPayment"
+      get_gateway_payment_details(params)
+
+    when "CompletedPayment"
+      complete_payment(params)
+
+    else
+      puts "**********> #{process} logic performed once it has been written <**********"
+    end
+  end
+end

data/lib/servicebroker/broker.rb

@@ -0,0 +1,74 @@
+# Copyright (c) 2007-2008 Orangery Technology Limited
+# You can redistribute it and/or modify it under the same terms as Ruby.
+#
+require 'net/http'
+require 'RatingEngineResolver'
+
+class SBroker
+  SERVICE_BROKER_ROOT = File.dirname(__FILE__)
+  XSL_ROOT = File.join(SERVICE_BROKER_ROOT, 'xsl')
+  MOCK_ROOT = File.join(SERVICE_BROKER_ROOT, 'mocks')
+  
+  def self.RequestRatingService(process,product,full,partial,knockout)
+    open("#{PRODUCTS_ROOT}/#{product}/dsl.rb") {|f| @contents = f.read }
+    script = @contents.to_s
+    mycmd = RatingEngineResolver.execute(script)
+    cmd = eval(mycmd)
+    cmd
+  end
+  
+  def self.InvokeRTE(msg)
+      Net::HTTP.start(APP_CONFIG['rte_restful_ip'], 80) do |http|
+        response = http.post('/RestfulXRTE.ashx/quote',msg)
+        response.body
+      end    
+  end
+  
+  def self.ApplyTransform(xml,transform,code)
+      require 'xml/xslt'
+      
+      xslt = XML::XSLT.new()
+      xslt.xml = xml
+      xslt.xsl = File.join(XSL_ROOT, transform)
+      if (code != nil) then
+        xslt.parameters = { "code" => "#{code}" }
+      end
+      transformed_xml = xslt.serve()
+      transformed_xml
+  end
+  
+  def self.ExtractSectionPremium(xml,response_xml)
+    begin
+      #expects a standard format message with a code value in
+      #will be ok since all the schemas are derived from the
+      #formal polaris library
+      transformed_xml = SBroker.ApplyTransform(xml,"extractCode.xsl",nil)
+      if (transformed_xml == nil)
+          transformed_xml = SBroker.ApplyTransform(xml,"extractDescription.xsl",nil)
+      end
+      msg = transformed_xml.strip
+      vals = msg.split('>')
+      #get some odd initial character here...quick hack to remove it
+      #need to figure out what it is
+      code = vals[1][1,vals[1].length]
+
+      #now extract the premium from the response
+      #this approach is taken so that the xslt can hide the nasties of a none XML dictionary
+      #TODO: provide a XSLT conversation on the way back from thre RTE
+      transformed_xml = SBroker.ApplyTransform(response_xml,"extractPremium.xsl",code)
+      msg = transformed_xml.strip
+
+      vals = msg.split('>')
+      #get some odd initial character here...quick hack to remove it
+      #need to figure out what it is
+      premium = vals[1][1,vals[1].length]
+    rescue Exception => e
+      puts "THE SECTION PREMIUM ERROR'ED WITH:#{e.message}"
+    end      
+  end
+  
+  def self.GetMockRatingResponse(mockFile)
+    quote = open("#{MOCK_ROOT}/" + mockFile) {|f| f.read }
+    quote.to_s  
+  end
+end