imperituroard 1.0.4 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 64ac99c5a41209df78fa5f319ec47a51cb28b05b
-  data.tar.gz: 004ea48aa310c5d3159ffa8f93b6451f6105fe0a
+  metadata.gz: dae0092e4f87b047adb62157ee51cb3e917bc3d7
+  data.tar.gz: be638036010d680252df866b5b09fb49bddd6628
 SHA512:
-  metadata.gz: 97de046b4032c0751a046c4e1f57cbaffafd63936e53bfa08bcca6dc7216b6a5f73dcf1a68715c9a0a21b4f4ff5e1c116b3fabe0f450a264962543e68b6055b3
-  data.tar.gz: 62ad29d69a43d0b0574c5249ac6777bc153a10472b9cce01298a80e27c8c956b6776aa86eef9d558d87acd1d260d5f7ca66428fa12ac8cfead71aab7fb0a7383
+  metadata.gz: a0e130dbe846d930dfe7da4a6290f76e4c1f6326e944ea4dbc693bafe90b9087ee4915e0e08dd83c346fb35c6a0ea68ce88ce5f690db27e47ab6b82e1ffaa3c6
+  data.tar.gz: f9c6ffd509148ae09d85fc4aac1439686612283d735fc020f3e45d76fd62e94d41b938d6a033fd93be6e2221612009b66d8a8da948e64fd32e0ee0c252baa93f

data/.idea/runConfigurations/version.xml

@@ -0,0 +1,21 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="version" type="RubyRunConfigurationType" factoryName="Ruby">
+    <module name="imperituroard" />
+    <RUBY_RUN_CONFIG NAME="RUBY_ARGS" VALUE="-e $stdout.sync=true;$stderr.sync=true;load($0=ARGV.shift)" />
+    <RUBY_RUN_CONFIG NAME="WORK DIR" VALUE="$MODULE_DIR$/lib/imperituroard" />
+    <RUBY_RUN_CONFIG NAME="SHOULD_USE_SDK" VALUE="false" />
+    <RUBY_RUN_CONFIG NAME="ALTERN_SDK_NAME" VALUE="" />
+    <RUBY_RUN_CONFIG NAME="myPassParentEnvs" VALUE="true" />
+    <envs />
+    <EXTENSION ID="BundlerRunConfigurationExtension" bundleExecEnabled="true" />
+    <EXTENSION ID="JRubyRunConfigurationExtension" NailgunExecEnabled="false" />
+    <EXTENSION ID="RubyCoverageRunConfigurationExtension" enabled="false" sample_coverage="true" track_test_folders="true" runner="rcov">
+      <COVERAGE_PATTERN ENABLED="true">
+        <PATTERN REGEXPS="/.rvm/" INCLUDED="false" />
+      </COVERAGE_PATTERN>
+    </EXTENSION>
+    <RUBY_RUN_CONFIG NAME="SCRIPT_PATH" VALUE="$MODULE_DIR$/lib/imperituroard/version.rb" />
+    <RUBY_RUN_CONFIG NAME="SCRIPT_ARGS" VALUE="" />
+    <method />
+  </configuration>
+</component>

data/lib/imperituroard.rb

@@ -33,6 +33,7 @@ require 'net/http'
 require 'uri'
 
 module Imperituroard
+
   class Error < StandardError;
   end
 
@@ -42,6 +43,7 @@ module Imperituroard
   def hhh(jjj)
     p jjj
   end
+
   # Your code goes here...
 end
 
@@ -239,6 +241,11 @@ class Iot
     iot_connector.get_available_types_2(login, real_ip, remote_ip)
   end
 
+  #9-1 get available types for login and profile
+  def get_available_types2(login, profile, real_ip, remote_ip)
+    iot_connector.get_available_types2_2(login, profile, real_ip, remote_ip)
+  end
+
   #10 get info for device type
   def get_info_data_type(type, real_ip, remote_ip)
     iot_connector.get_info_data_type_2(type, real_ip, remote_ip)

data/lib/imperituroard/projects/iot.rb

@@ -115,10 +115,9 @@ class IotFunctions_2
             end
           end
 
-
           begin
             added_on_iot_platf = []
-            if for_insert!=[]
+            if for_insert != []
               ##Logic for IOT Platform connection###
 
 
@@ -132,16 +131,25 @@ class IotFunctions_2
 
                 #########
 
