imperituroard 0.5.9 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dd14223003e59a7d5e907811784e45156363c086
-  data.tar.gz: 53254977a65f45d29edfc93d527b71307b97bcd6
+  metadata.gz: 64ac99c5a41209df78fa5f319ec47a51cb28b05b
+  data.tar.gz: 004ea48aa310c5d3159ffa8f93b6451f6105fe0a
 SHA512:
-  metadata.gz: '059dd82d5c64924e88897d2685170dc7de79c333c3c1ba367d7f0897604cb554bf145cd3b20fc7fc014bb87c03f0dad42c48ac00fdf874d674535b7236afc45b'
-  data.tar.gz: 7b9f74f90c3cdf4c3286464622f8e4f4fd0792880039c3c7877a32ec94040ea38c883e65c8e51f1271fa13486f16990eaacd667308418bcae4514db46aa6e523
+  metadata.gz: 97de046b4032c0751a046c4e1f57cbaffafd63936e53bfa08bcca6dc7216b6a5f73dcf1a68715c9a0a21b4f4ff5e1c116b3fabe0f450a264962543e68b6055b3
+  data.tar.gz: 62ad29d69a43d0b0574c5249ac6777bc153a10472b9cce01298a80e27c8c956b6776aa86eef9d558d87acd1d260d5f7ca66428fa12ac8cfead71aab7fb0a7383

data/lib/imperituroard.rb

@@ -107,42 +107,47 @@ class Pipam
 end
 
 class Iot
-  attr_accessor :mongoip,
-                :mongoport,
-                :iotip,
-                :mongo_database,
-                :iotplatform_ip,
-                :iotplatform_port,
-                :cert_path,
-                :key_path,
+  attr_accessor :param_all,
                 :mongo_client,
                 :add_functions_connector,
-                :real_ip, #real ip address of procedure caller
-                :remote_ip, #ip address of balancer
+                #:real_ip, #real ip address of procedure caller
+                #:remote_ip, #ip address of balancer
                 :hua_aceanconnect_connector,
                 :internal_func,
                 :iot_connector
 
-  def initialize(mongoip, mongoport, iotip, mongo_database,
-                 iotplatform_ip, iotplatform_port, cert_path, key_path, telegram_api_url, telegram_chat_id, real_ip, remote_ip)
-    @mongoip = mongoip
-    @mongoport = mongoport
-    @iotip = iotip
-    @mongo_database = mongo_database
-    @iotplatform_ip = iotplatform_ip
-    @iotplatform_port = iotplatform_port
-    @cert_path = cert_path
-    @key_path = key_path
-    @mongo_client = MongoIot.new(mongoip, mongoport, mongo_database)
+  def initialize(mongoip,
+                 mongoport,
+                 iotip,
+                 mongo_database,
+                 iotplatform_ip,
+                 iotplatform_port,
+                 cert_path,
+                 key_path,
+                 telegram_api_url,
+                 telegram_chat_id
+    #real_ip,
+    #remote_ip
+  )
+    @param_all = {:mongoip => mongoip,
+                  :mongoport => mongoport,
+                  :iotip => iotip,
+                  :mongo_database => mongo_database,
+                  :iotplatform_ip => iotplatform_ip,
+                  :cert_path => cert_path,
+                  :key_path => key_path
+    }
+    @mongo_client = MongoIot.new(param_all[:mongoip], param_all[:mongoport], param_all[:mongo_database])
     @add_functions_connector = AdditionalFunc.new(telegram_api_url, telegram_chat_id)
-    @real_ip = real_ip
-    @remote_ip = remote_ip
-    @hua_aceanconnect_connector = HuaIot.new(iotplatform_ip, iotplatform_port, cert_path, key_path)
+    #@real_ip = real_ip
+    #@remote_ip = remote_ip
+    @hua_aceanconnect_connector = HuaIot.new(iotplatform_ip, iotplatform_port, cert_path, key_path, param_all[:mongoip], param_all[:mongoport], param_all[:mongo_database])
     @internal_func = InternalFunc.new
-    @iot_connector = IotFunctions_2.new(mongoip, mongoport, iotip, mongo_database,
-                                        iotplatform_ip, iotplatform_port, cert_path, key_path, telegram_api_url, telegram_chat_id, real_ip, remote_ip)
+    @iot_connector = IotFunctions_2.new(param_all[:mongoip], param_all[:mongoport], iotip, param_all[:mongo_database],
+                                        iotplatform_ip, iotplatform_port, cert_path, key_path, telegram_api_url, telegram_chat_id)
   end
 
+
   #error list
 
   #:code => 507, :result => "Unknown SDK error"
@@ -157,8 +162,8 @@ class Iot
   #massive commands
   #+++
   #iot logic added
-  def add_device_to_profile(login, imei_list)
-    iot_connector.add_device_to_prof_2(login, imei_list)
+  def add_device_to_profile(login, imei_list, real_ip, remote_ip)
+    iot_connector.add_device_to_prof_2(login, imei_list, real_ip, remote_ip)
   end
 
 
@@ -169,8 +174,8 @@ class Iot
   # imei
   # imei_list =[41234,23452345,132412]
   #++
-  def device_find(login, imei_list)
-    iot_connector.device_find_2(login, imei_list)
+  def device_find(login, imei_list, real_ip, remote_ip)
+    iot_connector.device_find_2(login, imei_list, real_ip, remote_ip)
   end
 
   #!3 device modify, change imei
