vchain_client 1.0.24 → 1.0.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 45eab3023d999ff109e6276094ad539f90b58cd5
-  data.tar.gz: 5ba7df0e979f407888885065f52c7b806407411f
+  metadata.gz: 594cda89ecd48d65fe70e8ab692af24962232ff0
+  data.tar.gz: 5f20fe475e378bf2380c9ee1d069052d9139772a
 SHA512:
-  metadata.gz: 0e15a53253f36814cd6c59f7b59109dfcc9f052a23678d686b88be16c6676a8cd4aba8f1537d007bb565febbfdd94b7caae15261be1d540656a7f7f353638feb
-  data.tar.gz: 1769eb0e95bfb74529ad4dfe569d3d8b7c91e34efeb492c24b79f193470a3db3ee05f50691343e39ad32bf3e48458234ef9b0730e1bb2db701adc172d66781ee
+  metadata.gz: 4d62fc662be3b9200c587ade4e9307fb2ef4bf5e72d84b4fe2a0d122233cbd79258e8bbd6be4bc6005da44563e1b27e00dd9c0caf21f0b75b6a3e235799e9374
+  data.tar.gz: 514bb2f17cc0de35fbb6247a43f5976a92b606b34a895a06c01886edf95c52a4304c320b1f21974f82ed17865eb542af696b068a4811d8f260e3604048f42d87

data/lib/vchain_client/decision_algos/decision_algorithm.rb

@@ -0,0 +1,11 @@
+module VChainClient
+  
+  class DecisionAlgorithm
+
+  	def make_decision(sent_document, res, validated_data_points)
+  		return nil
+  	end
+
+  end
+
+end

data/lib/vchain_client/decision_algos/vector_based_decision_algorithm.rb