+                if aaa.key?("type") && !aaa.key?("device_type")
+                  aaa["device_type"] = aaa["type"]
+                  aaa = internal_func.delete_key_hash(aaa, "type")
+                end
 
-                if credentials[:code] == 200
+                aaa = internal_func.hash_val_to_string(aaa)
 
+                if credentials[:code] == 200
 
                   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"])
+                    model_data = mongo_client.get_device_type_info_universal(aaa["device_type"])
+                    profile_data = mongo_client.get_profile_universal(aaa["profile"])
+                    p profile_data
+                    p model_data
+                    p "model_data"
                     resss = hua_aceanconnect_connector.add_new_device_on_huawei(credentials[:body][:app_id],
                                                                                 credentials[:body][:secret],
                                                                                 aaa["imei"],
@@ -160,7 +168,8 @@ class IotFunctions_2
                         s1 = aaa
                         s1[:huadata] = resss
                         s1[:created] = DateTime.now
-                        s1[:type] = s1["device_type"]
+                        s1["device_type"] = model_data[:body]["model"]
+                        s1["profile"] = profile_data["profile_id"]
                         added_on_iot_platf.append(s1)
                       end
                     else
@@ -199,9 +208,7 @@ class IotFunctions_2
     end
     thr1.join
 
-
     resp_out[:body][:tosoapgw] = internal_func.iot_create_dev_soapgw_answer(input_json, resp_out)
-
     mongo_client.audit_logger("add_device_to_profile", remote_ip, input_json, resp_out, real_ip)
     resp_out
   end
@@ -221,16 +228,16 @@ class IotFunctions_2
     resp_out = {}
     begin
       thr2 = Thread.new do
-        if add_functions_connector.check_input_2(login, imei_list)[:code]==200
+        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
+            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
+                if permiss1[:code] == 200
                   ime_list_approved.append(t)
                 else
                   ime_list_notapproved.append({:imei => t, :error => permiss1})
@@ -460,12 +467,12 @@ class IotFunctions_2
     begin
       thr4 = Thread.new do
 
-        if add_functions_connector.check_input_4(login, imei)[:code]==200
+        if add_functions_connector.check_input_4(login, imei)[:code] == 200
 
           prof_name = mongo_client.get_profile_name_from_imei(imei)
-          if prof_name[:code]==200
+          if prof_name[:code] == 200
             permiss = mongo_client.check_login_profile_permiss(login, prof_name[:body]["profile"])
-            if permiss[:code]==200
+            if permiss[:code] == 200
 
               ##Logic for IOT Platform connection###
 
@@ -479,17 +486,17 @@ class IotFunctions_2
 
               resp = {}
 
-              if credentials[:code]==200
+              if credentials[:code] == 200
 
                 imei_data = mongo_client.get_imei_info_from_db([imei])
-                if imei_data[:body]!=[]
+                if imei_data[:body] != []
                   ans = {}
                   if imei_data[:body][0]["huadata"]["body"]["deviceId"] != nil
                     ans = hua_aceanconnect_connector.remove_one_device_from_iot(credentials[:body][:app_id], credentials[:body][:secret], imei_data[:body][0]["huadata"]["body"]["deviceId"])
                   else
                     ans = {:code => "204", :result => "Not processed by iot platform. deviceId not found in mongoDB"}
                   end
-                  if ans[:code]=="204" or ans[:code]=="200"
+                  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}
@@ -573,10 +580,8 @@ class IotFunctions_2
                   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
 
                 #########end iot platform logic#######
@@ -651,7 +656,7 @@ class IotFunctions_2
                       if attr["profile"].is_a? Integer
                         p "Ok"
                       else
-                        p new = mongo_client.get_profile_id_by_name(attr["profile"])
+                        p new = mongo_client.get_profile_universal(attr["profile"])
                         attr["profile"] = new["profile_id"]
                       end
                     end
@@ -736,6 +741,7 @@ class IotFunctions_2
         permit_profiles = login_info[:body]["permit_profiles"]
         permit_types = login_info[:body]["permit_types"]
         data_from_mongo = mongo_client.get_profile_list_by_id(permit_profiles)
