imperituroard 0.5.8 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dec8fb3791d83727a6bfd54fc71889481af42b42
-  data.tar.gz: 583739817cad732740861c08845910e849770b55
+  metadata.gz: 5264f8d3d00a73980d4de22a91b93c49ccd65904
+  data.tar.gz: a165a821f4ea118ca20916f6ca512aa4d1f4b173
 SHA512:
-  metadata.gz: 27b131265896d1793261ea994a011e436171f6d5e74bc0c11a4d2e7039545a715ca693be6faab217e321d52e41ae92a6488fb00027c9c2a3beab8fc24b4f198b
-  data.tar.gz: c5d72b86f1168829d5287c14120f70705a1bfb317ee896071d84b161a0a6b2ec3495a3e3c525a2e1aa2aa0a7d530c78f76c8d790dfe0a290a9c56401a7d9f71e
+  metadata.gz: e8d44ca288a3ebadc98ebd0ad7844e781c1ca3085c4df144113f9cd61a349915f71565daeeaa460437d4b6da545a40f7577c488bc7f4f6ca09230dafacc535b1
+  data.tar.gz: 1161e315402988d67d08cb63d0c7660412a24d2826172e5d23c38f81d1fa876c84cfef2f56b83754a7f8ff3cbc1d45e2cdd1415b6cc96abb8c8a9a8a5c15739f

data/imperituroard.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   spec.homepage      = "https://rubygems.org/"
   spec.license       = "MIT"
 
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.5.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org/"
 
@@ -52,6 +52,6 @@ Gem::Specification.new do |spec|
   spec.add_dependency "simpleidn", "0.1.1"
   spec.add_dependency "net-scp", "3.0.0"
 
-  spec.add_dependency "rails", "5.2.4.2"
+  spec.add_dependency "rails", "5.0.7.2"
 
 end

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
@@ -211,7 +221,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 +284,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 +459,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 +543,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 +625,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 = []
@@ -690,7 +700,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 +732,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 +783,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 +840,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 +897,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 +927,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 +956,157 @@ 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"]
+
+    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)
+            if prof_name1[:code] == 200
+
+              if curr_dev["new_profile"] != "nil" && curr_dev["new_profile"] != "null" && curr_dev["new_profile"] != "empty"
+                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"
+                type_new_pr = curr_dev["new_type"]
+              else
+                type_new_pr = prof_name1[:imei_info][:body][0]["device_type"]
+              end
+
+
+              get_login_info = mongo_client.check_login_prof_perm_id_one(inp_login, prof_name1[:body]["profile_id"])
+              if get_login_info[:code] == 200
+                get_login_info_new = mongo_client.check_login_prof_perm_id_one(inp_login, prof_new_id)
+                if get_login_info_new[:code] == 200
+                  cur_comp1 = mongo_client.compare_profiles(prof_name1[:body]["profile_id"], prof_new_id)
+                  cur_comp2 = mongo_client.compare_device_types(prof_name1[:imei_info][:body][0]["device_type"], type_new_pr)
+
+                  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)
+                    #########
+                    if credentials_old[:code] == 200 && credentials_new[:code] == 200
+                      imei_data = mongo_client.get_imei_info_from_db([curr_dev["imei"].to_i])
+                      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)
+                          #####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, device_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
+                                  #added_on_iot_platf.append(s1)
+                                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
+      soap_answ = {:code=>200, :result=>"Success", :body=>{:processednum => processed_list.length, :failednum => not_processed_list.length, :deviceserr => err_li}}
+    else
+      soap_answ = {:code=>202, :result=>"Nothing done", :body=>{:processednum => 0, :failednum => not_processed_list.length, :deviceserr => err_li}}
+    end
+
+    output_answ = {:code => 200, :result => "Success", :body => {:to_soap_gw => soap_answ, :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 +1159,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)
@@ -364,6 +388,7 @@ class MongoIot
 
   def get_profile_name_from_imei(imei)
     out_resp = {}
+    info = {}
     begin
       id = ""
       begin
@@ -387,7 +412,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 +548,155 @@ 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)
+
+    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 = {}
+      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
+
+      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.8"
+  VERSION = "1.0.3"
 end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: imperituroard
 version: !ruby/object:Gem::Version
-  version: 0.5.8
+  version: 1.0.3
 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
@@ -170,14 +170,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.2.4.2
+        version: 5.0.7.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.2.4.2
+        version: 5.0.7.2
 description: Gem from imperituroard for different actions
 email:
 - imperituro.ard@gmail.com
@@ -249,7 +249,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="