@@ -0,0 +1,477 @@
+module VChainClient
+
+  class VectorBasedDecisionAlgorithm < VChainClient::DecisionAlgorithm
+
+    @log = nil
+
+    @config = nil
+
+    CREDENTIALS_FIELD_WEIGHT = 1
+    NON_CREDENTIALS_FIELD_WEIGHT = 1
+    PROBABILITY_THRESHOLD = 80
+
+    def initialize(app_config)
+      @config = app_config
+
+      @log = Log4r::Logger["vchain_client"]
+    end 
+
+    def get_vector_weight(vector, credentials_fields)
+      vector_weight = 0
+
+      vector.each { |field_hash, values|
+        field = values[1]
+        
+        if field_hash != "names_parts"
+          weight = values[2]
+
+          if credentials_fields.include?(field)
+            vector_weight += weight * CREDENTIALS_FIELD_WEIGHT
+          else
+            vector_weight += weight * NON_CREDENTIALS_FIELD_WEIGHT
+          end
+        end
+      }
+
+      return vector_weight
+    end
+
+    def make_decision(sent_document, res, validated_data_points)
+
+      sent_type_credentials_fields = VChainClient::Client.get_credentials_fields(sent_document["type"])
+
+#      total_response_weight = 0
+#
+#      sent_document_fully_hashed = VChainClient::Client.full_hash(sent_document)
+#
+#      sent_type_credentials_fields_hashed = []
+#      sent_type_credentials_fields.each { |credentials_field|
+#        sent_type_credentials_fields_hashed.push(Digest::SHA512.hexdigest(credentials_field))
+#      }
+#
+#      validated_data_points.each { |data_point_hash, validated_data_point|
+#        validated_data_point.each { |field_hashed, weight|
+#
+#          if sent_document_fully_hashed.key?(field_hashed) || sent_type_credentials_fields_hashed.include?(field_hashed)
+#
+#            if sent_type_credentials_fields_hashed.include?(field_hashed)
+#              total_response_weight += weight * CREDENTIALS_FIELD_WEIGHT
+#            else
+#              total_response_weight += weight * NON_CREDENTIALS_FIELD_WEIGHT
+#            end
+#
+#          end
+#        }
+#      }
+
+      # 1. cut non-input fields, rebuild doc_hashes
+      # 2. build vectors out of cut documents
+
+      cut_res_docs = []
+
+      vectors = []
+
+      res["docs"].each { |res_doc|
+
+        cut_doc = {}
+        vector = {}
+
+        names_parts = {}
+        if res_doc.key?("names_parts")
+          names_parts = res_doc["names_parts"]
+
+          res_doc.delete("names_parts")
+        end
+
+        full_doc_hash = VChainClient::Client.get_doc_hash(res_doc)
+
+        res_doc.each { |res_doc_field, res_doc_value|
+          if sent_document.key?(res_doc_field) || sent_type_credentials_fields.include?(res_doc_field)
+            cut_doc[res_doc_field] = res_doc_value
+            
+            vector[Digest::SHA512.hexdigest(res_doc_field)]  = [res_doc_value, res_doc_field, 0]
+          end
+        }
+
+        cut_doc["doc_hash"]      = VChainClient::Client.get_doc_hash(cut_doc)
+
+        cut_doc["full_doc_hash"] = full_doc_hash
+
+        hashed_full_doc_hash = Digest::SHA512.hexdigest(full_doc_hash);
+
+        if validated_data_points.key?(hashed_full_doc_hash)
+          data_points = validated_data_points[hashed_full_doc_hash]
+
+          data_points.each { |data_point_field, data_point_value|
+            if vector.key?(data_point_field)
+              vector[data_point_field][2] += data_point_value
+            end
+          }
+        end
+
+        if !names_parts.empty?
+          cut_doc["names_parts"] = names_parts
+          vector["names_parts"]  = names_parts
+        end
+
+        vectors.push(vector)
+
+        cut_res_docs.push(cut_doc)
+      }
+
+      res["docs"] = cut_res_docs
+
+
+      # 3. combine vectors part 1 - marking => absorb smaller, merge equal
+      for i in 0..(vectors.length - 1)
+
+        vector_i = vectors[i]
+        
+        for j in i+1..(vectors.length - 1)
+
+          if j >= vectors.length
+            break
+          end
+
+          vector_j = vectors[j]
+
+          i_is_less_j = false
+          j_is_less_i = false
+
+          need_to_combine = true
+
+          vector_i.each { |vector_i_hashed_field, vector_i_values|
+            if vector_i_hashed_field != "names_parts" && vector_i_hashed_field != "resolutions"
+              if !vector_j.key?(vector_i_hashed_field)
+                j_is_less_i = true
+              else
+                vector_j_values = vector_j[vector_i_hashed_field]
+                if vector_i_values[0] != vector_j_values[0]
+                  need_to_combine = false
+                  break
+                end
+              end
+            end
+          }
+
+          vector_j.each { |vector_j_hashed_field, vector_j_values|
+            if vector_j_hashed_field != "names_parts" && vector_j_hashed_field != "resolutions"
+              if !vector_i.key?(vector_j_hashed_field)
+                i_is_less_j = true
+              else
+                vector_i_values = vector_i[vector_j_hashed_field]
+                if vector_j_values[0] != vector_i_values[0]
+                  need_to_combine = false
+                  break
+                end
+              end
+            end
+          }
+
+          if need_to_combine
+            if i_is_less_j && j_is_less_i
+              # differs, no need to combine
+
+            elsif i_is_less_j && !j_is_less_i
+              # combine i to j                
+              if !vectors[i].key?("resolutions")
+                vectors[i]["resolutions"] = []
+              end
+              if !vectors[j].key?("resolutions")
+                vectors[j]["resolutions"] = []
+              end
+              vectors[i]["resolutions"].push(["combine_to", j])
+              vectors[j]["resolutions"].push(["absorb", i])
+
+            elsif !i_is_less_j && j_is_less_i
+              # combine j to i
+              if !vectors[i].key?("resolutions")
+                vectors[i]["resolutions"] = []
+              end
+              if !vectors[j].key?("resolutions")
+                vectors[j]["resolutions"] = []
+              end
+              vectors[j]["resolutions"].push(["combine_to", i])
+              vectors[i]["resolutions"].push(["absorb", j])
+
+            else
+              # equals, combine j to i and delete j
+              if !vectors[i].key?("resolutions")
+                vectors[i]["resolutions"] = []
+              end
+              if !vectors[j].key?("resolutions")
+                vectors[j]["resolutions"] = []
+              end
+              vectors[j]["resolutions"].push(["combine_to", i])
+              vectors[i]["resolutions"].push(["absorb", j])
+
+            end
+          end
+        end
+      end
+
+      # 4. combine vectors part 2 - resolutions execution => absorb smaller, merge equal
+      vectors_to_remove = []
+
+      for i in 0..(vectors.length-1)
+
+        vector_i = vectors[i]
+
+        if vector_i.key?("resolutions")
+
+          need_to_delete = false
+
+          vector_i["resolutions"].each { |resolution|
+            
+            resolution_type = resolution[0]
+
+            if resolution_type == "combine_to"
+              
+              vector_i["resolutions"].each { |resolution_b|
+                
+                if resolution_b[0] == "absorb"
+                  if !vectors[resolution[1]].key?("resolutions")
+                    vectors[resolution[1]]["resolutions"] = []
+                  end
+
+                  # check for dublicates
+                  need_to_add = true
+
+                  vectors[resolution[1]]["resolutions"].each { |resolution_c|
+                    if resolution_c[0] == resolution_b[0] && resolution_c[1] == resolution_b[1]
+                      need_to_add = false
+                      break
+                    end
+                  }
+
+                  if need_to_add
+                    vectors[resolution[1]]["resolutions"].push(resolution_b)
+                  end
+                end
+              }
+
+              need_to_delete = true
+            end
+          }
+
+          if need_to_delete
+            vectors_to_remove.push(i)
+          end
+        end
+      end
+
+      for i in 0..(vectors.length - 1)
+
+        vector_i = vectors[i]
+
+        if vector_i.key?("resolutions")
+          if !vectors_to_remove.include?(i)
+
+            vector_i["resolutions"].each { |resolution|
+
+              if resolution[0] == "absorb"
+                vector_j = vectors[resolution[1]]
+
+                vector_j.each { |vector_j_hashed_field, vector_j_values|
+                  if vector_j_hashed_field != "names_parts" && vector_j_hashed_field != "resolutions"
+                    vectors[i][vector_j_hashed_field][2] += vector_j_values[2]
+                  end
+                }
+              end
+            
+            }
+
+            vectors[i].delete("resolutions")
+
+          end
+        end
+      end
+
+      # remove marked vectors
+      vectors_removed_number = 0
+      vectors_to_remove.each { |index|
+        vectors.delete_at(index - vectors_removed_number)
+        vectors_removed_number += 1
+      }
+
+      total_response_weight = 0
+
+      vectors.each { |vector|
+
+        vector_weight = self.get_vector_weight(vector, sent_type_credentials_fields)
+
+        total_response_weight += vector_weight
+      }
+
+      vectors.each { |vector|
+
+        vector_weight = self.get_vector_weight(vector, sent_type_credentials_fields)
+        vector_probability = (vector_weight / total_response_weight) * 100
+
+        if vector_probability > PROBABILITY_THRESHOLD
+
+          compare_document = sent_document.clone
+          compare_document.delete("names")
+
+          # let's compare found vector with sent_document
+          diff_fields = []
+          validated = {}
+
+          # flip vector
+          vector_fliped = {}
+
+          vector.each { |hashed_vector_field, vector_values|
+            if hashed_vector_field != "names_parts"
+              vector_fliped[vector_values[1]] = vector_values[2]
+            end
+          }
+
+          # all fields except of names
+          compare_document.each { |compare_field, compared_value_hashed|
+            
+            compare_field_hashed = Digest::SHA512.hexdigest(compare_field)
+
+            if vector.key?(compare_field_hashed)
+            
+              vector_values = vector[compare_field_hashed]
+
+              if sent_document[vector_values[1]] != vector_values[0]
+                
+                diff_fields.push(compare_field)
+              
+              else
+
+                validated[compare_field] = {
+                  "validations_weight" => vector_values[2]
+                }
+
+              end
+
+            else
+
+              validated[compare_field] = {
+                "validations_weight" => 0
+              }
+
+            end
+          }
+
+          # names
+          
+          if vector.key?("names_parts")
+            if vector["names_parts"].key?("surname")
+
+              validated["surname"] = {
+                "vector_values"      => vector["names_parts"]["surname"],
+                "validations_weight" => vector_fliped["surname"]
+              }
+              
+            else
+              diff_fields.push("surname")
+            end
+          else
+            diff_fields.push("surname")
+          end
+
+          if vector.key?("names_parts")
+            if vector["names_parts"].key?("given_names")
+
+              validated["given_names"] = {
+                "vector_values"      => vector["names_parts"]["given_names"],
+                "validations_weight" => vector_fliped["given_names"]
+              }
+              
+            else
+              diff_fields.push("given_names")
+            end
+          else
+            diff_fields.push("given_names")
+          end
+
+          if diff_fields.length == 0
+            return {
+              "decision_made" => true,
+              "decision"      => "MATCH",
+              "validations"   => validated
+            }
+          end
+
+          return {
+            "decision_made"     => true,
+            "decision"          => "POSSIBLE_MISTAKES",
+            "possible_mistakes" => diff_fields,
+            "validations"       => validated
+          }
+
+        end
+      }
+
+      # prepare for output
+
+      vectors_fliped = []
+
+      for i in 0..(vectors.length - 1)
+
+        vector_fliped = {}
+
+        vectors[i].each { |hashed_vector_field, vector_values|
+
+          if hashed_vector_field != "names_parts"
+            val = "same"
+            if sent_document[vector_values[1]] != vector_values[0]
+              val = "different"
+            end
+            vector_fliped[vector_values[1]] = [val, vector_values[2]]
+          else
+            vector_fliped[hashed_vector_field] = vector_values
+          end
+        }
+
+        vector_raw_surname = ""
+        if vector_fliped.key?("names_parts")
+          if vector_fliped["names_parts"].key?("surname")
+            sep = ""
+            vector_fliped["names_parts"]["surname"].each { |surname_part|
+              vector_raw_surname += sep + surname_part
+              sep = " "
+            }
+          else
+            vector_raw_surname = "different"
+          end
+        else
+          vector_raw_surname = "different"
+        end
+
+        vector_raw_given_names = ""
+        if vector_fliped.key?("names_parts")
+          if vector_fliped["names_parts"].key?("given_names")
+            sep = ""
+            vector_fliped["names_parts"]["given_names"].each { |given_names_part|
+              vector_raw_given_names += sep + given_names_part
+              sep = " "
+            }
+          else
+            vector_raw_given_names = "different"
+          end
+        else
+          vector_raw_given_names = "different"
+        end
+
+        vector_fliped["surname"] = [vector_raw_surname, vector_fliped["surname"][1]]
+        vector_fliped["given_names"] = [vector_raw_given_names, vector_fliped["given_names"][1]]
+
+        vector_fliped.delete("names_parts")
+
+        vectors_fliped.push(vector_fliped)
+
+      end
+
+      return {
+        "decision_made" => false,
+        "vectors"       => vectors_fliped
+      }
+    end
+
+  end
+
+end