+        p data_from_mongo
 
         for ff in data_from_mongo
           data_processed.append({:profile_id => ff["profile_id"],
@@ -840,33 +846,47 @@ class IotFunctions_2
       data_processed = []
       data_soapgw = []
       login_info = mongo_client.get_login_inf2_select(login)
+      prof_data = mongo_client.get_profile_universal(profile)
       if login_info[:code]==200
 
         permit_profiles = login_info[:body]["permit_profiles"]
         permit_types = login_info[:body]["permit_types"]
+        perm_tp_prof = prof_data["permit_types"]
+
+        if permit_profiles.include?(prof_data["profile_id"])
+          res_types_permitted = internal_func.compare_dict(permit_types, perm_tp_prof)
+          data_from_mongo = mongo_client.get_type_list_by_id(res_types_permitted)
+
+          for ff in data_from_mongo
+            data_processed.append({:type_id => ff["type_id"],
+                                   :description => ff["description"],
+                                   :note => ff["note"],
+                                   :form => ff["form"],
+                                   :ManufacturerID => ff["ManufacturerID"],
+                                   :ManufacturerNAME => ff["ManufacturerNAME"],
+                                   :device_type => ff["device_type"],
+                                   :model => ff["model"],
+                                   :info => ff["info"]
+                                  })
+            data_soapgw.append({:name => ff["model"], :form => ff["form"], :description => ff["description"], :type_id => ff["type_id"]})
+          end
 
-        data_from_mongo = mongo_client.get_type_list_by_id(permit_types)
+          tosoapgw = {:code => 200,
+                      :result => "Request completed successfully",
+                      :types => data_soapgw
+          }
 
-        for ff in data_from_mongo
-          data_processed.append({:type_id => ff["type_id"],
-                                 :description => ff["description"],
-                                 :note => ff["note"],
-                                 :form => ff["form"],
-                                 :ManufacturerID => ff["ManufacturerID"],
-                                 :ManufacturerNAME => ff["ManufacturerNAME"],
-                                 :device_type => ff["device_type"],
-                                 :model => ff["model"],
-                                 :info => ff["info"]
-                                })
-          data_soapgw.append({:name => ff["model"], :form => ff["form"], :description => ff["description"], :type_id => ff["type_id"]})
+          resp_out = {:code => 200, :result => "Request completed successfully", :body => {:data => data_processed, :tosoapgw => tosoapgw}}
+
+        else
+          tosoapgw = {:code => 700,
+                      :result => "Profile not permitted",
+                      :types => data_soapgw
+          }
+          resp_out = {:code => 700, :result => "Profile not permitted", :body => {:tosoapgw => tosoapgw}}
         end
 
-        tosoapgw = {:code => 200,
-                    :result => "Request completed successfully",
-                    :types => data_soapgw
-        }
 
-        resp_out = {:code => 200, :result => "Request completed successfully", :body => {:data => data_processed, :tosoapgw => tosoapgw}}
       else
         tosoapgw = {:code => login_info[:code],
                     :result => login_info[:result],
@@ -930,6 +950,8 @@ class IotFunctions_2
         mon_answer = mongo_client.get_profile_name_by_id(profile)
       end
 
+      p mon_answer
+
       if mon_answer != {} && mon_answer != []
         output_answ = {:code => 200, :result => "Request completed successfully", :body => {:data => {:info => mon_answer["info"],
                                                                                                       :profile => mon_answer["profile"],
@@ -943,7 +965,6 @@ class IotFunctions_2
     end
     mongo_client.audit_logger("get_info_data_profile_2", remote_ip, input_params, output_answ, real_ip)
     output_answ
-
   end
 
 
@@ -1002,7 +1023,7 @@ class IotFunctions_2
                     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)
+                    cur_comp2 = mongo_client.compare_device_types(prof_name1[:imei_info][:body][0]["device_type"], type_new_pr)
 
 
                     p cur_comp2
@@ -1049,11 +1070,12 @@ class IotFunctions_2
                                   if resss[:body].key?("error_code") && resss[:body]["error_code"] != 200
                                     not_processed_list.append({:imei => curr_dev["imei"], :error => resss})
                                   else
+                                    p resss
                                     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}
+                                    attribute = {profile: new_profile_id, device_type: model_data[:body]["model"], huadata: resss, 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})
@@ -1067,6 +1089,8 @@ class IotFunctions_2
                               rescue
                                 not_processed_list.append({:imei => curr_dev["imei"], :error => "Unknown error with insertion imei on IOT platform"})
                               end
+                            else
+                              not_processed_list.append({:imei => curr_dev["imei"], :error => "Something wrong with IOT platform"})
                             end
                           else
                             not_processed_list.append({:imei => curr_dev["imei"], :error => "Not processed by iot platform. deviceId not found in mongoDB"})

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

@@ -54,6 +54,9 @@ class HuaIot
   def get_token(app_id, secret)
     internal_func.printer_texter("get_token: start. Step1, iput: app_id: #{app_id.to_s}, secret: #{secret.to_s}", "debug")
     out_resp = {}
+    fff = {}
+    data = {}
+    url_string = ""
     begin
       path = "/iocm/app/sec/v1.1.0/login"
       url_string = "https://" + platformip + ":" + platformport + path
@@ -73,15 +76,19 @@ class HuaIot
       request.content_type = 'application/x-www-form-urlencoded'
       request.body = URI.encode_www_form(data)
       res = https.request(request)
+      p res.code
+      p res.message
+      p res.body.to_s
       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'
+             :req_header => {:content_type => 'application/x-www-form-urlencoded',
+                             :platform => "Huawei oceanconnect"
              }}
-      client_iot_mongo.audit_iot_logger(fff, url_string, data, out_resp)
     rescue
       out_resp = {:code => 500, :message => "failed get token"}
     end
+    client_iot_mongo.audit_iot_logger(fff, url_string, data, out_resp)
     jjj = {:procedure => "get_token", :answ => out_resp}
     internal_func.printer_texter(jjj, "debug")
     out_resp
@@ -92,6 +99,9 @@ class HuaIot
 
     internal_func.printer_texter("token_logout Step1 token: #{token}", "debug")
     out_resp = {}
+    fff = {}
+    data = {}
+    url_string = ""
     begin
       path = "/iocm/app/sec/v1.1.0/logout"
       url_string = "https://" + platformip + ":" + platformport + path
@@ -112,12 +122,17 @@ class HuaIot
       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"
+             :iot_fun => "logout",
+             :platform => "Huawei oceanconnect"
       }
-      client_iot_mongo.audit_iot_logger(fff, url_string, data, out_resp)
+      p res.code
+      p res.message
+      p res.body.to_s
+
     rescue
       out_resp = {:code => 500, :message => "failed logout token"}
     end
+    client_iot_mongo.audit_iot_logger(fff, url_string, data, out_resp)
     jjj = {:procedure => "token_logout", :answ => out_resp}
     internal_func.printer_texter(jjj, "debug")
     out_resp
@@ -125,6 +140,7 @@ class HuaIot
 
   #Registering a Directly Connected Device (Verification Code Mode) (V2)
   def dev_register_verif_code_mode(app_id, secret, node_id)
+    out_resp = {}
     token = get_token(app_id, secret)[:body]["accessToken"]
     path = "/iocm/app/reg/v1.1.0/deviceCredentials?appId=" + app_id
     url_string = "https://" + platformip + ":" + platformport + path
@@ -138,9 +154,17 @@ class HuaIot
     request.content_type = 'application/json'
     request['Authorization'] = 'Bearer ' + token
     request['app_key'] = app_id
-    request.body = {nodeId: node_id}.to_json
+    data = {nodeId: node_id}
+    request.body = data.to_json
     res = https.request(request)
-    {:code => res.code, :message => res.message, :body => JSON.parse(res.body.to_s)}
+    out_resp = {:code => res.code, :message => res.message, :body => JSON.parse(res.body.to_s)}
+    fff = {:func => "dev_register_verif_code_mode",
+           :iot_fun => "Registering a Directly Connected Device (Verification Code Mode) (V2)",
+           :req_header => {:content_type => 'application/json',
+                           :platform => "Huawei oceanconnect"
+           }}
+    client_iot_mongo.audit_iot_logger(fff, url_string, data, out_resp)
+    out_resp
   end
 
   #2.2.4 Registering a Directly Connected Device (Password Mode) (V2)
@@ -176,7 +200,8 @@ class HuaIot
            :iot_fun => "2.2.4",
            :req_header => {:authorization => 'Bearer ' + token,
                            :content_type => 'application/json',
-                           :app_key => app_id
+                           :app_key => app_id,
+                           :platform => "Huawei oceanconnect"
            }}
     client_iot_mongo.audit_iot_logger(fff, url_string, data_out, out_resp)
     out_resp