@@ -180,8 +185,8 @@ class Iot
   #massive commands
   #im_list = [{"imei_old"=>7967843245667, "imei_new"=>7967843245665}]
   #++
-  def imei_replace(login, im_list)
-    iot_connector.imei_replace_2(login, im_list)
+  def imei_replace(login, im_list, real_ip, remote_ip)
+    iot_connector.imei_replace_2(login, im_list, real_ip, remote_ip)
   end
 
   #!!4 remove device
@@ -192,8 +197,8 @@ class Iot
   #login="test"
   #+++
   #IOT logic added
-  def device_remove(login, imei)
-    iot_connector.device_remove_2(login, imei)
+  def device_remove(login, imei, real_ip, remote_ip)
+    iot_connector.device_remove_2(login, imei, real_ip, remote_ip)
   end
 
 
@@ -204,8 +209,8 @@ class Iot
   #newdevice_list=[{:imei=>7967843245665, :address=>"Golubeva51"}]
   #+++
   #iot platform integration completed
-  def device_add_address(login, newdevice_list)
-    iot_connector.device_add_address_2(login, newdevice_list)
+  def device_add_address(login, newdevice_list, real_ip, remote_ip)
+    iot_connector.device_add_address_2(login, newdevice_list, real_ip, remote_ip)
   end
 
   #6 add service by SPA
@@ -215,38 +220,42 @@ class Iot
   #msisdn
   #newdevice_list=[{:imei=>7967843245665, :attributes=>{:address=>"Golubeva51", :profile=>"wqeqcqeqwev", :msisdn=>375298766719, :imsi=>25702858586756875}}]
   #+
-  def add_service(login, device_list)
-    iot_connector.add_service_2(login, device_list)
+  def add_service(login, device_list, real_ip, remote_ip)
+    iot_connector.add_service_2(login, device_list, real_ip, remote_ip)
   end
 
-
   #7 procedure for subscriber autorization
-  def autorize_subscriber(login, password)
-    iot_connector.autorize_subscriber_2(login, password)
+  def autorize_subscriber(login, password, real_ip, remote_ip)
+    iot_connector.autorize_subscriber_2(login, password, real_ip, remote_ip)
   end
 
-
   #8 get available profiles for login
-  def get_available_profiles(login)
-    iot_connector.get_available_prof_2(login)
+  def get_available_profiles(login, real_ip, remote_ip)
+    iot_connector.get_available_prof_2(login, real_ip, remote_ip)
   end
 
-
   #9 get available types for login
-  def get_available_types(login)
-    iot_connector.get_available_types_2(login)
+  def get_available_types(login, real_ip, remote_ip)
+    iot_connector.get_available_types_2(login, real_ip, remote_ip)
   end
 
-
   #10 get info for device type
-  def get_info_data_type(type)
-    iot_connector.get_info_data_type_2(type)
+  def get_info_data_type(type, real_ip, remote_ip)
+    iot_connector.get_info_data_type_2(type, real_ip, remote_ip)
   end
 
-
   #11 get info for profile
-  def get_info_data_profile(profile)
-    iot_connector.get_info_data_profile_2(profile)
+  def get_info_data_profile(profile, real_ip, remote_ip)
+    iot_connector.get_info_data_profile_2(profile, real_ip, remote_ip)
+  end
+
+  #13 replace data for imei. Replace Type and Profile
+  #new procedure 2020-06-06
+  #params =
+  # {"autorization"=>{"login"=>"test", "token"=>"token"}, "datalist"=>[{"imei"=>"524523654366", "new_profile"=>"3", "new_type"=>"1000001"}, {"imei"=>"53623413423", "new_profile"=>"1", "new_type"=>"1000003"}]}
+  # answer = {:code=>200, :result=>"Success", :body=>{:processednum=>1, :failednum=>1, :deviceserr=>[{:failedimei=>524523654366}]}}
+  def set_data_replace(soapgw_params, real_ip, remote_ip)
+    iot_connector.set_data_replace_2(soapgw_params, real_ip, remote_ip)
   end
 
 
@@ -258,7 +267,6 @@ class Iot
     iot_connector.test1278493
   end
 
-
 end
 
 
@@ -402,4 +410,4 @@ class Ukaz60Automation_2
     ukaz60_func.no_pasaran
   end
 
-end
+end

data/lib/imperituroard/projects/iot.rb

@@ -17,34 +17,44 @@ class IotFunctions_2
 
   attr_accessor :mongoip,
                 :mongoport,
-                :iotip,
-                :mongo_database,
-                :iotplatform_ip,
-                :iotplatform_port,
+                #:iotip,
+                #:mongo_database,
+                #:iotplatform_ip,
+                #:iotplatform_port,
                 :cert_path,
                 :key_path,
                 :mongo_client,
                 :add_functions_connector,
-                :real_ip, #real ip address of procedure caller
-                :remote_ip, #ip address of balancer
+                #:real_ip, #real ip address of procedure caller
+                #:remote_ip, #ip address of balancer
                 :hua_aceanconnect_connector,
                 :internal_func
 
-  def initialize(mongoip, mongoport, iotip, mongo_database,
-                 iotplatform_ip, iotplatform_port, cert_path, key_path, telegram_api_url, telegram_chat_id, real_ip, remote_ip)
+  def initialize(mongoip,
+                 mongoport,
+                 iotip,
+                 mongo_database,
+                 iotplatform_ip,
+                 iotplatform_port,
+                 cert_path,
+                 key_path,
+                 telegram_api_url,
+                 telegram_chat_id
+    #real_ip, remote_ip
+  )
     @mongoip = mongoip
     @mongoport = mongoport
