vchain_client 1.0.21 → 1.0.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b7db396f9ccc111daf170ae178b5dcc5a7dbe42a
-  data.tar.gz: 74baca0c18f217d70c2a5b191f89911b9aa13533
+  metadata.gz: 65340391974700636c2d48e309226cae1e472797
+  data.tar.gz: 132f978b2d7e25377f9efdbc108e4f744a0d74a3
 SHA512:
-  metadata.gz: d5043acbd5dbfb6b5848a606404d2e01ce8236c720f666b024adeca956425dd98717b9ec9669c4a991b2c595ab5e42be91efee201faa2c573b469744c143a377
-  data.tar.gz: 83bfc37f83bc377462189da905466490a444d5f842bbc530bb47d022a23d0e92fcacb085a2ab1e42d4047aa9859f6e32c3835e37ee3f49c8cdb024670c00c71e
+  metadata.gz: 110cf09f708a3b23d8de059a9cbb9d14fbfbc48f7dbd4ef7a1f1a3097cb42345fc2b6ed62116fecd60553ad1f2e9a9779914991f0a9bc6602469a6205a4683f1
+  data.tar.gz: 959022c40a2975fb038ac62599bcdb320d4101d318fbe82565e3d470770171e8905fd9603356cd6836879b2bd8b717dc09ed90735d1d382967c9bff696bba78c

data/lib/vchain_client.rb

@@ -37,10 +37,12 @@ module VChainClient
 
   	def hash(arr)
       arr.each { |k, v|
-        if k != "surname" && k != "given_names"
-      	  arr[k] = Digest::SHA512.hexdigest(v.downcase)
-        else
-          arr[k] = Digest::SHA512.hexdigest(v)
+        if k != "names_parts"
+          if k != "surname" && k != "given_names"
+        	  arr[k] = Digest::SHA512.hexdigest(v.downcase)
+          else
+            arr[k] = Digest::SHA512.hexdigest(v)
+          end
         end
       }
   	end
@@ -49,10 +51,12 @@ module VChainClient
       output = {}
       
       arr.each { |k, v| 
-        if k != "doc_hash"
-          output[Digest::SHA512.hexdigest(k)] = Digest::SHA512.hexdigest(v)
-        else
-          output[k] = Digest::SHA512.hexdigest(v)
+        if k != "names_parts"
+          if k != "doc_hash"
+            output[Digest::SHA512.hexdigest(k)] = Digest::SHA512.hexdigest(v)
+          else
+            output[k] = Digest::SHA512.hexdigest(v)
+          end
         end
       }
 
@@ -220,7 +224,7 @@ module VChainClient
   	def add_data_point(point_type, input, weight = 1)
 
     	client_id = @config["client_id"]
-    	api_url = @config["api"]["url"] + "v0.1/addDataPoint/"
+    	api_url = @config["api"]["url"] + "v0.2/addDataPoint/"
 
 	  	time = Time.now.getutc
 	  	timestamp = time.to_i
@@ -439,7 +443,7 @@ module VChainClient
 
       client_id = @config["client_id"]
 
-      api_url = @config["api"]["url"] + "v0.1/check/";
+      api_url = @config["api"]["url"] + "v0.2/check/";
 
       document = input
 
@@ -455,10 +459,14 @@ module VChainClient
 
       document = self.cut(document)
 
+      names_index = {}
+
       if document["type"] == FIELD_TYPE_TRAVEL_DOCUMENT_HASHED
         document["names"] = []
         names.each { |name|
-          document["names"].push(Digest::SHA512.hexdigest(name.downcase))
+          name_hash = Digest::SHA512.hexdigest(name.downcase)
+          names_index[name_hash] = name
+          document["names"].push(name_hash)
         }
       end
 
@@ -528,38 +536,6 @@ module VChainClient
 
         # success result
 
-        if sent_document.key?("names")
-
-          real_surname = ""
-
-          real_given_name = ""
-          
-          if res.key?("names") && res["names"].is_a?(Hash)
-
-            if res["names"].key?("given_names")
-              sep = "";
-              res["names"]["given_names"].each { |found_given_name|
-                real_given_name += sep + found_given_name
-                sep = " "
-              }
-            end
-
-            if res["names"].key?("surname")
-              sep = "";
-              res["names"]["surname"].each { |found_surname|
-                real_surname += sep + found_surname
-                sep = " "
-              }
-            end
-
-          end
-
-          sent_document["given_names"] = Digest::SHA512.hexdigest(real_given_name)
-          sent_document["surname"] = Digest::SHA512.hexdigest(real_surname)
-
-          sent_document.delete("names")
-        end
-
         validated_data_points = self.validate_data_points(res["data_points"], res["docs"])
 
         if validated_data_points.length == 0
@@ -573,289 +549,317 @@ module VChainClient
           }
 
           return {
-            "status"    => "success",
-            "validated" => result
+            "status"       => "success",
+            "validated"    => result,
+            "hashed_input" => sent_document
           }
 
         end
 
+        #
         # analyse
+        #
 