data/lib/vchain_client.rb

@@ -15,6 +15,8 @@ module VChainClient
     require 'vchain_client/blockchain_connection'
     require 'vchain_client/signatures'
     require 'vchain_client/blockstack_client'
+    require 'vchain_client/decision_algos/decision_algorithm.rb'
+    require 'vchain_client/decision_algos/vector_based_decision_algorithm.rb'
 
     FIELD_TYPE_TRAVEL_DOCUMENT = "travel_document"
     FIELD_TYPE_TEST_DOCUMENT = "test_document"
@@ -24,7 +26,7 @@ module VChainClient
 
     DATA_POINT_VERSION = "1"
 
-    CLIENT_LIB_VERSION = "1.0.24"
+    CLIENT_LIB_VERSION = "1.0.25"
 
     @config = nil
     @log = nil
@@ -35,7 +37,7 @@ module VChainClient
       @log = Log4r::Logger["vchain_client"]
     end 
 
-  	def hash(arr)
+  	def self.hash_doc(arr)
       arr.each { |k, v|
         if k != "names_parts"
           if k != "surname" && k != "given_names"
@@ -47,11 +49,11 @@ module VChainClient
       }
   	end
 
-    def full_hash(arr)
+    def self.full_hash(arr)
       output = {}
       
       arr.each { |k, v| 
-        if k != "names_parts"
+        if k != "names_parts" && k != "names"
           if k != "doc_hash"
             output[Digest::SHA512.hexdigest(k)] = Digest::SHA512.hexdigest(v)
           else
@@ -63,7 +65,7 @@ module VChainClient
       return output
     end
 
-    def cut(arr)
+    def self.cut(arr)
       arr.each { |k, v|
         if arr["type"] == FIELD_TYPE_TRAVEL_DOCUMENT_HASHED
           if k == "type" || k == "country_code" || k == "number" || k == "surname" || k == "given_names" || k == "birthdate" || k == "nationality" || k == "sex" || k == "birthplace" || k == "issue_date" || k == "expiry_date" || k == "authority"
@@ -83,7 +85,7 @@ module VChainClient
       }
     end
 
-    def get_doc_hash(arr)
+    def self.get_doc_hash(arr)
       if arr["type"] == FIELD_TYPE_TRAVEL_DOCUMENT_HASHED
         
         what_to_hash = ""
@@ -117,7 +119,7 @@ module VChainClient
       end
     end
 
-    def get_credentials_fields(type)
+    def self.get_credentials_fields(type)
       if type == FIELD_TYPE_TRAVEL_DOCUMENT_HASHED
         return ["type", "number", "given_names", "surname", "birthdate"]
 
@@ -133,7 +135,7 @@ module VChainClient
       return nil
     end
 
-    def get_similar_credential_sets(type)
+    def self.get_similar_credential_sets(type)
       if type == FIELD_TYPE_TRAVEL_DOCUMENT_HASHED
         output = []
         output.push(["type", "number", "surname", "birthdate"])
@@ -161,7 +163,7 @@ module VChainClient
       return nil
     end
 
-  	def get_credentials_hash(document)
+  	def self.get_credentials_hash(document)
   		if document["type"] == FIELD_TYPE_TRAVEL_DOCUMENT_HASHED
   			what_to_hash = document["type"] + document["number"] + document["given_names"] + document["surname"] + document["birthdate"]
 
@@ -265,14 +267,14 @@ module VChainClient
         raw_document["given_names"] = hashed_given_names
         raw_document["surname"] = hashed_surname
         
-        out_document = self.hash(raw_document)
+        out_document = VChainClient::Client.hash_doc(raw_document)
 
-        out_document = self.cut(out_document)
+        out_document = VChainClient::Client.cut(out_document)
 
-        doc_hash = self.get_doc_hash(out_document)
+        doc_hash = VChainClient::Client.get_doc_hash(out_document)
         out_document["doc_hash"] = doc_hash
 
-        credentials_hash = self.get_credentials_hash(out_document)
+        credentials_hash = VChainClient::Client.get_credentials_hash(out_document)
         out_document["credentials_hash"] = credentials_hash
 
         if weight > 1
@@ -533,14 +535,14 @@ module VChainClient
 
       document["given_names"] = hashed_given_names
       document["surname"] = hashed_surname
-	    
-      document = self.hash(document)
 
-      document = self.cut(document)
+      document = VChainClient::Client.hash_doc(document)
+
+      document = VChainClient::Client.cut(document)
 
-      doc_hash = self.get_doc_hash(document)
+      doc_hash = VChainClient::Client.get_doc_hash(document)
 
-      credentials_hash = self.get_credentials_hash(document)
+      credentials_hash = VChainClient::Client.get_credentials_hash(document)
 
       if weight > 1
       
@@ -741,9 +743,9 @@ module VChainClient
           raw_document.delete("names")
         end
 
-        out_document = self.hash(raw_document)
+        out_document = VChainClient::Client.hash_doc(raw_document)
 
-        out_document = self.cut(out_document)
+        out_document = VChainClient::Client.cut(out_document)
 
         if out_document["type"] == FIELD_TYPE_TRAVEL_DOCUMENT_HASHED
           out_document["names"] = []
@@ -761,7 +763,7 @@ module VChainClient
       return output
     end
 
-    def check(input, is_already_hashed = false)
+    def check(input, is_already_hashed = false, preffered_decision_algo = nil)
 
       client_id = @config["client_id"]
 
@@ -776,12 +778,10 @@ module VChainClient
       end
 
       if (!is_already_hashed)
-        document = self.hash(document)
+        document = VChainClient::Client.hash_doc(document)
       end
 
-      document = self.cut(document)
-
-      names_index = {}
+      document = VChainClient::Client.cut(document)
 
       if document["type"] == FIELD_TYPE_TRAVEL_DOCUMENT_HASHED
         document["names"] = []
@@ -792,8 +792,7 @@ module VChainClient
           if (!is_already_hashed)
             name_hash = Digest::SHA512.hexdigest(name.downcase)
           end
-          
-          names_index[name_hash] = name
+
           document["names"].push(name_hash)
         }
       end