-    @iotip = iotip
-    @mongo_database = mongo_database
-    @iotplatform_ip = iotplatform_ip
-    @iotplatform_port = iotplatform_port
+    #@iotip = iotip
+    #@mongo_database = mongo_database
+    #@iotplatform_ip = iotplatform_ip
+    #@iotplatform_port = iotplatform_port
     @cert_path = cert_path
     @key_path = key_path
     @mongo_client = MongoIot.new(mongoip, mongoport, mongo_database)
     @add_functions_connector = AdditionalFunc.new(telegram_api_url, telegram_chat_id)
-    @real_ip = real_ip
-    @remote_ip = remote_ip
-    @hua_aceanconnect_connector = HuaIot.new(iotplatform_ip, iotplatform_port, cert_path, key_path)
+    #@real_ip = real_ip
+    #@remote_ip = remote_ip
+    @hua_aceanconnect_connector = HuaIot.new(iotplatform_ip, iotplatform_port, cert_path, key_path, mongoip, mongoport, mongo_database)
     @internal_func = InternalFunc.new
   end
 
@@ -57,7 +67,7 @@ class IotFunctions_2
   #massive commands
   #+++
   #iot logic added
-  def add_device_to_prof_2(login, imei_list)
+  def add_device_to_prof_2(login, imei_list, real_ip, remote_ip)
     input_json = {:login => login, :imei_list => imei_list}
     resp_out = {}
     begin
@@ -144,24 +154,21 @@ class IotFunctions_2
                                                                                 model_data[:body]["model"]
                     )
                     if resss[:code]=="200"
-
                       if resss[:body].key?("error_code") && resss[:body]["error_code"] != 200
                         not_processed_list.append({:imei => aaa["imei"], :error => resss})
                       else
                         s1 = aaa
                         s1[:huadata] = resss
                         s1[:created] = DateTime.now
+                        s1[:type] = s1["device_type"]
                         added_on_iot_platf.append(s1)
                       end
-
                     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
-
-
                   #########end iot platform logic#######
 
                 else
@@ -177,16 +184,12 @@ class IotFunctions_2
               else
                 resp_out = {:code => 202, :result => "Empty list. Nothing for insertion", :body => {:imei_processed => added_on_iot_platf, :error_list => not_processed_list}}
               end
-
-
             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
-
         else
           resp_out = {:code => 509, :result => "Input data invalid"}
         end
@@ -211,7 +214,7 @@ class IotFunctions_2
   # imei
   # imei_list =[41234,23452345,132412]
   #++
-  def device_find_2(login, imei_list)
+  def device_find_2(login, imei_list, real_ip, remote_ip)
     input_json = {:login => login, :imei_list => imei_list}
     ime_list_approved = []
     ime_list_notapproved = []
@@ -274,7 +277,7 @@ class IotFunctions_2
   #massive commands
   #im_list = [{"imei_old"=>7967843245667, "imei_new"=>7967843245665}]
   #++
-  def imei_replace_2(login, im_list)
+  def imei_replace_2(login, im_list, real_ip, remote_ip)
     input_json = {:login => login, :imei_list => im_list}
     resp_out = {}
 
@@ -449,7 +452,7 @@ class IotFunctions_2
   #login="test"
   #+++
   #IOT logic added
-  def device_remove_2(login, imei)
+  def device_remove_2(login, imei, real_ip, remote_ip)
 
     input_json = {:login => login, :imei_list => imei}
     resp_out = {}
@@ -533,7 +536,7 @@ class IotFunctions_2
   #newdevice_list=[{:imei=>7967843245665, :address=>"Golubeva51"}]
   #+++
   #iot platform integration completed
-  def device_add_address_2(login, newdevice_list)
+  def device_add_address_2(login, newdevice_list, real_ip, remote_ip)
     #add_functions_connector.telegram_message(newdevice_list.to_s)
     p newdevice_list
     p "gas"
@@ -615,7 +618,7 @@ class IotFunctions_2
   #msisdn
   #newdevice_list=[{:imei=>7967843245665, :attributes=>{:address=>"Golubeva51", :profile=>"wqeqcqeqwev", :msisdn=>375298766719, :imsi=>25702858586756875}}]
   #+
-  def add_service_2(login, device_list)
+  def add_service_2(login, device_list, real_ip, remote_ip)
     resp_out = {}
     not_processed = []
     processed = []
@@ -676,9 +679,7 @@ class IotFunctions_2
         else
           resp_out = {:code => 509, :result => "Input data invalid"}
         end
-
       end
-
     rescue
       resp_out = {:code => 507, :result => "Unknown SDK error"}
     end
@@ -690,7 +691,7 @@ class IotFunctions_2
 
   #7 procedure for subscriber autorization
   # save data to mongodb
-  def autorize_subscriber_2(login, password)
+  def autorize_subscriber_2(login, password, real_ip, remote_ip)
     input_json = {:login => login, :password => password}
     resp_out = {}
     thr7 = Thread.new do
@@ -722,7 +723,7 @@ class IotFunctions_2
 
 
   #8 get available profiles by login
-  def get_available_prof_2(login)
+  def get_available_prof_2(login, real_ip, remote_ip)
 
     input_params = {:login => login}
     resp_out = {}
@@ -773,7 +774,7 @@ class IotFunctions_2
   end
 
   #9 get available device types by login