-        new_res_docs = []
-
-        res_docs_index = {}
-
-        # cut and index
-        res["docs"].each { |res_doc|
-
-          full_doc_hash = self.get_doc_hash(res_doc)
-
-          play_doc = {}
-          res_doc.each { |field, value|
-            if sent_document.key?(field)
-              play_doc[field] = value
-            end
-          }
-
-          res_doc_credentials_hash = self.get_credentials_hash(play_doc)
-
-          if !res_docs_index.key?(res_doc_credentials_hash)
-            res_docs_index[res_doc_credentials_hash] = []
-          end
-
-          play_doc["doc_hash"]      = self.get_doc_hash(play_doc)
-
-          play_doc["full_doc_hash"] = full_doc_hash
-
-          res_docs_index[res_doc_credentials_hash].push(play_doc)
-
-          new_res_docs.push(play_doc)
-        }
-
-        res["docs"] = new_res_docs
-
+        sent_type_credentials_fields = self.get_credentials_fields(sent_document["type"])
 
-        sent_doc_hash = self.get_doc_hash(sent_document)
 
-        sent_credentials_hash = self.get_credentials_hash(sent_document)
+        # 1. cut non-input fields, rebuild doc_hashes
+        # 2. build vectors out of cut documents
 
-        hashed_sent_doc = self.full_hash(sent_document)
+        cut_res_docs = []
 
-        hashed_sent_doc_hash = Digest::SHA512.hexdigest(sent_doc_hash)
+        vectors = []
 
-        # trying to find exact match by doc_hash
-
-        if validated_data_points.key?(hashed_sent_doc_hash)
-          
-          # exact match found by doc_hash
-
-          result = {}
-
-          exact_match = validated_data_points[hashed_sent_doc_hash]
-
-          sent_document.each { |field, value|
-            
-            hashed_field = Digest::SHA512.hexdigest(field)
+        res["docs"].each { |res_doc|
 
-            if exact_match.key?(hashed_field)
+          cut_doc = {}
+          vector = {}
 
-              result[field] = exact_match[hashed_field]
+          names_parts = {}
+          if res_doc.key?("names_parts")
+            names_parts = res_doc["names_parts"]
 
-            else
+            res_doc.delete("names_parts")
+          end
 
-              result[field] = 0
+          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
-
-          }
-
-          return {
-            "status"    => "success",
-            "validated" => result
           }
 
-        else
-
-          # search by credentials_hash
-          
-          found_docs = []
-          if res_docs_index.key?(sent_credentials_hash)
-            found_docs = res_docs_index[sent_credentials_hash]
-          end
-
-          if found_docs.length > 0
+          cut_doc["doc_hash"]      = self.get_doc_hash(cut_doc)
 
-            # matches found by credentials
+          cut_doc["full_doc_hash"] = full_doc_hash
 
-            result = {}
+          hashed_full_doc_hash = Digest::SHA512.hexdigest(full_doc_hash);
 
-            possible_mistakes = []
+          if validated_data_points.key?(hashed_full_doc_hash)
+            data_points = validated_data_points[hashed_full_doc_hash]
 
-            cred_fields = self.get_credentials_fields(sent_document["type"]);
+            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
 
-            non_cred_fields_index = {}
+          if !names_parts.empty?
+            cut_doc["names_parts"] = names_parts
+            vector["names_parts"]  = names_parts
+          end
 
-            found_docs.each { |cred_doc|
+          vectors.push(vector)
 
-              cred_doc_hash = cred_doc["full_doc_hash"]#self.get_doc_hash(cred_doc)
-              cred_doc_hash = Digest::SHA512.hexdigest(cred_doc_hash)
+          cut_res_docs.push(cut_doc)
+        }
 
-              cred_doc_exact_match = validated_data_points[cred_doc_hash]
+        res["docs"] = cut_res_docs
 
-              # fill credential fields
-              cred_fields.each { |cred_field|
 
-                cred_field_hashed = Digest::SHA512.hexdigest(cred_field)
+        # 3. combine vectors part 1 - marking => absorb smaller, merge equal
+        for i in 0..(vectors.length - 1)
 
-                if !result.key?(cred_field)
-                  result[cred_field] = 0
-                end
+          vector_i = vectors[i]
+          
+          for j in i+1..(vectors.length - 1)
 
-                if cred_doc_exact_match.key?(cred_field_hashed)
-                  result[cred_field] += cred_doc_exact_match[cred_field_hashed]
-                end
+            if j >= vectors.length
+              break
+            end
 
-              }
+            vector_j = vectors[j]
 
-              # fill non credential fields
-              cred_doc.each { |field, value|
-                
-                if !cred_fields.include?(field) && field != "doc_hash"
+            i_is_less_j = false
+            j_is_less_i = false
 
-                  non_cred_field_hashed = Digest::SHA512.hexdigest(field)
-                  
-                  if !non_cred_fields_index.key?(field)
-                    non_cred_fields_index[field] = {}
-                  end
+            need_to_combine = true
 
-                  if !non_cred_fields_index[field].key?(value)
-                    non_cred_fields_index[field][value] = 0
+            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
+            }
 
-                  if cred_doc_exact_match.key?(non_cred_field_hashed)
-                    non_cred_fields_index[field][value] += cred_doc_exact_match[non_cred_field_hashed]
+            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
             }
 