@@ -199,13 +224,21 @@ class HuaIot
     request.content_type = 'application/json'
     request['Authorization'] = 'Bearer ' + token
     request['app_key'] = app_id
-    data_out = {deviceInfo: attr_list}.to_json
+    data = {deviceInfo: attr_list}
+    data_out = data.to_json
     internal_func.printer_texter({:procedure => "dev_register_passw_code_mode2", :data => {:body => data_out, :url => url_string}}, "debug")
     request.body = data_out
     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_reg_passw_code_mode2_2",
+           :iot_fun => "2.2.4",
+           :req_header => {:content_type => 'application/json',
+                           :authorization => 'Bearer ' + token,
+                           :app_key => app_id,
+                           :platform => "Huawei oceanconnect"
+           }}
+    client_iot_mongo.audit_iot_logger(fff, url_string, data, out_resp)
     out_resp
   end
 
@@ -237,7 +270,8 @@ class HuaIot
              :iot_fun => "2.2.12",
              :req_header => {:authorization => 'Bearer ' + token,
                              :content_type => 'application/json',
-                             :app_key => app_id
+                             :app_key => app_id,
+                             :platform => "Huawei oceanconnect"
              }}
       client_iot_mongo.audit_iot_logger(fff, url_string, "Delete", out_resp)
     rescue