-  def get_available_types_2(login)
+  def get_available_types_2(login, real_ip, remote_ip)
 
     input_params = {:login => login}
     resp_out = {}
@@ -830,7 +831,7 @@ class IotFunctions_2
 
 
   #10 get available device types by login and profile. procedure update
-  def get_available_types2_2(login, profile)
+  def get_available_types2_2(login, profile, real_ip, remote_ip)
 
     input_params = {:login => login}
     resp_out = {}
@@ -887,7 +888,7 @@ class IotFunctions_2
 
 
   #11 get info for device type
-  def get_info_data_type_2(type)
+  def get_info_data_type_2(type, real_ip, remote_ip)
 
     input_params = {:type => type}
     output_answ = {}
@@ -917,7 +918,7 @@ class IotFunctions_2
 
 
   #12 get info for profile
-  def get_info_data_profile_2(profile)
+  def get_info_data_profile_2(profile, real_ip, remote_ip)
 
     input_params = {:profile => profile}
     output_answ = {}
@@ -946,6 +947,180 @@ class IotFunctions_2
   end
 
 
+  #set_data_replace
+  #13
+  # {"autorization"=>{"login"=>"test", "token"=>"token"}, "datalist"=>[{"imei"=>"524523654366", "new_profile"=>"3", "new_type"=>"1000001"}, {"imei"=>"53623413423", "new_profile"=>"1", "new_type"=>"1000003"}]}
+  # answer = {:code=>200, :result=>"Success", :body=>{:processednum=>1, :failednum=>1, :deviceserr=>[{:failedimei=>524523654366}]}}
+  def set_data_replace_2(soapgw_params, real_ip, remote_ip)
+    input_params = {:soapgw_params => soapgw_params, :real_ip => real_ip, :remote_ip => remote_ip}
+    output_answ = {}
+    failes_list = []
+    answ_to_soapgw = {}
+    not_processed_list = []
+    processed_list = []
+
+    inp_login = soapgw_params["autorization"]["login"]
+    inp_dev_list = soapgw_params["datalist"]
+
+    thr13set = Thread.new do
+      inp_dev_list.each do |curr_dev|
+        begin
+          if curr_dev["imei"] != [] && curr_dev["imei"] != nil && curr_dev["imei"] != ""
+            list_checked = mongo_client.check_imei_exists([curr_dev["imei"].to_i])
+            if list_checked[:code] == 200 && list_checked[:body][:exists] != [] && list_checked[:body][:not_exists] == []
+
+              #step1 checking permission for writing for imei list
+              prof_name1 = mongo_client.get_profile_name_from_imei(curr_dev["imei"].to_i)
+              p prof_name1
+              p "prof_name1"
+              if prof_name1[:code] == 200
+
+                if curr_dev["new_profile"] != "nil" && curr_dev["new_profile"] != "null" && curr_dev["new_profile"] != "empty" && curr_dev["new_profile"] != "nill"
+                  prof_new_id = mongo_client.get_profile_universal(curr_dev["new_profile"])["profile_id"]
+                else
+                  prof_new_id = prof_name1[:body]["profile_id"]
+                end
+
+                if curr_dev["new_type"] != "nil" && curr_dev["new_type"] != "null" && curr_dev["new_type"] != "empty" && curr_dev["new_type"] != "nill"
+                  type_new_pr = curr_dev["new_type"]
+                else
+                  type_new_pr = prof_name1[:imei_info][:body][0]["device_type"]
+                end
+
+                p type_new_pr
+                p prof_new_id
+                p "st111111"
+
+                get_login_info = mongo_client.check_login_prof_perm_id_one(inp_login, prof_name1[:body]["profile_id"])
+                p get_login_info
+                p "get_login_info"
+                if get_login_info[:code] == 200
+                  get_login_info_new = mongo_client.check_login_prof_perm_id_one(inp_login, prof_new_id)
+                  p get_login_info_new
+                  p "get_login_info_new"
+                  if get_login_info_new[:code] == 200
+                    cur_comp1 = mongo_client.compare_profiles(prof_name1[:body]["profile_id"], prof_new_id)
+                    p cur_comp1
+                    p "cur_comp1"
+                    cur_comp2 = mongo_client.compare_device_types(prof_name1[:imei_info][:body][0]["type"], type_new_pr)
+
+
+                    p cur_comp2
+                    p "cur_comp2"
+
+                    if cur_comp1[:is_the_same] && cur_comp2[:is_the_same]
+                      #the same. Nothing to do
+                      processed_list.append(curr_dev)
+                      ########
+                    else
+                      credentials_old = mongo_client.get_iot_oceanconn_credent_2(prof_name1[:body]["profile"])
+                      credentials_new = mongo_client.get_iot_oceanconn_credent_2(prof_new_id)
+                      p credentials_new
+                      p "credentials_new"
+                      #########
+                      if credentials_old[:code] == 200 && credentials_new[:code] == 200
+                        imei_data = mongo_client.get_imei_info_from_db([curr_dev["imei"].to_i])
+                        p imei_data
+                        p "imei_data"
+                        if imei_data[:body] != []
+                          ans = {}
+                          if imei_data[:body][0]["huadata"]["body"]["deviceId"] != nil
+                            model_data = mongo_client.get_device_type_info_universal(type_new_pr)
+                            p model_data
+                            p "model_data"
+                            #####all checks completed. then process data#####
+                            ans_old = hua_aceanconnect_connector.remove_one_device_from_iot(credentials_old[:body][:app_id], credentials_old[:body][:secret], imei_data[:body][0]["huadata"]["body"]["deviceId"])
+
+
+                            if ans_old[:code].to_i == 200 || ans_old[:code].to_i == 202 || ans_old[:code].to_i == 204
+                              begin
+                                resss = hua_aceanconnect_connector.add_new_device_on_huawei(credentials_new[:body][:app_id],
+                                                                                            credentials_new[:body][:secret],
+                                                                                            curr_dev["imei"].to_i,
+                                                                                            curr_dev["imei"].to_s,
+                                                                                            prof_name1[:body]["description"],
+                                                                                            model_data[:body]["device_type"],
+                                                                                            curr_dev["new_profile"],
+                                                                                            model_data[:body]["ManufacturerID"],
+                                                                                            model_data[:body]["ManufacturerNAME"],
+                                                                                            model_data[:body]["model"]
+                                )
+                                if resss[:code] == "200"
+                                  if resss[:body].key?("error_code") && resss[:body]["error_code"] != 200
+                                    not_processed_list.append({:imei => curr_dev["imei"], :error => resss})
+                                  else
+                                    new_id_iot = resss[:body]
+                                    new_profile_id = prof_new_id
+                                    now_date = DateTime.now
+                                    #finished success. update database
+                                    attribute = {profile: new_profile_id, type: model_data[:body]["model"], huadata: {body: new_id_iot}, updated: now_date}
+                                    answ_mongo = mongo_client.modify_attr_mongo_universal(curr_dev["imei"].to_i, attribute)
+                                    if answ_mongo[:code] != 200
+                                      not_processed_list.append({:imei => curr_dev["imei"], :error => "Critical error. Mongo not updated", :mongo_err => answ_mongo})
+                                    else
+                                      processed_list.append(curr_dev)
+                                    end
+                                  end
+                                else
+                                  not_processed_list.append({:imei => curr_dev["imei"], :error => resss})
+                                end
+                              rescue
+                                not_processed_list.append({:imei => curr_dev["imei"], :error => "Unknown error with insertion imei on IOT platform"})
+                              end
+                            end
+                          else
+                            not_processed_list.append({:imei => curr_dev["imei"], :error => "Not processed by iot platform. deviceId not found in mongoDB"})
+                          end
+                        else
+                          not_processed_list.append({:imei => curr_dev["imei"], :error => "Failed to get info from database"})
+                        end
+                      else
+                        not_processed_list.append({:imei => curr_dev["imei"], :error => "Failed to get credentials from database"})
+                      end
+                    end
+                  else
+                    not_processed_list.append({:imei => curr_dev["imei"], :error => "New profile modification not permitted"})
+                  end
+                else
+                  not_processed_list.append({:imei => curr_dev["imei"], :error => "Old profile modification not permitted"})
+                end
+              else
+                not_processed_list.append({:imei => curr_dev["imei"], :error => "Unknown current profile"})
+              end
+            else
+              not_processed_list.append({:imei => curr_dev["imei"], :error => "Device not exists"})
+            end
+          else
+            not_processed_list.append({:imei => curr_dev["imei"], :error => "IMEI can't be nil"})
+          end
+        rescue
+          not_processed_list.append({:imei => curr_dev["imei"], :error => "Unknown SDK error"})
+        end
+
+      end
+
+      err_li = []
+      if not_processed_list.length > 0
+        not_processed_list.each do |err_l|
+          err_li.append({:failedimei => err_l[:imei]})
+        end
+      end
+
+      if processed_list.length > 0
+        answ_to_soapgw = {:code => 200, :result => "Success", :body => {:processednum => processed_list.length, :failednum => not_processed_list.length, :deviceserr => err_li}}
+      else
+        answ_to_soapgw = {:code => 202, :result => "Nothing done", :body => {:processednum => 0, :failednum => not_processed_list.length, :deviceserr => err_li}}
+      end
+    end
+    thr13set.join
+
+    output_answ = {:code => 200, :result => "Success", :body => {:to_soap_gw => answ_to_soapgw, :not_processed_list => not_processed_list, :processed_list => processed_list}}
+    mongo_client.audit_logger("set_data_replace_2", remote_ip, input_params, output_answ, real_ip)
+    output_answ
+  end
+
+
+  #14
   #additional procedure for checking status on iot platform
   def get_info_by_imeilist_from_iot(login, imei_list)
     resp_out={}