-            non_cred_fields_index.each { |field, values|
-
-              if sent_document.key?(field)
+            if need_to_combine
+              if i_is_less_j && j_is_less_i
+                # differs, no need to combine
 
-                if values.length == 1
+              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])
 
-                  values.take(1).each { |value, validated_count|
-                    if value == sent_document[field]
-                      result[field] = validated_count
-                    else
-                      possible_mistakes.push(field)
-                    end
-                  }
+              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
-                  possible_mistakes.push(field)
+              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
 
-            }
-
-            return {
-              "status"            => "success",
-              "possible_mistakes" => possible_mistakes,
-              "validated"         => result
-            }
-
-          else
-
-            # search for possible errors in credentials
+        # 4. combine vectors part 2 - resolutions execution => absorb smaller, merge equal
+        vectors_to_remove = []
 
-            similar_sets = self.get_similar_credential_sets(sent_document["type"])
+        for i in 0..(vectors.length-1)
 
-            result = {}
-            possible_mistakes = []
+          vector_i = vectors[i]
 
-            other_fields_index = {}
+          if vector_i.key?("resolutions")
 
-            similar_sets.each { |lookup_set|
+            need_to_delete = false
 
-              lookup_set_match_found = false
+            vector_i["resolutions"].each { |resolution|
+              
+              resolution_type = resolution[0]
 
-              res["docs"].each { |res_doc|
+              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
 
-                is_matching = true
+                    # check for dublicates
+                    need_to_add = true
 
-                lookup_set.each { |lookup_field|
-                  sent_doc_val = sent_document[lookup_field]
-                  res_doc_val = res_doc[lookup_field]
+                    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 sent_doc_val != res_doc_val
-                    is_matching = false
-                    break
+                    if need_to_add
+                      vectors[resolution[1]]["resolutions"].push(resolution_b)
+                    end
                   end
                 }
 
-                if is_matching
-                  matching_doc_hash = self.get_doc_hash(res_doc)
-                  matching_doc_hash = Digest::SHA512.hexdigest(matching_doc_hash)
-
-                  matching_exact_match = validated_data_points[matching_doc_hash]
-
-                  lookup_set.each { |lookup_field|
+                need_to_delete = true
+              end
+            }
 
-                    lookup_field_hashed = Digest::SHA512.hexdigest(lookup_field)
+            if need_to_delete
+              vectors_to_remove.push(i)
+            end
+          end
+        end
 
-                    result[lookup_field] = matching_exact_match[lookup_field_hashed]
-                  }
+        for i in 0..(vectors.length - 1)
 
-                  res_doc.each { |field, value|
-                    
-                    if !lookup_set.include?(field) && field != "doc_hash"
+          vector_i = vectors[i]
 
-                      other_field_hashed = Digest::SHA512.hexdigest(field)
-                      
-                      if !other_fields_index.key?(field)
-                        other_fields_index[field] = {}
-                      end
+          if vector_i.key?("resolutions")
+            if !vectors_to_remove.include?(i)
 
-                      if !other_fields_index[field].key?(value)
-                        other_fields_index[field][value] = 0
-                      end
+              vector_i["resolutions"].each { |resolution|
 
-                      if matching_exact_match.key?(other_field_hashed)
-                        other_fields_index[field][value] += matching_exact_match[other_field_hashed]
-                      end
+                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
-
                   }
-
-                  lookup_set_match_found = true
                 end
+              
               }
 
-              if lookup_set_match_found
-                break
-              end
+              vectors[i].delete("resolutions")
 
-            }
+            end
+          end
+        end
 
-            other_fields_index.each { |field, values|
+        # remove marked vectors
+        vectors_removed_number = 0
+        vectors_to_remove.each { |index|
+          vectors.delete_at(index - vectors_removed_number)
+          vectors_removed_number += 1
+        }
 
-              if sent_document.key?(field)
+        # prepare for output
 
-                if values.length == 1
+        vectors_fliped = []
 
-                  values.take(1).each { |value, validated_count|
-                    if value == sent_document[field]
-                      result[field] = validated_count
-                    else
-                      possible_mistakes.push(field)
-                    end
-                  }
+        for i in 0..(vectors.length - 1)
 
-                else
-                  possible_mistakes.push(field)
-                end
+          vector_fliped = {}
 
-              end
+          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
+          }
 
-            return {
-              "status"            => "success",
-              "possible_mistakes" => possible_mistakes,
-              "validated"         => result
-            }
+          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
 
+        # result output
+
+        return {
+          "status"  => "success",
+          "vectors" => vectors_fliped
+        }
+
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vchain_client
 version: !ruby/object:Gem::Version
-  version: 1.0.21
+  version: 1.0.22
 platform: ruby
 authors:
 - Aleksandr Gorelik
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-27 00:00:00.000000000 Z
+date: 2017-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: log4r