@@ -274,6 +308,7 @@ class HuaIot
 
   #2.2.14 Querying Device Activation Status
   def querying_device_activ_status(app_id, secret, device_id)
+    output_ans = {}
     token = get_token(app_id, secret)[:body]["accessToken"]
     path = "/iocm/app/reg/v1.1.0/devices/" + device_id + "?app_Id=" + app_id
     url_string = "https://" + platformip + ":" + platformport + path
@@ -288,12 +323,22 @@ class HuaIot
     request['Authorization'] = 'Bearer ' + token
     request['app_key'] = app_id
     res = https.request(request)
-    {:code => res.code, :message => res.message, :body => JSON.parse(res.body.to_s)}
+    output_ans = {:code => res.code, :message => res.message, :body => JSON.parse(res.body.to_s)}
+    fff = {:func => "querying_device_activ_status",
+           :iot_fun => "2.2.14",
+           :req_header => {:content_type => 'application/json',
+                           :authorization => 'Bearer ' + token,
+                           :app_key => app_id,
+                           :platform => "Huawei oceanconnect"
+           }}
+    client_iot_mongo.audit_iot_logger(fff, url_string, data, output_ans)
+    output_ans
   end
 
 
   #2.9.1 Querying Information About a Device
   def querying_device_info(app_id, secret, device_id)
+    out_resp = {}
     token = get_token(app_id, secret)[:body]["accessToken"]
     path = "/iocm/app/dm/v1.1.0/devices/" + device_id + "?app_Id=" + app_id
     url_string = "https://" + platformip + ":" + platformport + path
@@ -308,7 +353,16 @@ class HuaIot
     request['Authorization'] = 'Bearer ' + token
     request['app_key'] = app_id
     res = https.request(request)
-    {:code => res.code, :message => res.message, :body => JSON.parse(res.body.to_s)}
+    out_resp = {:code => res.code, :message => res.message, :body => JSON.parse(res.body.to_s)}
+    fff = {:func => "querying_device_info",
+           :iot_fun => "2.9.1",
+           :req_header => {:authorization => 'Bearer ' + token,
+                           :content_type => 'application/json',
+                           :app_key => app_id,
+                           :platform => "Huawei oceanconnect"
+           }}
+    client_iot_mongo.audit_iot_logger(fff, url_string, "Get", out_resp)
+    out_resp
   end
 
   #2.9.6 Querying Directly Connected Devices and Their Mounted Devices in Batches
@@ -335,7 +389,8 @@ class HuaIot
            :iot_fun => "2.9.6",
            :req_header => {:authorization => 'Bearer ' + token,
                            :content_type => 'application/json',
-                           :app_key => app_id
+                           :app_key => app_id,
+                           :platform => "Huawei oceanconnect"
            }}
     client_iot_mongo.audit_iot_logger(fff, url_string, req_body, output_str)
     output_str
@@ -344,6 +399,7 @@ class HuaIot
 
   #2.9.19 Querying the Complete Device Type List of All Device Capabilities
   def querying_device_type_list(app_id, secret)
+    output_ans = {}
     token = get_token(app_id, secret)[:body]["accessToken"]
     path = "/iocm/app/profile/v1.1.0/allDeviceTypes"
     url_string = "https://" + platformip + ":" + platformport + path