@@ -878,313 +877,32 @@ module VChainClient
 
           return {
             "status" => "success",
-            "result" => "NO_DATA"
+            "result" => {
+              "decision_made" => true,
+              "decision"      => "NO_DATA"
+            }
           }
 
         end
 
         #
-        # analyse
+        # decision
         #
 
-        sent_type_credentials_fields = self.get_credentials_fields(sent_document["type"])
-
-
-        # 1. cut non-input fields, rebuild doc_hashes
-        # 2. build vectors out of cut documents
-
-        cut_res_docs = []
-
-        vectors = []
-
-        res["docs"].each { |res_doc|
-
-          cut_doc = {}
-          vector = {}
-
-          names_parts = {}
-          if res_doc.key?("names_parts")
-            names_parts = res_doc["names_parts"]
-
-            res_doc.delete("names_parts")
-          end
-
-          full_doc_hash = self.get_doc_hash(res_doc)
-
-          res_doc.each { |res_doc_field, res_doc_value|
-            if sent_document.key?(res_doc_field) || sent_type_credentials_fields.include?(res_doc_field)
-              cut_doc[res_doc_field] = res_doc_value
-              
-              vector[Digest::SHA512.hexdigest(res_doc_field)]  = [res_doc_value, res_doc_field, 0]
-            end
-          }
-
-          cut_doc["doc_hash"]      = self.get_doc_hash(cut_doc)
-
-          cut_doc["full_doc_hash"] = full_doc_hash
-
-          hashed_full_doc_hash = Digest::SHA512.hexdigest(full_doc_hash);
-
-          if validated_data_points.key?(hashed_full_doc_hash)
-            data_points = validated_data_points[hashed_full_doc_hash]
-
-            data_points.each { |data_point_field, data_point_value|
-              if vector.key?(data_point_field)
-                vector[data_point_field][2] += data_point_value
-              end
-            }
-          end
-
-          if !names_parts.empty?
-            cut_doc["names_parts"] = names_parts
-            vector["names_parts"]  = names_parts
-          end
-
-          vectors.push(vector)
-
-          cut_res_docs.push(cut_doc)
-        }
-
-        res["docs"] = cut_res_docs
-
-
-        # 3. combine vectors part 1 - marking => absorb smaller, merge equal
-        for i in 0..(vectors.length - 1)
-
-          vector_i = vectors[i]
-          
-          for j in i+1..(vectors.length - 1)
-
-            if j >= vectors.length
-              break
-            end
-
-            vector_j = vectors[j]
-
-            i_is_less_j = false
-            j_is_less_i = false
-
-            need_to_combine = true
-
-            vector_i.each { |vector_i_hashed_field, vector_i_values|
-              if vector_i_hashed_field != "names_parts" && vector_i_hashed_field != "resolutions"
-                if !vector_j.key?(vector_i_hashed_field)
-                  j_is_less_i = true
-                else
-                  vector_j_values = vector_j[vector_i_hashed_field]
-                  if vector_i_values[0] != vector_j_values[0]
-                    need_to_combine = false
-                    break
-                  end
-                end
-              end
-            }
-
-            vector_j.each { |vector_j_hashed_field, vector_j_values|
-              if vector_j_hashed_field != "names_parts" && vector_j_hashed_field != "resolutions"
-                if !vector_i.key?(vector_j_hashed_field)
-                  i_is_less_j = true
-                else
-                  vector_i_values = vector_i[vector_j_hashed_field]
-                  if vector_j_values[0] != vector_i_values[0]
-                    need_to_combine = false
-                    break
-                  end
-                end
-              end
-            }
-
-            if need_to_combine
-              if i_is_less_j && j_is_less_i
-                # differs, no need to combine
-
-              elsif i_is_less_j && !j_is_less_i
-                # combine i to j                
-                if !vectors[i].key?("resolutions")
-                  vectors[i]["resolutions"] = []
-                end
-                if !vectors[j].key?("resolutions")
-                  vectors[j]["resolutions"] = []
-                end
-                vectors[i]["resolutions"].push(["combine_to", j])
-                vectors[j]["resolutions"].push(["absorb", i])
-
-              elsif !i_is_less_j && j_is_less_i
-                # combine j to i
-                if !vectors[i].key?("resolutions")
-                  vectors[i]["resolutions"] = []
-                end
-                if !vectors[j].key?("resolutions")
-                  vectors[j]["resolutions"] = []
-                end
-                vectors[j]["resolutions"].push(["combine_to", i])
-                vectors[i]["resolutions"].push(["absorb", j])
-
-              else
-                # equals, combine j to i and delete j
-                if !vectors[i].key?("resolutions")
-                  vectors[i]["resolutions"] = []
-                end
-                if !vectors[j].key?("resolutions")
-                  vectors[j]["resolutions"] = []
-                end
-                vectors[j]["resolutions"].push(["combine_to", i])
-                vectors[i]["resolutions"].push(["absorb", j])
-
-              end
-            end
-          end
-        end
-
-        # 4. combine vectors part 2 - resolutions execution => absorb smaller, merge equal
-        vectors_to_remove = []
-
-        for i in 0..(vectors.length-1)
-
-          vector_i = vectors[i]
-
-          if vector_i.key?("resolutions")
-
-            need_to_delete = false
-
-            vector_i["resolutions"].each { |resolution|
-              
-              resolution_type = resolution[0]
-
-              if resolution_type == "combine_to"
-                
-                vector_i["resolutions"].each { |resolution_b|
-                  
-                  if resolution_b[0] == "absorb"
-                    if !vectors[resolution[1]].key?("resolutions")
-                      vectors[resolution[1]]["resolutions"] = []
-                    end
-
-                    # check for dublicates
-                    need_to_add = true
-
-                    vectors[resolution[1]]["resolutions"].each { |resolution_c|
-                      if resolution_c[0] == resolution_b[0] && resolution_c[1] == resolution_b[1]
-                        need_to_add = false
-                        break
-                      end
-                    }
-
-                    if need_to_add
-                      vectors[resolution[1]]["resolutions"].push(resolution_b)
-                    end
-                  end
-                }
-
-                need_to_delete = true
-              end
-            }
-
-            if need_to_delete
-              vectors_to_remove.push(i)
-            end
-          end
-        end
-
-        for i in 0..(vectors.length - 1)
-
-          vector_i = vectors[i]
-
-          if vector_i.key?("resolutions")
-            if !vectors_to_remove.include?(i)
-
-              vector_i["resolutions"].each { |resolution|
-
-                if resolution[0] == "absorb"
-                  vector_j = vectors[resolution[1]]
-
-                  vector_j.each { |vector_j_hashed_field, vector_j_values|
-                    if vector_j_hashed_field != "names_parts" && vector_j_hashed_field != "resolutions"
-                      vectors[i][vector_j_hashed_field][2] += vector_j_values[2]
-                    end
-                  }
-                end
-              
-              }
+        decisionAlgo = nil
 