@@ -998,10 +1173,10 @@ class IotFunctions_2
           p resp_out[:body]
           p "resp_out[:body][\"devices\"]"
 
-          if resp_out[:body] == nil || resp_out[:body] == {} || resp_out[:body] == {"devices"=>nil}
+          if resp_out[:body] == nil || resp_out[:body] == {} || resp_out[:body] == {"devices" => nil}
             p "step1111"
             p resp_out_1[:body]["devices"]
-            resp_out[:body] = { 'devices' => resp_out_1[:body]["devices"]}
+            resp_out[:body] = {'devices' => resp_out_1[:body]["devices"]}
             p "step22222"
           else
             if resp_out_1[:body]["devices"] != nil

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

@@ -6,13 +6,14 @@ require 'rubygems'
 require 'nokogiri'
 require 'rails'
 require "imperituroard/projects/iot/internal_functions"
+require 'imperituroard/projects/iot/mongoconnector'
 
 
 class HuaIot
 
-  attr_accessor :platformip, :platformport, :client, :database, :cert_file, :key_file, :internal_func
+  attr_accessor :platformip, :platformport, :client, :database, :cert_file, :key_file, :internal_func, :client_iot_mongo
 
-  def initialize(platformip, platformport, cert_file, key_file)
+  def initialize(platformip, platformport, cert_file, key_file, mongo_ip, mongo_port, mongo_database)
     @database = database
     @platformip = platformip
     @platformport = platformport