@@ -358,13 +414,24 @@ class HuaIot
     request['Authorization'] = 'Bearer ' + token
     request['app_key'] = app_id
     res = https.request(request)
-    {:code => res.code, :message => res.message, :body => JSON.parse(res.body.to_s)}
+    output_ans = {:code => res.code, :message => res.message, :body => JSON.parse(res.body.to_s)}
+
+    fff = {:func => "querying_device_type_list",
+           :iot_fun => "2.9.19",
+           :req_header => {:content_type => 'application/json',
+                           :authorization => 'Bearer ' + token,
+                           :app_key => app_id,
+                           :platform => "Huawei oceanconnect"
+           }}
+    client_iot_mongo.audit_iot_logger(fff, url_string, "Get", output_ans)
+    output_ans
+
   end
 
 
   #2.9.6 Querying Directly Connected Devices and Their Mounted Devices in Batches
   def quer_dev_direct_conn_batches(app_id, dev_list, token)
-
+    output_ans = {}
     path = "/iocm/app/dm/v1.1.0/queryDevicesByIds"
     url_string = "https://" + platformip + ":" + platformport + path
     p url_string
@@ -378,10 +445,19 @@ class HuaIot
     request.content_type = 'application/json'
     request['Authorization'] = 'Bearer ' + token
     request['app_key'] = app_id
-    request.body = {deviceIds: dev_list}.to_json
+    data = {deviceIds: dev_list}
+    request.body = data.to_json
     res = https.request(request)
-    {:code => res.code, :message => res.message, :body => JSON.parse(res.body.to_s)}
-
+    output_ans =  {:code => res.code, :message => res.message, :body => JSON.parse(res.body.to_s)}
+    fff = {:func => "quer_dev_direct_conn_batches",
+           :iot_fun => "2.9.6",
+           :req_header => {:content_type => 'application/json',
+                           :authorization => 'Bearer ' + token,
+                           :app_key => app_id,
+                           :platform => "Huawei oceanconnect"
+           }}
+    client_iot_mongo.audit_iot_logger(fff, url_string, data, output_ans)
+    output_ans
   end
 
 
@@ -417,7 +493,8 @@ class HuaIot
              :iot_fun => "2.2.11",
              :req_header => {:authorization => 'Bearer ' + token,
                              :content_type => 'application/json',
-                             :app_key => app_id
+                             :app_key => app_id,
+                             :platform => "Huawei oceanconnect"
              }}
       client_iot_mongo.audit_iot_logger(fff, url_string, req_b, out_resp)
     rescue

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

@@ -155,6 +155,38 @@ class InternalFunc
     answer
   end
 
+  #compare dictionaries
+  def compare_dict(dict1, dict2)
+    v1 = dict1 - dict2
+    v2 = dict2 - dict1
+    v3 = dict2 + dict1
+    v3.uniq - v2.uniq - v1.uniq
+  end
+
+
+  #delete one key from hash
+  def delete_key_hash(hash_f, delete_key)
+    res = {}
+    hash_f.each do |ggg|
+      if ggg[0].to_s != delete_key.to_s
+        res[ggg[0]] = ggg[1]
+      end
+    end
+    res
+  end
+
+
+  #process hash array. Transform keys to string keys
+  def hash_val_to_string(hash_full)
+    resp = {}
+    hash_full.each do |hsh|
+      resp[hsh[0].to_s] = hsh[1]
+    end
+    resp
+  end
+
+
+
   def test()
     p "eeeeeeeeeeeeeeeeeeeeeeee"
   end

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

@@ -194,7 +194,7 @@ class MongoIot
     begin
       result_ps = []
       collection = client[:device_profiles]