-              vectors[i].delete("resolutions")
-
-            end
-          end
+        if preffered_decision_algo == nil
+          # falling to default algo
+          decisionAlgo = VChainClient::VectorBasedDecisionAlgorithm.new(@config)
         end
 
-        # remove marked vectors
-        vectors_removed_number = 0
-        vectors_to_remove.each { |index|
-          vectors.delete_at(index - vectors_removed_number)
-          vectors_removed_number += 1
-        }
-
-        # prepare for output
-
-        vectors_fliped = []
-
-        for i in 0..(vectors.length - 1)
-
-          vector_fliped = {}
-
-          vectors[i].each { |hashed_vector_field, vector_values|
-
-            if hashed_vector_field != "names_parts"
-              val = "same"
-              if sent_document[vector_values[1]] != vector_values[0]
-                val = "different"
-              end
-              vector_fliped[vector_values[1]] = [val, vector_values[2]]
-            else
-              vector_fliped[hashed_vector_field] = vector_values
-            end
-          }
-
-          vector_raw_surname = ""
-          if vector_fliped.key?("names_parts")
-            if vector_fliped["names_parts"].key?("surname")
-              sep = ""
-              vector_fliped["names_parts"]["surname"].each { |surname_part|
-                vector_raw_surname += sep + names_index[surname_part]
-                sep = " "
-              }
-            else
-              vector_raw_surname = "different"
-            end
-          else
-            vector_raw_surname = "different"
-          end
-
-          vector_raw_given_names = ""
-          if vector_fliped.key?("names_parts")
-            if vector_fliped["names_parts"].key?("given_names")
-              sep = ""
-              vector_fliped["names_parts"]["given_names"].each { |given_names_part|
-                vector_raw_given_names += sep + names_index[given_names_part]
-                sep = " "
-              }
-            else
-              vector_raw_given_names = "different"
-            end
-          else
-            vector_raw_given_names = "different"
-          end
-
-          vector_fliped["surname"] = [vector_raw_surname, vector_fliped["surname"][1]]
-          vector_fliped["given_names"] = [vector_raw_given_names, vector_fliped["given_names"][1]]
-
-          vector_fliped.delete("names_parts")
-
-          vectors_fliped.push(vector_fliped)
-
-        end
+        decision = decisionAlgo.make_decision(sent_document, res, validated_data_points)
 
         # result output
 
         return {
-          "status"  => "success",
-          "vectors" => vectors_fliped
+          "status" => "success",
+          "result" => decision
         }
 
       end