@@ -21,6 +22,7 @@ class HuaIot
     #client_host = [mongoip + ":" + mongoport]
     #@client = Mongo::Client.new(client_host, :database => database)
     @internal_func = InternalFunc.new
+    @client_iot_mongo = MongoIot.new(mongo_ip, mongo_port, mongo_database)
   end
 
   def parse_token(str)
@@ -72,6 +74,11 @@ class HuaIot
       request.body = URI.encode_www_form(data)
       res = https.request(request)
       out_resp = {:code => res.code, :message => res.message, :body => JSON.parse(res.body.to_s)}
+      fff = {:func => "get_token",
+             :iot_fun => "",
+             :req_header => {:content_type => 'application/x-www-form-urlencoded'
+             }}
+      client_iot_mongo.audit_iot_logger(fff, url_string, data, out_resp)
     rescue
       out_resp = {:code => 500, :message => "failed get token"}
     end
@@ -104,6 +111,10 @@ class HuaIot
       request.body = URI.encode_www_form(data)
       res = https.request(request)
       out_resp = {:code => res.code, :message => res.message, :body => JSON.parse(res.body.to_s)}
+      fff = {:func => "token_logout",
+             :iot_fun => "logout"
+      }
+      client_iot_mongo.audit_iot_logger(fff, url_string, data, out_resp)
     rescue
       out_resp = {:code => 500, :message => "failed logout token"}
     end
@@ -129,7 +140,6 @@ class HuaIot
     request['app_key'] = app_id
     request.body = {nodeId: node_id}.to_json
     res = https.request(request)
-    p res.body.to_s
     {:code => res.code, :message => res.message, :body => JSON.parse(res.body.to_s)}
   end
 
@@ -157,13 +167,18 @@ class HuaIot
                              manufacturerName: manufacturer_name,
                              model: model,
                              isSecurity: "FALSE",
-                             supportedSecurity: "FALSE"}}.to_json
+                             supportedSecurity: "FALSE"}}
     internal_func.printer_texter({:procedure => "dev_register_passw_code_mode2", :data => {:body => data_out, :url => url_string}}, "debug")
-    request.body = data_out
+    request.body = data_out.to_json
     res = https.request(request)
-    p res.body.to_s
     out_resp = {:code => res.code, :message => res.message, :body => JSON.parse(res.body.to_s)}
-    p out_resp
+    fff = {:func => "dev_register_passw_code_mode2",
+           :iot_fun => "2.2.4",
+           :req_header => {:authorization => 'Bearer ' + token,
+                           :content_type => 'application/json',
+                           :app_key => app_id
+           }}
+    client_iot_mongo.audit_iot_logger(fff, url_string, data_out, out_resp)
     out_resp
   end
 
@@ -213,18 +228,21 @@ class HuaIot
       request['Authorization'] = 'Bearer ' + token
       request['app_key'] = app_id
       res = https.request(request)
-      p "res.code"
-      p res.code
-      p res.body
       if res.body != nil
         out_resp = {:code => res.code, :message => res.message, :body => {:answ => JSON.parse(res.body.to_s)}}
       else
         out_resp = {:code => res.code, :message => res.message, :body => {:answ => "no data"}}
       end
+      fff = {:func => "dev_delete",
+             :iot_fun => "2.2.12",
+             :req_header => {:authorization => 'Bearer ' + token,
+                             :content_type => 'application/json',
+                             :app_key => app_id
+             }}
+      client_iot_mongo.audit_iot_logger(fff, url_string, "Delete", out_resp)
     rescue
       out_resp = {:code => 500, :message => "dev_delete: Unknown IOT error"}
     end
-    p out_resp
     out_resp
   end
 
@@ -295,6 +313,7 @@ class HuaIot
 
   #2.9.6 Querying Directly Connected Devices and Their Mounted Devices in Batches
   def querying_device_direct_conn(app_id, secret, dev_list)
+    output_str = {}
     token = get_token(app_id, secret)[:body]["accessToken"]
     path = "/iocm/app/dm/v1.1.0/queryDevicesByIds"
     url_string = "https://" + platformip + ":" + platformport + path
@@ -308,9 +327,18 @@ class HuaIot
     request.content_type = 'application/json'
     request['Authorization'] = 'Bearer ' + token
     request['app_key'] = app_id
-    request.body = {deviceIds: dev_list}.to_json
+    req_body = {deviceIds: dev_list}
+    request.body = req_body.to_json
     res = https.request(request)
-    {:code => res.code, :message => res.message, :body => JSON.parse(res.body.to_s)}
+    output_str = {:code => res.code, :message => res.message, :body => JSON.parse(res.body.to_s)}
+    fff = {:func => "querying_device_direct_conn",
+           :iot_fun => "2.9.6",
+           :req_header => {:authorization => 'Bearer ' + token,
+                           :content_type => 'application/json',
+                           :app_key => app_id
+           }}
+    client_iot_mongo.audit_iot_logger(fff, url_string, req_body, output_str)
+    output_str
   end
 
 
@@ -364,7 +392,7 @@ class HuaIot
     begin
       path = "/iocm/app/dm/v1.4.0/devices/" + dev_id + "?app_Id=" + app_id
       url_string = "https://" + platformip + ":" + platformport + path
-      internal_func.printer_texter({:url_string=>url_string, :procedure=>"dev_modify_location_v2"}, "debug")
+      internal_func.printer_texter({:url_string => url_string, :procedure => "dev_modify_location_v2"}, "debug")
       uri = URI.parse url_string
       https = Net::HTTP.new(uri.host, uri.port)
       https.use_ssl = true
@@ -375,7 +403,8 @@ class HuaIot
       request.content_type = 'application/json'
       request['Authorization'] = 'Bearer ' + token
       request['app_key'] = app_id
-      request.body = {location: address}.to_json
+      req_b = {location: address}
+      request.body = req_b.to_json
       res = https.request(request)
       p res.code
       p res.body
@@ -384,6 +413,13 @@ class HuaIot
       else
         out_resp = {:code => res.code, :message => res.message, :body => {:answ => "no data"}}
       end
+      fff = {:func => "dev_modify_location_v2",
+             :iot_fun => "2.2.11",
+             :req_header => {:authorization => 'Bearer ' + token,
+                             :content_type => 'application/json',
+                             :app_key => app_id
+             }}
+      client_iot_mongo.audit_iot_logger(fff, url_string, req_b, out_resp)
     rescue
       out_resp = {:code => 500, :message => "dev_modify_location_v2: Unknown IOT error"}
     end
@@ -392,7 +428,6 @@ class HuaIot
   end
 
 
-
   ##2.10.7 Adding Members to a Device Group
 
 

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

@@ -41,6 +41,30 @@ class MongoIot
     out_resp
   end
 
+  def audit_iot_logger(proc_name, url_str, input_json, output_json)
+    out_resp = {}
+    p "iiiiiiiot"
+    p input_json
+    begin
+      current = internal_func.datetimenow
+      collection = client[:audit_iot_platform]
+      doc = {
+          :proc_name => proc_name,
+          :date => current,
+          :url => url_str,
+          :iot_platform_request => input_json,
+          :iot_platform_responce => output_json
+      }
+      p doc
+      result = collection.insert_one(doc)
+      out_resp = {:code => 200, :result => "audit_logger: Request completed successfully", :body => result}
+    rescue
+      out_resp = {:code => 507, :result => "audit_logger: Unknown SDK error"}
+    end
+    internal_func.printer_texter(out_resp, "debug")
+    out_resp
+  end
+
   #:code => 507, :result => "Unknown SDK error"
   #{:code => 200, :result => "Request completed successfully", :body => result_ps}
   def get_profiles_by_login(login)
@@ -317,6 +341,7 @@ class MongoIot
             note: "second description",
             profile: 0,
             type: 0,
+            device_type: 0,
             address: "unknown"
         }
         result = collection.insert_one(l)
@@ -340,6 +365,7 @@ class MongoIot
             note: "second description",
             profile: 0,
             type: 0,
+            device_type: 0,
             address: "unknown"
         }
         result = collection.insert_one(l)
@@ -364,6 +390,7 @@ class MongoIot
 
   def get_profile_name_from_imei(imei)
     out_resp = {}
+    info = {}
     begin
       id = ""
       begin
@@ -387,7 +414,7 @@ class MongoIot
           end
           begin
             if res["profile"]!=nil
-              out_resp = {:code => 200, :result => "get_profile_name_from_imei: Request completed successfully", :body => res}
+              out_resp = {:code => 200, :result => "get_profile_name_from_imei: Request completed successfully", :body => res, :imei_info => info}
             end
           rescue
             out_resp = {:code => 506, :result => "get_profile_name_from_imei: Function get_profile_name_by_id not processed correctly and returned: #{res.to_s}"}
@@ -523,5 +550,164 @@ class MongoIot
     out_resp
   end
 