-      collection.find({"profile_id" => profile_id}).each {|row|
+      collection.find({"profile_id" => profile_id.to_i}).each {|row|
         result_ps.append(row)
       }
       result_ps[0]
@@ -238,7 +238,7 @@ class MongoIot
     begin
       result_ps = []
       collection = client[:device_types]
-      collection.find({"type_id" => type_id}).each {|row|
+      collection.find({"type_id" => type_id.to_i}).each {|row|
         result_ps.append(row)
       }
       result_ps[0]
@@ -260,19 +260,20 @@ class MongoIot
     end
   end
 
+  #universal procedure. might be profile id or name
   def check_login_profile_permiss(login, profile)
     out_resp = {}
     get_login_info = get_profiles_by_login(login)
-    if get_login_info[:code]==200
-      dst_profile = get_profile_id_by_name(profile)
-      access=1
-      if get_login_info[:body]!=[]
-        if dst_profile!=[]
+    if get_login_info[:code] == 200
+      dst_profile = get_profile_universal(profile)
+      access = 1
+      if get_login_info[:body] != []
+        if dst_profile != []
           for j in get_login_info[:body]
-            if j["profile_id"].to_i==dst_profile["profile_id"].to_i
-              access=0
+            if j["profile_id"].to_i == dst_profile["profile_id"].to_i
+              access = 0
             end
-            if access==0
+            if access == 0
               out_resp = {:code => 200, :result => "check_login_profile_permiss: Permission granted"}
             else
               out_resp = {:code => 400, :result => "check_login_profile_permiss: Access denied. This incident will be reported."}
@@ -292,13 +293,15 @@ class MongoIot
   end
 
 
+  #universal procedure. You can use profile id or profile name as profile_id (string or int)
   def check_login_prof_perm_id_one(login, profile_id)
     out_resp = {}
     get_login_info = get_profiles_by_login(login)
+    profile_data = self.get_profile_universal(profile_id)
     access=1
     if get_login_info[:body]!=[]
       for j in get_login_info[:body]
-        if j["profile_id"].to_i==profile_id.to_i
+        if j["profile_id"].to_i==profile_data["profile_id"]
           access=0
         end
         if access==0
@@ -340,7 +343,6 @@ class MongoIot
             description: "test imei",
             note: "second description",
             profile: 0,
-            type: 0,
             device_type: 0,
             address: "unknown"
         }
@@ -364,7 +366,6 @@ class MongoIot
             description: "test imei",
             note: "second description",
             profile: 0,
-            type: 0,
             device_type: 0,
             address: "unknown"
         }
@@ -503,6 +504,7 @@ class MongoIot
 
 
   #function for get iot platform credentials from profile
+  #universal procedure. use profile or profile id
   def get_iot_oceanconn_credent_2(profile)
     out_resp = {}
     begin
@@ -538,7 +540,7 @@ class MongoIot
         result_ps.append(row)
       }
       dattaa = result_ps[0]
-      if dattaa!=nil
+      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"}}
@@ -550,6 +552,7 @@ class MongoIot
     out_resp
   end
 
+  #universal procedure. Use id or name
   def get_device_type_info_universal(device_model)
     out_resp = {}
     begin
@@ -563,9 +566,9 @@ class MongoIot
         }
         dattaa = result_ps[0]
         if dattaa!=nil
-          out_resp = {:code => 200, :result => "get_device_type_info_by_model: Request completed successfully", :body => dattaa}
+          out_resp = {:code => 200, :result => "get_device_type_info_universal: 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"}}
+          out_resp = {:code => 404, :result => "get_device_type_info_universal: Device info not found", :body => {"model" => device_model, "ManufacturerID" => "unknown", "ManufacturerNAME" => "unknown", "device_type" => "unknown"}}
         end
       else
         result_ps2 = []
@@ -575,9 +578,9 @@ class MongoIot
         }
         dattaa = result_ps2[0]
         if dattaa!=nil
-          out_resp = {:code => 200, :result => "get_device_type_info_by_model: Request completed successfully", :body => dattaa}
+          out_resp = {:code => 200, :result => "get_device_type_info_universal: 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"}}
+          out_resp = {:code => 404, :result => "get_device_type_info_universal: Device info not found", :body => {"model" => device_model, "ManufacturerID" => "unknown", "ManufacturerNAME" => "unknown", "device_type" => "unknown"}}
         end
       end
 
@@ -681,6 +684,7 @@ class MongoIot
   end
 
 
+  #universal procedure. put there profile name or id in string or int
   def get_profile_universal(profile)
     inn = internal_func.if_digit_or_string(profile)
     out = {}

data/lib/imperituroard/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: imperituroard
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.1.0
 platform: ruby
 authors:
 - Dzmitry Buynovskiy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-08 00:00:00.000000000 Z
+date: 2020-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -187,6 +187,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".idea/runConfigurations/hua_oceanconnect_adapter.xml"
+- ".idea/runConfigurations/version.xml"
 - ".ruby-gemset"
 - ".ruby-version"
 - ".travis.yml"