@@ -1203,8 +921,8 @@ module VChainClient
       documents_index = {}
 
       documents.each { |document|
-        hashed_doc = self.full_hash(document)
-        hashed_doc["original_doc_hash"] = self.get_doc_hash(document)
+        hashed_doc = VChainClient::Client.full_hash(document)
+        hashed_doc["original_doc_hash"] = VChainClient::Client.get_doc_hash(document)
         documents_index[hashed_doc["doc_hash"]] = hashed_doc
       }
 
@@ -1715,7 +1433,8 @@ module VChainClient
           output[data_point["doc_hash"]][data_point["field_hash"]] = 0
         end
 
-        output[data_point["doc_hash"]][data_point["field_hash"]] += 1
+        # add weight coming from the data_point
+        output[data_point["doc_hash"]][data_point["field_hash"]] += (1 * data_point["weight"].to_f)
       }
 
       return output

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vchain_client
 version: !ruby/object:Gem::Version
-  version: 1.0.24
+  version: 1.0.25
 platform: ruby
 authors:
 - Aleksandr Gorelik
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-05 00:00:00.000000000 Z
+date: 2017-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: log4r
@@ -84,6 +84,8 @@ files:
 - lib/vchain_client/blockchain_connection.rb
 - lib/vchain_client/blockcypher_blockchain_adapter.rb
 - lib/vchain_client/blockstack_client.rb
+- lib/vchain_client/decision_algos/decision_algorithm.rb
+- lib/vchain_client/decision_algos/vector_based_decision_algorithm.rb
 - lib/vchain_client/signatures.rb
 homepage: http://rubygems.org/gems/vchain_client
 licenses: