imperituroard 0.3.3 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9145a7e26b0478b84af6d549588cd403cf52080d
-  data.tar.gz: fbdc0528f7ff7e535eaa29a2ad3eba67216163be
+  metadata.gz: 1ad44807fb4cff12695580d243f54083f75abda4
+  data.tar.gz: d075e7afb11370fe50d8837282016313da1713df
 SHA512:
-  metadata.gz: 2db737b82e9d6127b475ea6c6e472d86c82857a253fb8e16e5de2c804fdded8681a4764d1c6735994c783e81da413370d95b300a498094fc98276792a623544e
-  data.tar.gz: 8e93980bda5a7d66317611c4291c62b4f094d318dd45f404196f7c5219c6fec88ae2637f00f59f0c5cc62747a56543a67d355b977209ba68ab80352b2b853e83
+  metadata.gz: b5a77c1263b5f9058143127c5daa69cf93c2c83c38c8d9c5ad5ef3d2f7bb8ea6ed12cb2e01651c5531068de6519f6fa775a8486ea6dbef4806534062576aa8aa
+  data.tar.gz: 6d8fcb8c02ece03e5e73ae3564fe81874e9da0f322622aa2a8aef7776b2d6800f964314b1a9e1ecd381e73934e8535b6b377c1f2d43ed7e970c1480b08ab6b5a

data/lib/imperituroard/projects/iot/add_functions.rb

@@ -10,7 +10,6 @@ class AdditionalFunc
   def initialize(telegram_api_url, telegram_chat_id)
     @telegram_api_url = telegram_api_url
     @telegram_chat_id = telegram_chat_id
-
   end
 
   #procedure for send log to telegram chat
@@ -33,7 +32,6 @@ class AdditionalFunc
     end
   end
 
-
   def answ_dev_query_format_process(dev_list)
     dataaa_ok = []
     dataaa_failed = []
@@ -115,5 +113,28 @@ class AdditionalFunc
 
   end
 
+  def check_input_1(login, imei_list)
+    {:code=>200, :result=>"Request completed successfully", :body=>"Data checked"}
+  end
+
+  def check_input_2(login, imei_list)
+    {:code=>200, :result=>"Request completed successfully", :body=>"Data checked"}
+  end
+
+  def check_input_3(login, imei_list)
+    {:code=>200, :result=>"Request completed successfully", :body=>"Data checked"}
+  end
+
+  def check_input_4(login, imei_list)
+    {:code=>200, :result=>"Request completed successfully", :body=>"Data checked"}
+  end
+
+  def check_input_5(login, imei_list)
+    {:code=>200, :result=>"Request completed successfully", :body=>"Data checked"}
+  end
+
+  def check_input_6(login, imei_list)
+    {:code=>200, :result=>"Request completed successfully", :body=>"Data checked"}
+  end
 
 end

data/lib/imperituroard/projects/iot/internal_functions.rb

@@ -4,9 +4,24 @@ require 'date'
 
 class InternalFunc
 
+  def datetimenow()
+    d_curr = DateTime.now
+    time_zone = 'Europe/Minsk'
+    DateTime.new
+        .in_time_zone(time_zone)
+        .change(year: d_curr.year, month: d_curr.month, day: d_curr.day, hour: d_curr.hour, min: d_curr.min, sec: d_curr.sec)
+  end
+
+  def check_pass_format(passw)
+    if passw!=nil && passw!=""
+      {:code=>200, :result=>"Request completed successfully", :body=>"Data checked"}
+    else
+      {:code=>500, :result=>"Request completed", :body=>"invalid password"}
+    end
+  end
 
   def printer_texter(text, log_level)
-    mess = {:datetime => DateTime.now, :sdk=> "imperituroard", :sdk_version=> "0.3.3", :message => text}
+    mess = {:datetime => datetimenow, :sdk=> "imperituroard", :sdk_version=> "0.3.3", :message => text}
     p mess
   end
 

data/lib/imperituroard/projects/iot/mongoconnector.rb

@@ -23,7 +23,7 @@ class MongoIot
   def audit_logger(proc_name, src_ip, input_json, output_json, real_ip)
     out_resp = {}
     begin
-      current = DateTime.now
+      current = internal_func.datetimenow
       collection = client[:audit]
       doc = {
           :proc_name => proc_name,
@@ -67,7 +67,6 @@ class MongoIot
       else
         out_resp = {:code => 404, :result => "get_profiles_by_login: Access denied. Incorrect login"}
       end
-
     rescue
       out_resp = {:code => 507, :result => "get_profiles_by_login: Unknown SDK error"}
     end
@@ -75,6 +74,38 @@ class MongoIot
     out_resp
   end
 
+
+  def get_login_info(login)
+    out_resp = {}
+    begin
+      login_profiles = []
+      req2 = []
+      result_ps = []
+      collection = client[:users]
+      collection2 = client[:device_profiles]
+      collection.find({:login => login}).each {|row|
+        login_profiles = row
+      }
+      p "login_profiles"
+      p login_profiles
+      if login_profiles != [] && login_profiles["login"] != nil && login_profiles["login"] != ""
+        passw_check = internal_func.check_pass_format(login_profiles["password"])
+        if passw_check[:code]==200
+          out_resp = {:code => 200, :result => "get_login_info: Request completed successfully", :body => login_profiles}
+        else
+          out_resp = {:code => 405, :result => "get_login_info: incorrect password"}
+        end
+      else
+        out_resp = {:code => 404, :result => "get_login_info: login not found in database"}
+      end
+    rescue
+      out_resp = {:code => 507, :result => "get_login_info: Unknown SDK error"}
+    end
+    p out_resp
+    internal_func.printer_texter(out_resp, "debug")
+    out_resp
+  end
+
   def get_imei_info_from_db(imeilist)
     out_resp = {}
     p imeilist
@@ -125,24 +156,13 @@ class MongoIot
 
   def check_login_profile_permiss(login, profile)
     out_resp = {}
-    p "profile"
-    p profile
     get_login_info = get_profiles_by_login(login)
-    p "get_login_info"
-    p get_login_info
-
     if get_login_info[:code]==200
-
-
       dst_profile = get_profile_id_by_name(profile)
-      p "dst_profile"
-      p dst_profile
       access=1
       if get_login_info[:body]!=[]
         if dst_profile!=[]
-          p "sgsgsd"
           for j in get_login_info[:body]
-            p j
             if j["profile_id"].to_i==dst_profile["profile_id"].to_i
               access=0
             end
@@ -168,16 +188,10 @@ class MongoIot
 
   def check_login_prof_perm_id_one(login, profile_id)
     out_resp = {}
-    p "profile"
-    p profile_id
     get_login_info = get_profiles_by_login(login)
-    p "get_login_info"
-    p get_login_info
     access=1
     if get_login_info[:body]!=[]
-      p "sgsgsd"
       for j in get_login_info[:body]
-        p j
         if j["profile_id"].to_i==profile_id.to_i
           access=0
         end
@@ -198,19 +212,10 @@ class MongoIot
     out_resp = {}
     res_exists = []
     imei_list_res = get_imei_info_from_db(imei_list)
-    p imei_list_res
-    p "imei_list"
     for k in imei_list_res[:body]
-      p k
       res_exists.append(k["imei"])
     end
-    p "aaaa"
-    p imei_list
-    p res_exists
     not_ex = imei_list - res_exists
-    p "not_ex"
-    p not_ex
-    p res_exists
     out_resp = {:code => 200, :result => "check_imei_exists: Request completed successfully",
                 :body => {:exists => res_exists, :not_exists => not_ex}}
     internal_func.printer_texter(out_resp, "debug")
@@ -221,7 +226,6 @@ class MongoIot
   def imei_insert_list(imei_list)
     begin
       collection = client[:device_imei]
-      p imei_list
       for l in imei_list
         doc = {
             imei: l,
@@ -245,7 +249,6 @@ class MongoIot
   def imei_insert_list2(imei_list)
     begin
       collection = client[:device_imei]
-      p imei_list
       for l in imei_list
         doc = {
             imei: l,
@@ -283,17 +286,10 @@ class MongoIot
       id = ""
       begin
         info = get_imei_info_from_db([imei])
-        p info
-        p "info"
         if info[:body]==[]
           out_resp = {:code => 505, :result => "get_profile_name_from_imei: get_imei_info_from_db returned empty list from database. IMEIS not found"}
         else
-          p "fshhsdf"
-          p info
           id = info[:body][0]["profile"]
-          p id
-          p "id"
-
           begin
             p id
             res = get_profile_name_by_id(id)

data/lib/imperituroard/version.rb

@@ -1,3 +1,3 @@
 module Imperituroard
-  VERSION = "0.3.3"
+  VERSION = "0.3.4"
 end

data/lib/imperituroard.rb

@@ -139,96 +139,103 @@ class Iot
     input_json = {:login => login, :imei_list => imei_list}
     resp_out = {}
     begin
+
       thr1 = Thread.new do
+        if add_functions_connector.check_input_1(login, imei_list)[:code]==200
 
-        imei = []
-        list1 = {}
-        for_insert = []
-        not_processed_list = []
-        processed_list = []
+          imei = []
+          list1 = {}
+          for_insert = []
+          not_processed_list = []
+          processed_list = []
 
-        for ii in imei_list
-          list1[ii["imei"]] = ii
-          imei.append(ii["imei"])
-        end
-        list_checked = mongo_client.check_imei_exists(imei)
-        for ss in list_checked[:body][:exists]
-          not_processed_list.append({:imei => ss, :error => "Device exists in database"})
-        end
+          for ii in imei_list
+            list1[ii["imei"]] = ii
+            imei.append(ii["imei"])
+          end
+          list_checked = mongo_client.check_imei_exists(imei)
+          for ss in list_checked[:body][:exists]
+            not_processed_list.append({:imei => ss, :error => "Device exists in database"})
+          end
 
-        for jj in list_checked[:body][:not_exists]
-          begin
-            get_login_info = mongo_client.check_login_prof_perm_id_one(login, list1[jj]["profile"])[:code]
-            if get_login_info==200
-              for_insert.append(list1[jj])
-            else
-              not_processed_list.append({:imei => list1[jj], :error => "Permission denied for this profile"})
+          for jj in list_checked[:body][:not_exists]
+            begin
+              get_login_info = mongo_client.check_login_prof_perm_id_one(login, list1[jj]["profile"])[:code]
+              if get_login_info==200
+                for_insert.append(list1[jj])
+              else
+                not_processed_list.append({:imei => list1[jj], :error => "Permission denied for this profile"})
+              end
+            rescue
+              not_processed_list.append({:imei => list1[jj], :error => "Unknown error"})
             end
-          rescue
-            not_processed_list.append({:imei => list1[jj], :error => "Unknown error"})
           end
-        end
 
-        begin
-          added_on_iot_platf = []
-          if for_insert!=[]
-            ##Logic for IOT Platform connection###
-
-            credentials = mongo_client.get_iot_oceanconnect_credent(login)
-
-            if credentials[:code]==200
-              for aaa in for_insert
-                begin
-                  dev_name = aaa["imei"].to_s
-
-                  #get {"model"=>"BGT_PPMC", "ManufacturerID"=>"unknown", "ManufacturerNAME"=>"unknown", "device_type"=>"unknown"}
-                  #from database
-                  model_data = mongo_client.get_device_type_info_by_model(aaa["device_type"])
-                  resss = hua_aceanconnect_connector.add_new_device_on_huawei(credentials[:body][:app_id],
-                                                                              credentials[:body][:secret],
-                                                                              aaa["imei"],
-                                                                              dev_name,
-                                                                              aaa["description"],
-                                                                              model_data[:body]["device_type"],
-                                                                              aaa["profile"],
-                                                                              model_data[:body]["ManufacturerID"],
-                                                                              model_data[:body]["ManufacturerNAME"],
-                                                                              model_data[:body]["model"]
-                  )
-                  if resss[:code]=="200"
-                    s1 = aaa
-                    s1[:huadata] = resss
-                    s1[:created] = DateTime.now
-                    added_on_iot_platf.append(s1)
-                  else
-                    not_processed_list.append({:imei => aaa["imei"], :error => resss})
+          begin
+            added_on_iot_platf = []
+            if for_insert!=[]
+              ##Logic for IOT Platform connection###
+
+              credentials = mongo_client.get_iot_oceanconnect_credent(login)
+
+              if credentials[:code]==200
+                for aaa in for_insert
+                  begin
+                    dev_name = aaa["imei"].to_s
+
+                    #get {"model"=>"BGT_PPMC", "ManufacturerID"=>"unknown", "ManufacturerNAME"=>"unknown", "device_type"=>"unknown"}
+                    #from database
+                    model_data = mongo_client.get_device_type_info_by_model(aaa["device_type"])
+                    resss = hua_aceanconnect_connector.add_new_device_on_huawei(credentials[:body][:app_id],
+                                                                                credentials[:body][:secret],
+                                                                                aaa["imei"],
+                                                                                dev_name,
+                                                                                aaa["description"],
+                                                                                model_data[:body]["device_type"],
+                                                                                aaa["profile"],
+                                                                                model_data[:body]["ManufacturerID"],
+                                                                                model_data[:body]["ManufacturerNAME"],
+                                                                                model_data[:body]["model"]
+                    )
+                    if resss[:code]=="200"
+                      s1 = aaa
+                      s1[:huadata] = resss
+                      s1[:created] = DateTime.now
+                      added_on_iot_platf.append(s1)
+                    else
+                      not_processed_list.append({:imei => aaa["imei"], :error => resss})
+                    end
+                  rescue
+                    not_processed_list.append({:imei => aaa["imei"], :error => "Unknown error with insertion imei on IOT platform"})
                   end
-                rescue
-                  not_processed_list.append({:imei => aaa["imei"], :error => "Unknown error with insertion imei on IOT platform"})
                 end
-              end
 
-              #########end iot platform logic#######
+                #########end iot platform logic#######
 
-              mongo_client.imei_insert_list(added_on_iot_platf)
-              resp_out = {:code => 200, :result => "Data processed", :body => {:imei_processed => added_on_iot_platf, :error_list => not_processed_list}}
-            else
-              resp_out = {:code => 400, :result => "IOT platform credentials not found"}
-            end
+                mongo_client.imei_insert_list(added_on_iot_platf)
+                resp_out = {:code => 200, :result => "Data processed", :body => {:imei_processed => added_on_iot_platf, :error_list => not_processed_list}}
+              else
+                resp_out = {:code => 400, :result => "IOT platform credentials not found"}
+              end
 
 
-          else
-            resp_out = {:code => 202, :result => "Nothing for insertion", :body => {:imei_processed => added_on_iot_platf, :error_list => not_processed_list}}
+            else
+              resp_out = {:code => 202, :result => "Nothing for insertion", :body => {:imei_processed => added_on_iot_platf, :error_list => not_processed_list}}
 
+            end
+          rescue
+            resp_out = {:code => 505, :result => "Error with database communication"}
           end
-        rescue
-          resp_out = {:code => 505, :result => "Error with database communication"}
+
+        else
+          resp_out = {:code => 509, :result => "Input data invalid"}
         end
       end
     rescue
       resp_out = {:code => 507, :result => "Unknown SDK error"}
     end
     thr1.join
+
     mongo_client.audit_logger("add_device_to_profile", remote_ip, input_json, resp_out, real_ip)
     resp_out
   end
@@ -245,47 +252,52 @@ class Iot
     input_json = {:login => login, :imei_list => imei_list}
     ime_list_approved = []
     ime_list_notapproved = []
-    resp = {}
+    resp_out = {}
     begin
       thr2 = Thread.new do
-        for t in imei_list
-          prof_name1 = mongo_client.get_profile_name_from_imei(t)
-          if prof_name1[:code]==200
-            begin
-              permiss1 = mongo_client.check_login_profile_permiss(login, prof_name1[:body]["profile"])
-              p "permiss1"
-              p permiss1
-              if permiss1[:code]==200
-                ime_list_approved.append(t)
-              else
-                ime_list_notapproved.append({:imei => t, :error => permiss1})
+        if add_functions_connector.check_input_2(login, imei_list)[:code]==200
+
+          for t in imei_list
+            prof_name1 = mongo_client.get_profile_name_from_imei(t)
+            if prof_name1[:code]==200
+              begin
+                permiss1 = mongo_client.check_login_profile_permiss(login, prof_name1[:body]["profile"])
+                p "permiss1"
+                p permiss1
+                if permiss1[:code]==200
+                  ime_list_approved.append(t)
+                else
+                  ime_list_notapproved.append({:imei => t, :error => permiss1})
+                end
+              rescue
+                ime_list_notapproved.append({:imei => t, :error => {:code => 405, :result => "Unknown error when check_login_profile_permiss imei #{t.to_s}"}})
               end
-            rescue
-              ime_list_notapproved.append({:imei => t, :error => {:code => 405, :result => "Unknown error when check_login_profile_permiss imei #{t.to_s}"}})
+            else
+              ime_list_notapproved.append({:imei => t, :error => prof_name1})
             end
-          else
-            ime_list_notapproved.append({:imei => t, :error => prof_name1})
           end
-        end
-        begin
-          if ime_list_approved != []
-            data = mongo_client.get_imei_info_from_db(ime_list_approved)
+          begin
+            if ime_list_approved != []
+              data = mongo_client.get_imei_info_from_db(ime_list_approved)
 
-            resp = {:code => 200, :result => "Request completed successfully", :data => {:approved_list => data, :unapproved_list => ime_list_notapproved}}
+              resp_out = {:code => 200, :result => "Request completed successfully", :data => {:approved_list => data, :unapproved_list => ime_list_notapproved}}
 
-          else
-            resp = {:code => 404, :result => "Invalidate data", :data => {:approved_list => [], :unapproved_list => ime_list_notapproved}}
+            else
+              resp_out = {:code => 404, :result => "Invalidate data", :data => {:approved_list => [], :unapproved_list => ime_list_notapproved}}
+            end
+          rescue
+            resp_out = {:code => 504, :result => "Unsuccessfully data transfer"}
           end
-        rescue
-          resp = {:code => 504, :result => "Unsuccessfully data transfer"}
+        else
+          resp_out = {:code => 509, :result => "Input data invalid"}
         end
       end
     rescue
-      resp = {:code => 507, :result => "Unknown SDK error"}
+      resp_out = {:code => 507, :result => "Unknown SDK error"}
     end
     thr2.join
-    mongo_client.audit_logger("device_find", remote_ip, input_json, resp, real_ip)
-    resp
+    mongo_client.audit_logger("device_find", remote_ip, input_json, resp_out, real_ip)
+    resp_out
   end
 
   #!3 device modify, change imei
@@ -297,140 +309,143 @@ class Iot
   #++
   def imei_replace(login, im_list)
     input_json = {:login => login, :imei_list => im_list}
+    resp_out = {}
 
-    li_new_imei = []
-    list1 = {}
+    begin
 
-    #dictionary for imeis which not processed. Final dictionary
-    not_processed_list = []
+      thr3 = Thread.new do
 
-    #dictionary for devices which was processed correctly
-    processed_list = []
+        if add_functions_connector.check_input_3(login, imei_list)[:code]==200
 
-    #array for translations from old imei to new
-    old_new_translation = {}
+          li_new_imei = []
+          list1 = {}
 
-    approved_list = []
-    resp_out = {}
+          #dictionary for imeis which not processed. Final dictionary
+          not_processed_list = []
 
-    #old_imei_list for query to iot platform for data request
-    step1_approved_dict_old=[]
+          #dictionary for devices which was processed correctly
+          processed_list = []
 
-    #form dictionary for processing
-    for pr1 in im_list
-      p "pr1"
-      p pr1
-      li_new_imei.append(pr1["imei_new"])
-      list1[pr1["imei_new"]]=pr1["imei_old"]
-      old_new_translation[pr1["imei_old"]]=pr1["imei_new"]
-    end
+          #array for translations from old imei to new
+          old_new_translation = {}
 
-    p list1
+          approved_list = []
 
-    begin
 
-      thr3 = Thread.new do
+          #old_imei_list for query to iot platform for data request
+          step1_approved_dict_old=[]
 
-        #check if imei_new exists in database. If exists - not process this imei
-        list_checked = mongo_client.check_imei_exists(li_new_imei)
+          #form dictionary for processing
+          for pr1 in im_list
+            li_new_imei.append(pr1["imei_new"])
+            list1[pr1["imei_new"]]=pr1["imei_old"]
+            old_new_translation[pr1["imei_old"]]=pr1["imei_new"]
+          end
 
-        internal_func.printer_texter({:function => "imei_replace Step1", :list_checked => list_checked}, "debug")
+          #check if imei_new exists in database. If exists - not process this imei
+          list_checked = mongo_client.check_imei_exists(li_new_imei)
 
-        #add already exists new IMEI in error dictionary
-        for ss in list_checked[:body][:exists]
-          not_processed_list.append({:record => {:imei_old => list1[ss], :imei_new => ss}, :error => "New IMEI exists in database"})
-        end
+          internal_func.printer_texter({:function => "imei_replace Step1", :list_checked => list_checked}, "debug")
 
-        #new_imei list which processed step1
-        step2_list = list_checked[:body][:not_exists]
+          #add already exists new IMEI in error dictionary
+          for ss in list_checked[:body][:exists]
+            not_processed_list.append({:record => {:imei_old => list1[ss], :imei_new => ss}, :error => "New IMEI exists in database"})
+          end
 
-        internal_func.printer_texter({:function => "imei_replace Step2", :step2_list => step2_list}, "debug")
+          #new_imei list which processed step1
+          step2_list = list_checked[:body][:not_exists]
 
+          internal_func.printer_texter({:function => "imei_replace Step2", :step2_list => step2_list}, "debug")
 
-        for a in step2_list
-          begin
 
-            #step3 checking permission for writing for imei list
-            prof_name1 = mongo_client.get_profile_name_from_imei(list1[a])
+          for a in step2_list
+            begin
 
-            internal_func.printer_texter({:function => "imei_replace Step3", :prof_name1 => prof_name1}, "debug")
+              #step3 checking permission for writing for imei list
+              prof_name1 = mongo_client.get_profile_name_from_imei(list1[a])
 
-            if prof_name1[:code]==200
-              permiss1 = mongo_client.check_login_profile_permiss(login, prof_name1[:body]["profile"])[:code]
-              internal_func.printer_texter({:function => "imei_replace Step4", :permiss1 => permiss1, :input => prof_name1[:body]["profile"]}, "debug")
-              if permiss1==200
+              internal_func.printer_texter({:function => "imei_replace Step3", :prof_name1 => prof_name1}, "debug")
 
-                approved_list.append({:imei_old => list1[a], :imei_new => a})
-                step1_approved_dict_old.append(list1[a])
+              if prof_name1[:code]==200
+                permiss1 = mongo_client.check_login_profile_permiss(login, prof_name1[:body]["profile"])[:code]
+                internal_func.printer_texter({:function => "imei_replace Step4", :permiss1 => permiss1, :input => prof_name1[:body]["profile"]}, "debug")
+                if permiss1==200
 
+                  approved_list.append({:imei_old => list1[a], :imei_new => a})
+                  step1_approved_dict_old.append(list1[a])
+
+                else
+                  not_processed_list.append({:record => {:imei_old => list1[a], :imei_new => a}, :error => "Old IMEI modification denied"})
+                end
               else
-                not_processed_list.append({:record => {:imei_old => list1[a], :imei_new => a}, :error => "Old IMEI modification denied"})
+                not_processed_list.append({:record => {:imei_old => list1[a], :imei_new => a}, :error => "Old IMEI not exists in database"})
               end
-            else
-              not_processed_list.append({:record => {:imei_old => list1[a], :imei_new => a}, :error => "Old IMEI not exists in database"})
+            rescue
+              not_processed_list.append({:record => {:imei_old => list1[a], :imei_new => a}, :error => "Unknown error"})
             end
-          rescue
-            not_processed_list.append({:record => {:imei_old => list1[a], :imei_new => a}, :error => "Unknown error"})
           end
-        end
 
-        internal_func.printer_texter({:function => "imei_replace Step5", :not_processed_list => not_processed_list, :input => list1, :approved_list => approved_list, :step1_approved_dict_old => step1_approved_dict_old}, "debug")
+          internal_func.printer_texter({:function => "imei_replace Step5", :not_processed_list => not_processed_list, :input => list1, :approved_list => approved_list, :step1_approved_dict_old => step1_approved_dict_old}, "debug")
 
 
-        ##Logic for IOT Platform connection###
+          ##Logic for IOT Platform connection###
 
-        list_from_iot = self.get_info_by_imeilist_from_iot(login, step1_approved_dict_old)
+          list_from_iot = self.get_info_by_imeilist_from_iot(login, step1_approved_dict_old)
 
-        internal_func.printer_texter({:function => "imei_replace Step6", :list_from_iot => list_from_iot, :description => "data from iot platform by old imei"}, "debug")
+          internal_func.printer_texter({:function => "imei_replace Step6", :list_from_iot => list_from_iot, :description => "data from iot platform by old imei"}, "debug")
 
-        #processing data. modifying data on iot platform and mongoDB
-        if list_from_iot[:code]=="200"
+          #processing data. modifying data on iot platform and mongoDB
+          if list_from_iot[:code]=="200"
 
-          for ard in list_from_iot[:body]["devices"]
-            p ard
-            new_data_cur_dev = {}
-            mongo_answer = {}
-            current_old_dev = ard["deviceInfo"]["nodeId"]
-            current_device_id = ard["deviceId"]
-            new_data_cur_dev = ard["deviceInfo"]
-            new_data_cur_dev["nodeId"] = old_new_translation[current_old_dev.to_i].to_s
+            for ard in list_from_iot[:body]["devices"]
+              p ard
+              new_data_cur_dev = {}
+              mongo_answer = {}
+              current_old_dev = ard["deviceInfo"]["nodeId"]
+              current_device_id = ard["deviceId"]
+              new_data_cur_dev = ard["deviceInfo"]
+              new_data_cur_dev["nodeId"] = old_new_translation[current_old_dev.to_i].to_s
 
-            credentials = mongo_client.get_iot_oceanconnect_credent(login)
+              credentials = mongo_client.get_iot_oceanconnect_credent(login)
 
-            if credentials[:code]==200
-              flag_remove=0
-              flag_create=0
-              remove_answer = hua_aceanconnect_connector.remove_one_device_from_iot(credentials[:body][:app_id], credentials[:body][:secret], current_device_id)
-              create_answer = hua_aceanconnect_connector.add_new_device_on_huawei2(credentials[:body][:app_id], credentials[:body][:secret], new_data_cur_dev)
+              if credentials[:code]==200
+                flag_remove=0
+                flag_create=0
+                remove_answer = hua_aceanconnect_connector.remove_one_device_from_iot(credentials[:body][:app_id], credentials[:body][:secret], current_device_id)
+                create_answer = hua_aceanconnect_connector.add_new_device_on_huawei2(credentials[:body][:app_id], credentials[:body][:secret], new_data_cur_dev)
 
-              if remove_answer[:code]=="204" || remove_answer[:code]=="200"
-                flag_remove=1
-              end
-              if create_answer[:code]=="200"
-                flag_create=1
-              end
-              if flag_remove==1 && flag_create==1
-                mongo_answer = mongo_client.device_modify_any_attr_mongo(current_old_dev.to_i, {:imei => old_new_translation[current_old_dev.to_i], :huadata => {:body => create_answer[:body]}, :updated => DateTime.now})
-                processed_list.append({:imei_old => current_old_dev.to_i, :imei_new => old_new_translation[current_old_dev.to_i]})
-              else
-                not_processed_list.append({:record => {:imei_old => current_old_dev.to_i, :imei_new => old_new_translation[current_old_dev.to_i]}, :error => "Failed for provisioning to IOT platform"})
-              end
+                if remove_answer[:code]=="204" || remove_answer[:code]=="200"
+                  flag_remove=1
+                end
+                if create_answer[:code]=="200"
+                  flag_create=1
+                end
+                if flag_remove==1 && flag_create==1
+                  mongo_answer = mongo_client.device_modify_any_attr_mongo(current_old_dev.to_i, {:imei => old_new_translation[current_old_dev.to_i], :huadata => {:body => create_answer[:body]}, :updated => DateTime.now})
+                  processed_list.append({:imei_old => current_old_dev.to_i, :imei_new => old_new_translation[current_old_dev.to_i]})
+                else
+                  not_processed_list.append({:record => {:imei_old => current_old_dev.to_i, :imei_new => old_new_translation[current_old_dev.to_i]}, :error => "Failed for provisioning to IOT platform"})
+                end
 
-              internal_func.printer_texter({:function => "imei_replace Step7", :remove_answer => remove_answer, :create_answer => create_answer, :mongo_answer => mongo_answer, :description => "processing imei #{current_old_dev.to_s}"}, "debug")
+                internal_func.printer_texter({:function => "imei_replace Step7", :remove_answer => remove_answer, :create_answer => create_answer, :mongo_answer => mongo_answer, :description => "processing imei #{current_old_dev.to_s}"}, "debug")
 
-            else
-              approved_list=[]
+              else
+                approved_list=[]
+              end
             end
+
+          else
+            approved_list=[]
           end
 
-        else
-          approved_list=[]
-        end
+          if approved_list!=[]
+            resp_out = {:code => 200, :result => "Request completed successfully", :data => {:approved_list => processed_list, :unapproved_list => not_processed_list}}
+          else
+            resp_out = {:code => 202, :result => "Nothing to do", :data => {:approved_list => processed_list, :unapproved_list => not_processed_list}}
+          end
 
-        if approved_list!=[]
-          resp_out = {:code => 200, :result => "Request completed successfully", :data => {:approved_list => processed_list, :unapproved_list => not_processed_list}}
         else
-          resp_out = {:code => 202, :result => "Nothing to do", :data => {:approved_list => processed_list, :unapproved_list => not_processed_list}}
+          resp_out = {:code => 509, :result => "Input data invalid"}
         end
 
       end
@@ -462,50 +477,54 @@ class Iot
 
     begin
       thr4 = Thread.new do
-        prof_name = mongo_client.get_profile_name_from_imei(imei)
-        if prof_name[:code]==200
-          permiss = mongo_client.check_login_profile_permiss(login, prof_name[:body]["profile"])
-          if permiss[:code]==200
 
-            ##Logic for IOT Platform connection###
+        if add_functions_connector.check_input_4(login, imei_list)[:code]==200
 
+          prof_name = mongo_client.get_profile_name_from_imei(imei)
+          if prof_name[:code]==200
+            permiss = mongo_client.check_login_profile_permiss(login, prof_name[:body]["profile"])
+            if permiss[:code]==200
+
+              ##Logic for IOT Platform connection###
 
-            credentials = mongo_client.get_iot_oceanconnect_credent(login)
-            resp = {}
+              credentials = mongo_client.get_iot_oceanconnect_credent(login)
+              resp = {}
 
-            if credentials[:code]==200
+              if credentials[:code]==200
 
-              imei_data = mongo_client.get_imei_info_from_db([imei])
-              if imei_data[:body]!=[]
-                ans = hua_aceanconnect_connector.remove_one_device_from_iot(credentials[:body][:app_id], credentials[:body][:secret], imei_data[:body][0]["huadata"]["body"]["deviceId"])
-                p ans
-                if ans[:code]=="204" or ans[:code]=="200"
-                  resp = mongo_client.device_remove_single_mongo(imei)
+                imei_data = mongo_client.get_imei_info_from_db([imei])
+                if imei_data[:body]!=[]
+                  ans = hua_aceanconnect_connector.remove_one_device_from_iot(credentials[:body][:app_id], credentials[:body][:secret], imei_data[:body][0]["huadata"]["body"]["deviceId"])
+                  p ans
+                  if ans[:code]=="204" or ans[:code]=="200"
+                    resp = mongo_client.device_remove_single_mongo(imei)
+                  else
+                    resp = {:code => 500, :result => "Unknown IOT platform error", :body => ans}
+                  end
                 else
-                  resp = {:code => 500, :result => "Unknown IOT platform error", :body => ans}
+                  resp_out = {:code => 404, :result => "Data not found"}
                 end
-              else
-                resp_out = {:code => 404, :result => "Data not found"}
-              end
 
-              #########end iot platform logic#######
+                #########end iot platform logic#######
 
-              if resp[:code]==200
-                resp_out = {:code => 200, :result => "Request completed successfully"}
+                if resp[:code]==200
+                  resp_out = {:code => 200, :result => "Request completed successfully"}
+                else
+                  resp_out=resp
+                end
               else
-                resp_out=resp
+                resp_out = {:code => 400, :result => "IOT platform credentials not found"}
               end
-
             else
-              resp_out = {:code => 400, :result => "IOT platform credentials not found"}
+              resp_out=permiss
             end
-
           else
-            resp_out=permiss
+            resp_out=prof_name
           end
         else
-          resp_out=prof_name
+          resp_out = {:code => 509, :result => "Input data invalid"}
         end
+
       end
 
     rescue
@@ -536,51 +555,50 @@ class Iot
     processed = []
     begin
       thr5 = Thread.new do
-        for p in newdevice_list
-          prof_name = mongo_client.get_profile_name_from_imei(p[:imei])
-
-          if prof_name[:code]==200
-            p "prof_name"
-            p prof_name
-            permiss = mongo_client.check_login_profile_permiss(login, prof_name[:body]["profile"])
-            if permiss[:code]==200
-
-              ##Logic for IOT Platform connection###
-              credentials = mongo_client.get_iot_oceanconnect_credent(login)
-              resp = {}
+        if add_functions_connector.check_input_5(login, imei_list)[:code]==200
 
-              if credentials[:code]==200
-                imei_data = mongo_client.get_imei_info_from_db([p[:imei]])
-                if imei_data[:body]!=[]
-                  ans =hua_aceanconnect_connector.modify_location_iot(credentials[:body][:app_id], credentials[:body][:secret], imei_data[:body][0]["huadata"]["body"]["deviceId"], p[:address])
+          for p in newdevice_list
+            prof_name = mongo_client.get_profile_name_from_imei(p[:imei])
 
-                  internal_func.printer_texter({:function => "device_add_address Step2", :ans => ans, :descrition=>"answer from hua IOT", :input=>{:did=>imei_data[:body][0]["huadata"]["body"]["deviceId"], :appid=>credentials[:body][:app_id], :secret=>credentials[:body][:secret], :address=>p[:address]}}, "debug")
+            if prof_name[:code]==200
+              permiss = mongo_client.check_login_profile_permiss(login, prof_name[:body]["profile"])
+              if permiss[:code]==200
 
-                  p ans
-                end
+                ##Logic for IOT Platform connection###
+                credentials = mongo_client.get_iot_oceanconnect_credent(login)
+                resp = {}
 
-              end
+                if credentials[:code]==200
+                  imei_data = mongo_client.get_imei_info_from_db([p[:imei]])
+                  if imei_data[:body]!=[]
+                    ans =hua_aceanconnect_connector.modify_location_iot(credentials[:body][:app_id], credentials[:body][:secret], imei_data[:body][0]["huadata"]["body"]["deviceId"], p[:address])
 
+                    internal_func.printer_texter({:function => "device_add_address Step2", :ans => ans, :descrition => "answer from hua IOT", :input => {:did => imei_data[:body][0]["huadata"]["body"]["deviceId"], :appid => credentials[:body][:app_id], :secret => credentials[:body][:secret], :address => p[:address]}}, "debug")
+                  end
 
-              #########end iot platform logic#######
+                end
 
+                #########end iot platform logic#######
 
-              resp = mongo_client.device_modify_attr_mongo(p[:imei], p[:address])
-              if resp[:code]==200
-                processed.append({:imei => p[:imei]})
+                resp = mongo_client.device_modify_attr_mongo(p[:imei], p[:address])
+                if resp[:code]==200
+                  processed.append({:imei => p[:imei]})
+                end
+              else
+                not_processed.append({:imei => p[:imei], :address => p[:address], :error => permiss})
               end
             else
-              not_processed.append({:imei => p[:imei], :address => p[:address], :error => permiss})
+              not_processed.append({:imei => p[:imei], :address => p[:address], :error => prof_name})
             end
-          else
-            not_processed.append({:imei => p[:imei], :address => p[:address], :error => prof_name})
           end
-        end
 
-        if processed!=[]
-          resp_out = {:code => 200, :result => "Request completed successfully", :body => {:imei_processed => processed, :error_list => not_processed}}
+          if processed!=[]
+            resp_out = {:code => 200, :result => "Request completed successfully", :body => {:imei_processed => processed, :error_list => not_processed}}
+          else
+            resp_out = {:code => 202, :result => "Nothing processed", :body => {:imei_processed => processed, :error_list => not_processed}}
+          end
         else
-          resp_out = {:code => 202, :result => "Nothing processed", :body => {:imei_processed => processed, :error_list => not_processed}}
+          resp_out = {:code => 509, :result => "Input data invalid"}
         end
       end
     rescue
@@ -608,66 +626,105 @@ class Iot
 
     begin
 
-      for g in device_list
-        p g
+      thr6 = Thread.new do
 
-        prof_name1 = mongo_client.get_profile_name_from_imei(g["imei"])
-        p prof_name1
+        if add_functions_connector.check_input_5(login, imei_list)[:code]==200
 
-        if prof_name1[:code]==200
-          p prof_name1
-          permiss1 = mongo_client.check_login_profile_permiss(login, prof_name1[:body]["profile"])
-          p "permiss1"
-          p permiss1
-          if permiss1[:code]==200
+          for g in device_list
 
-            if g["attributes"].key?("profile")
-              permiss2 = mongo_client.check_login_profile_permiss(login, g["attributes"]["profile"])[:code]
+            prof_name1 = mongo_client.get_profile_name_from_imei(g["imei"])
 
-              if permiss2==200
+            if prof_name1[:code]==200
+              permiss1 = mongo_client.check_login_profile_permiss(login, prof_name1[:body]["profile"])
+              if permiss1[:code]==200
+
+                if g["attributes"].key?("profile")
+                  permiss2 = mongo_client.check_login_profile_permiss(login, g["attributes"]["profile"])[:code]
+
+                  if permiss2==200
 
-                attr = g["attributes"]
-                #mod_attr = {}
+                    attr = g["attributes"]
+                    #mod_attr = {}
 
-                if attr.key?("profile")
-                  if attr["profile"].is_a? Integer
-                    p "Ok"
+                    if attr.key?("profile")
+                      if attr["profile"].is_a? Integer
+                        p "Ok"
+                      else
+                        p new = mongo_client.get_profile_id_by_name(attr["profile"])
+                        attr["profile"] = new["profile_id"]
+                      end
+                    end
+                    mongo_client.device_modify_any_attr_mongo(g["imei"], attr)
+                    processed.append(g["imei"])
                   else
-                    p new = mongo_client.get_profile_id_by_name(attr["profile"])
-                    attr["profile"] = new["profile_id"]
+                    not_processed.append({:imei => g["imei"], :description => "New profile permission error", :error => permiss2})
                   end
+
+                else
+                  attr = g["attributes"]
+                  mongo_client.device_modify_any_attr_mongo(g["imei"], attr)
+                  processed.append(g["imei"])
                 end
-                p attr
-                mongo_client.device_modify_any_attr_mongo(g["imei"], attr)
-                processed.append(g["imei"])
               else
-                not_processed.append({:imei => g["imei"], :description => "New profile permission error", :error => permiss2})
+                not_processed.append({:imei => g["imei"], :description => "Old profile permission error", :error => permiss1})
               end
 
             else
-              attr = g["attributes"]
-              mongo_client.device_modify_any_attr_mongo(g["imei"], attr)
-              processed.append(g["imei"])
+              not_processed.append({:imei => g["imei"], :error => prof_name1})
             end
-          else
-            not_processed.append({:imei => g["imei"], :description => "Old profile permission error", :error => permiss1})
-          end
 
+          end
+          resp_out = {:code => 200, :result => "Request completed successfully", :body => {:imei_processed => processed, :error_list => not_processed}}
         else
-          not_processed.append({:imei => g["imei"], :error => prof_name1})
+          resp_out = {:code => 509, :result => "Input data invalid"}
         end
 
       end
-      resp_out = {:code => 200, :result => "Request completed successfully", :body => {:imei_processed => processed, :error_list => not_processed}}
 
     rescue
       resp_out = {:code => 507, :result => "Unknown SDK error"}
     end
+    thr6.join
     mongo_client.audit_logger("device_remove", remote_ip, input_json, resp_out, real_ip)
     resp_out
   end
 
 
+  #7 procedure for subscriber autorization
+  def autorize_subscriber(login, password)
+    input_json = {:login => login, :password => password}
+    resp_out = {}
+    thr7 = Thread.new do
+      begin
+        login_inform = mongo_client.get_login_info(login)
+        if login_inform[:code]==200
+          pass_mongo = login_inform[:body]["password"]
+          if pass_mongo == password
+            resp_out = {:code => 200, :result => "Access granted"}
+          else
+            resp_out = {:code => 400, :result => "Access denied"}
+          end
+        else
+          resp_out = {:code => 401, :result => "Access denied. Incorrect login"}
+        end
+      rescue
+        resp_out = {:code => 507, :result => "Unknown SDK error"}
+      end
+    end
+    thr7.join
+    mongo_client.audit_logger("autorize_subscriber", remote_ip, input_json, resp_out, real_ip)
+    resp_out
+  end
+
+  def get_available_profiles(login)
+
+  end
+
+  def get_available_types(login)
+
+  end
+
+
   def answ_dev_query_format_process(dev_list)
     add_functions_connector.answ_dev_query_format_process(dev_list)
   end
@@ -717,17 +774,17 @@ class Iot
   end
 
   def test()
-    ddd = MongoIot.new(mongoip, mongoport, mongo_database)
+    #ddd = MongoIot.new(mongoip, mongoport, mongo_database)
     #ddd.get_profiles_by_login("test")
 
     ff = [131234123412341233, 131234123127341233]
     #ddd.get_imsi_info_from_db(ff)
 
     #p ddd.get_profile_id_by_name("1341241")
-    p ddd.get_device_type_info_by_model("BGT_PPMC11")
-  end
-
+    #p ddd.get_device_type_info_by_model("BGT_PPMC11")
 
+    #fff = HuaIot.new("134.17.93.4", "443", "/Users/imperituroard/Desktop/cert.crt", "/Users/imperituroard/Desktop/key.pem")
+    #p fff.querying_device_id("Cd1v0k2gTBCbpQlMVlW1FVqOSqga", "eWllZpHgXgvgDAQlJjWs4QXaR94a", [91234])
+  end
 
 end
-

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: imperituroard
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.4
 platform: ruby
 authors:
 - Dzmitry Buynovskiy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-04-17 00:00:00.000000000 Z
+date: 2020-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -158,6 +158,7 @@ files:
 - imperituroard.gemspec
 - lib/.DS_Store
 - lib/imperituroard.rb
+- lib/imperituroard/.DS_Store
 - lib/imperituroard/phpipamcps.rb
 - lib/imperituroard/phpipamdb.rb
 - lib/imperituroard/projects/iot/add_functions.rb