+  def get_device_type_info_universal(device_model)
+    out_resp = {}
+    begin
+      as = internal_func.if_digit_or_string(device_model)
+
+      if as[:body][:string]
+        result_ps = []
+        collection = client[:device_types]
+        collection.find({"model" => device_model}).each {|row|
+          result_ps.append(row)
+        }
+        dattaa = result_ps[0]
+        if dattaa!=nil
+          out_resp = {:code => 200, :result => "get_device_type_info_by_model: Request completed successfully", :body => dattaa}
+        else
+          out_resp = {:code => 404, :result => "get_device_type_info_by_model: Device info not found", :body => {"model" => device_model, "ManufacturerID" => "unknown", "ManufacturerNAME" => "unknown", "device_type" => "unknown"}}
+        end
+      else
+        result_ps2 = []
+        collection = client[:device_types]
+        collection.find({"type_id" => device_model.to_i}).each {|row|
+          result_ps2.append(row)
+        }
+        dattaa = result_ps2[0]
+        if dattaa!=nil
+          out_resp = {:code => 200, :result => "get_device_type_info_by_model: Request completed successfully", :body => dattaa}
+        else
+          out_resp = {:code => 404, :result => "get_device_type_info_by_model: Device info not found", :body => {"model" => device_model, "ManufacturerID" => "unknown", "ManufacturerNAME" => "unknown", "device_type" => "unknown"}}
+        end
+      end
+
+    rescue
+      out_resp = {:code => 500, :result => "get_device_type_info_universal: procedure error", :body => {"model" => device_model, "ManufacturerID" => "unknown", "ManufacturerNAME" => "unknown", "device_type" => "unknown"}}
+    end
+    internal_func.printer_texter(out_resp, "debug")
+    out_resp
+  end
+
+
+
+  def compare_profiles(profile1, profile2)
+    out_answ = {}
+    ch1 = internal_func.if_digit_or_string(profile1)
+    ch2 = internal_func.if_digit_or_string(profile2)
+    if ch1[:body][:string] == ch2[:body][:string] && ch1[:body][:string] == false
+      if profile1.to_i == profile2.to_i
+        out_answ = {:code => 200, :result => "compare_profiles: profiles are the same", :is_the_same => true, :data_type => "integer"}
+      else
+        out_answ = {:code => 200, :result => "compare_profiles: profiles are different", :is_the_same => false, :data_type => "integer"}
+      end
+    elsif ch1[:body][:string] == ch2[:body][:string] && ch1[:body][:string] == true
+      if profile1 == profile2
+        out_answ = {:code => 200, :result => "compare_profiles: profiles are the same", :is_the_same => true, :data_type => "string"}
+      else
+        out_answ = {:code => 200, :result => "compare_profiles: profiles are different", :is_the_same => false, :data_type => "string"}
+      end
+    else
+      ch1_data = {}
+      ch2_data = {}
+      if ch1[:body][:string]
+        ch1_data = self.get_profile_id_by_name(profile1)
+      else
+        ch1_data = self.get_profile_name_by_id(profile1.to_i)
+      end
+
+      if ch2[:body][:string]
+        ch2_data = self.get_profile_id_by_name(profile2)
+      else
+        ch2_data = self.get_profile_name_by_id(profile2.to_i)
+      end
+
+      if ch1_data["profile_id"] == ch2_data["profile_id"]
+        out_answ = {:code => 200, :result => "compare_profiles: profiles are the same", :is_the_same => true, :data_type => "different"}
+      else
+        out_answ = {:code => 200, :result => "compare_profiles: profiles are different", :is_the_same => false, :data_type => "different"}
+      end
+    end
+    out_answ
+  end
+
+  def compare_device_types(type1, type2)
+    out_answ = {}
+    tp1 = internal_func.if_digit_or_string(type1)
+    tp2 = internal_func.if_digit_or_string(type2)
+    p tp1
+    p tp2
+    p "tp"
+
+    if tp1[:body][:string] == tp2[:body][:string] && tp1[:body][:string] == false
+      if type1.to_i == type2.to_i
+        out_answ = {:code => 200, :result => "compare_device_types: types are the same", :is_the_same => true, :data_type => "integer"}
+      else
+        out_answ = {:code => 200, :result => "compare_device_types: types are different", :is_the_same => false, :data_type => "integer"}
+      end
+    elsif tp1[:body][:string] == tp2[:body][:string] && tp1[:body][:string] == true
+      if type1 == type2
+        out_answ = {:code => 200, :result => "compare_device_types: types are the same", :is_the_same => true, :data_type => "string"}
+      else
+        out_answ = {:code => 200, :result => "compare_device_types: types are different", :is_the_same => false, :data_type => "string"}
+      end
+    else
+      tp1_data = {}
+      tp2_data = {}
+      p "gggggggg"
+      if tp1[:body][:string]
+        tp1_data = self.get_type_by_name(type1)
+      else
+        tp1_data = self.get_type_by_id(type1.to_i)
+      end
+
+      if tp2[:body][:string]
+        tp2_data = self.get_type_by_name(type2)
+      else
+        tp2_data = self.get_type_by_id(type2.to_i)
+      end
+
+      p tp1_data
+      p tp2_data
+      p type1
+      p type2
+
+      if tp1_data["type_id"] == tp2_data["type_id"]
+        out_answ = {:code => 200, :result => "compare_device_types: profiles are the same", :is_the_same => true, :data_type => "different"}
+      else
+        out_answ = {:code => 200, :result => "compare_device_types: profiles are different", :is_the_same => false, :data_type => "different"}
+      end
+    end
+    out_answ
+  end
+
+
+  def get_profile_universal(profile)
+    inn = internal_func.if_digit_or_string(profile)
+    out = {}
+    if inn[:body][:string]
+      out = self.get_profile_id_by_name(profile)
+    else
+      out = self.get_profile_name_by_id(profile.to_i)
+    end
+    out
+  end
+
+  def modify_attr_mongo_universal(imei, attribute)
+    out_resp = {}
+    begin
+      collection = client[:device_imei]
+      doc = {
+          "imei" => imei
+      }
+      sett = {'$set' => attribute}
+      result = collection.update_one(doc, sett)
+      out_resp = {:code => 200, :result => "modify_attr_mongo_universal: Request completed successfully"}
+    rescue
+      out_resp = {:code => 507, :result => "modify_attr_mongo_universal: Unknown SDK error"}
+    end
+    internal_func.printer_texter(out_resp, "debug")
+    out_resp
+  end
+
+end
 
-end

data/lib/imperituroard/version.rb

@@ -1,3 +1,4 @@
 module Imperituroard
-  VERSION = "0.5.9"
+  VERSION = "1.0.4"
 end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: imperituroard
 version: !ruby/object:Gem::Version
-  version: 0.5.9
+  version: 1.0.4
 platform: ruby
 authors:
 - Dzmitry Buynovskiy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-03 00:00:00.000000000 Z
+date: 2020-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler