vchain_client 1.0.28 → 1.0.29

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3c98b88bea6b4a5dc8db9b6efb9c6b74fcabf3ee
-  data.tar.gz: a93f3af8542151ba9a562980f312a7ed9a000a1b
+  metadata.gz: e1f4807b48a4f9413739fa4e70e8893a2983c735
+  data.tar.gz: d1c9938626a2eee59176a25805b8c347d14d3024
 SHA512:
-  metadata.gz: 04ab0083dab3c2f3eaa16c8ae3064902d000d50105429f2c69665ad5addb79880f0e69c72dde3c9e362c2bcb8c7f35cecdf5289dac99662cdb041fe99e9730e7
-  data.tar.gz: da8febf81dd61908d400830f1c9a7a818cd84a4591b6d3749a4eee1f7cfd1e4f08aec5c0bb9d5706c2738df32577528f68cbaba99bcee2043c92b31c3915921b
+  metadata.gz: d88b075784a56721ee059dd5dd6f326e61088d82bf8e34e41cdf4f9b3a4d4f082625066b29b1725faa34f28d7eada236fb5ebd32dd71edb2c0627b04cabb1480
+  data.tar.gz: 883ae1b950241dc09852446011119a43111a937185194efacb0c38a9c703dd3e4a4f1f2170005d7186e1e5416c29a33f7c8ad55c6988d37cde1c38a364dcb2d1

data/lib/vchain_client.rb

@@ -26,7 +26,7 @@ module VChainClient
 
     DATA_POINT_VERSION = "1"
 
-    CLIENT_LIB_VERSION = "1.0.26"
+    CLIENT_LIB_VERSION = "1.0.29"
 
     @config = nil
     @log = nil
@@ -138,13 +138,25 @@ module VChainClient
     def self.get_similar_credential_sets(type)
       if type == FIELD_TYPE_TRAVEL_DOCUMENT_HASHED
         output = []
+        # given_names
         output.push(["type", "number", "surname", "birthdate"])
+        # surname
         output.push(["type", "number", "given_names", "birthdate"])
+        # number
         output.push(["type", "given_names", "surname", "birthdate"])
+        # birthdate
         output.push(["type", "number", "given_names", "surname"])
+        # given_names + number
+        output.push(["type", "surname", "birthdate"])
+        # surname + number
+        output.push(["type", "given_names", "birthdate"])
+        # given_names + birthdate
         output.push(["type", "number", "surname"])
+        # surname + birthdate
         output.push(["type", "number", "given_names"])
+        # given_names + surname
         output.push(["type", "number", "birthdate"])
+
         return output
 
       elsif type == FIELD_TYPE_TEST_DOCUMENT_HASHED
@@ -961,6 +973,21 @@ module VChainClient
 
       data_points.each { |data_point|
 
+        if @config.key?("do_not_check") && @config["do_not_check"] == true
+
+          if !output.key?(data_point["doc_hash"])
+            output[data_point["doc_hash"]] = {}
+          end
+          if !output[data_point["doc_hash"]].key?(data_point["field_hash"])
+            output[data_point["doc_hash"]][data_point["field_hash"]] = 0
+          end
+
+          # add weight coming from the data_point
+          output[data_point["doc_hash"]][data_point["field_hash"]] += (1 * data_point["weight"].to_f)
+
+          next
+        end
+
         if !data_point.key?("blockchain_reciepts")
           if @log.error?
             @log.error("[check] not a valid data point - no blockchain_reciepts key")

data/lib/vchain_client/decision_algos/vector_based_decision_algorithm.rb

@@ -303,90 +303,113 @@ module VChainClient
         total_response_weight += vector_weight
       }
 
+      diff_variants = []
+
       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")
+        compare_document = sent_document.clone
 
-          # let's compare found vector with sent_document
-          diff_fields = []
-          validated = {}
+        sent_names = compare_document["names"].clone
 
-          # 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
-          }
+        compare_document.delete("names")
 
-          # all fields except of names
-          compare_document.each { |compare_field, compared_value_hashed|
-            
-            compare_field_hashed = Digest::SHA512.hexdigest(compare_field)
+        # let's compare found vector with sent_document
+        diff_fields = []
+        validated = {}
 
-            if vector.key?(compare_field_hashed)
-            
-              vector_values = vector[compare_field_hashed]
+        # flip vector
+        vector_fliped = {}
 
-              if sent_document[vector_values[1]] != vector_values[0]
-                
-                diff_fields.push(compare_field)
-              
-              else
+        vector.each { |hashed_vector_field, vector_values|
+          if hashed_vector_field != "names_parts"
+            vector_fliped[vector_values[1]] = vector_values[2]
+          end
+        }
 
-                validated[compare_field] = {
-                  "validations_weight" => vector_values[2]
-                }
+        # all fields except of names
+        compare_document.each { |compare_field, compared_value_hashed|
+          
+          compare_field_hashed = Digest::SHA512.hexdigest(compare_field)
 
-              end
+          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" => 0
+                "validations_weight" => vector_values[2]
               }
 
             end
-          }
 
-          # names
-          
-          if vector.key?("names_parts")
-            if vector["names_parts"].key?("surname")
+          else
 
-              validated["surname"] = {
-                "vector_values"      => vector["names_parts"]["surname"],
-                "validations_weight" => vector_fliped["surname"]
-              }
-              
-            else
-              diff_fields.push("surname")
-            end
+            validated[compare_field] = {
+              "validations_weight" => 0
+            }
+
+          end
+        }
+
+        # names
+
+        surname_matched = false
+        given_names_matched = false
+        
+        if vector.key?("names_parts")
+          if vector["names_parts"].key?("surname")
+
+            validated["surname"] = {
+              "vector_values"      => vector["names_parts"]["surname"],
+              "validations_weight" => vector_fliped["surname"]
+            }
+
+            surname_matched = true
+            
           else
             diff_fields.push("surname")
           end
+        else
+          diff_fields.push("surname")
+        end
 
-          if vector.key?("names_parts")
-            if vector["names_parts"].key?("given_names")
+        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
+            validated["given_names"] = {
+              "vector_values"      => vector["names_parts"]["given_names"],
+              "validations_weight" => vector_fliped["given_names"]
+            }
+
+            given_names_matched = true
+            
           else
             diff_fields.push("given_names")
           end
+        else
+          diff_fields.push("given_names")
+        end
+
+        if surname_matched && given_names_matched
+          diff = sent_names - vector["names_parts"]["surname"] - vector["names_parts"]["given_names"]
+          
+          if diff.length > 0
+            diff_fields.push("surname")
+            diff_fields.push("given_names")
+          end
+        end
+
+        if vector_probability > PROBABILITY_THRESHOLD
+          
+          ## COULD MAKE A DECISION
 
           if diff_fields.length == 0
             return {
@@ -402,74 +425,41 @@ module VChainClient
             "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|
+        diff_variants.push(diff_fields)
+      }
 
-          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
-        }
+      ## ANALYSE DIFF_VARIANTS
+      all_the_same = true
 
-        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
+      prev_diff_fields = nil
 
-        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"
+      diff_variants.each { |diff_fields|
+        if prev_diff_fields != nil
+          if prev_diff_fields.uniq.sort != diff_fields.uniq.sort
+            all_the_same = false
+            break
           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)
+        prev_diff_fields = diff_fields
+      }
 
+      if all_the_same
+        return {
+          "decision_made"     => true,
+          "decision"          => "POSSIBLE_MISTAKES",
+          "possible_mistakes" => prev_diff_fields
+        }
       end
 
       return {
-        "decision_made" => false,
-        "vectors"       => vectors_fliped
+        "decision_made"     => true,
+        "decision"          => "POSSIBLE_MISTAKES",
+        "possible_mistakes" => diff_variants
       }
+
     end
 
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vchain_client
 version: !ruby/object:Gem::Version
-  version: 1.0.28
+  version: 1.0.29
 platform: ruby
 authors:
 - Aleksandr Gorelik
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-22 00:00:00.000000000 Z
+date: 2017-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: log4r