imperituroard 1.0.1 → 1.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7f4803bd76c090876b654425c6a5a76237ce07da
-  data.tar.gz: afc8920cded7afea1bab18ebc83ab992915f1329
+  metadata.gz: 4f4aba43e40c3e31b5d3336e6dd8233ced0fdc47
+  data.tar.gz: 14a08ce0ee5ee4af6f0af163c4eb148e1c18274b
 SHA512:
-  metadata.gz: fa6fd8bb0af774f0acd9a01cd74bb1851f5c437eb06c981a86767d1c0151261f3b62f4bba1624d835bc2902147229d2828f9a1ff8291134ada8786cc3a8acebc
-  data.tar.gz: 19874621621215547e23187b1643f3422d44228d071e357fada3b91e7f0cb35f76e4df8c4b5c5c28bd6194a06f9a9c8f17106a3bc19b6ee5e4c5e0871a7b3ced
+  metadata.gz: bbb81cd14c71ebe0693054322a33f8ad93096cada10528eb7665d8f822ec53430f42f81ccbaeb632bc7f41441509fda8dc2d0b69b54de6cdea11abe5034ac306
+  data.tar.gz: 6d9f3d756baaa25e8eacbb630822b1c26449d677caaa3dc0d47e8c79c1e514dfe6321c5370922f7b41da86ca466437f03ee1f2d45fffca990a73a4941053feff

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###
 
 
@@ -141,7 +140,7 @@ class IotFunctions_2
 
                     #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"])
                     resss = hua_aceanconnect_connector.add_new_device_on_huawei(credentials[:body][:app_id],
                                                                                 credentials[:body][:secret],
                                                                                 aaa["imei"],
@@ -154,7 +153,6 @@ 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
@@ -163,15 +161,12 @@ class IotFunctions_2
                         s1[:created] = DateTime.now
                         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
@@ -187,16 +182,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
@@ -206,9 +197,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
@@ -228,16 +217,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})
@@ -467,12 +456,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###
 
@@ -486,17 +475,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}
@@ -580,10 +569,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#######
@@ -658,7 +645,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
@@ -686,9 +673,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
@@ -745,6 +730,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"],
@@ -849,33 +835,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],
@@ -939,6 +939,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"],
@@ -952,7 +954,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
 
 
@@ -971,138 +972,163 @@ class IotFunctions_2
     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
-              prof_new_id = mongo_client.get_profile_universal(curr_dev["new_profile"])["profile_id"]
-
-              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"], curr_dev["new_type"])
-
-                  p cur_comp1
-                  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)
-                    #########
-                    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(curr_dev["new_type"])
-
-                          #####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}
+    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
 
-                                  answ_mongo = mongo_client.modify_attr_mongo_universal(curr_dev["imei"].to_i, attribute)
+                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
 
-                                  if answ_mongo[:code] != 200
-                                    not_processed_list.append({:imei => curr_dev["imei"], :error => "Critical error. Mongo not updated", :mongo_err => answ_mongo})
+                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]["device_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
-                                    processed_list.append(curr_dev)
+                                    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
                                   end
-
-                                  #added_on_iot_platf.append(s1)
+                                else
+                                  not_processed_list.append({:imei => curr_dev["imei"], :error => resss})
                                 end
-
-                              else
-                                not_processed_list.append({:imei => curr_dev["imei"], :error => resss})
+                              rescue
+                                not_processed_list.append({:imei => curr_dev["imei"], :error => "Unknown error with insertion imei on IOT platform"})
                               end
-                            rescue
-                              not_processed_list.append({:imei => curr_dev["imei"], :error => "Unknown error with insertion imei on IOT platform"})
+                            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"})
                           end
                         else
-                          not_processed_list.append({:imei => curr_dev["imei"], :error => "Not processed by iot platform. deviceId not found in mongoDB"})
+                          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 info from database"})
+                        not_processed_list.append({:imei => curr_dev["imei"], :error => "Failed to get credentials from database"})
                       end
-                    else
-                      not_processed_list.append({:imei => curr_dev["imei"], :error => "Failed to get credentials from database"})
                     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 => "New profile modification not permitted"})
+                  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 => "Old profile modification not permitted"})
+                not_processed_list.append({:imei => curr_dev["imei"], :error => "Unknown current profile"})
               end
             else
-              not_processed_list.append({:imei => curr_dev["imei"], :error => "Unknown current profile"})
+              not_processed_list.append({:imei => curr_dev["imei"], :error => "Device not exists"})
             end
           else
-            not_processed_list.append({:imei => curr_dev["imei"], :error => "Device not exists"})
+            not_processed_list.append({:imei => curr_dev["imei"], :error => "IMEI can't be nil"})
           end
-        else
-          not_processed_list.append({:imei => curr_dev["imei"], :error => "IMEI can't be nil"})
+        rescue
+          not_processed_list.append({:imei => curr_dev["imei"], :error => "Unknown SDK error"})
         end
-      rescue
-        not_processed_list.append({:imei => curr_dev["imei"], :error => "Unknown SDK error"})
-      end
 
-    end
+      end
 
-    err_li = []
-    if not_processed_list.length > 0
-      not_processed_list.each do |err_l|
-        err_li.append({:failedimei => err_l[:imei]})
+      err_li = []
+      if not_processed_list.length > 0
+        not_processed_list.each do |err_l|
+          err_li.append({:failedimei => err_l[:imei]})
+        end
       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}}
+      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 => soap_answ, :not_processed_list => not_processed_list, :processed_list => processed_list}}
+    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
 
 

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

@@ -74,6 +74,12 @@ 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',
+                             :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
@@ -106,6 +112,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 => "token_logout",
+             :iot_fun => "logout",
+             :platform => "Huawei oceanconnect"
+      }
+      client_iot_mongo.audit_iot_logger(fff, url_string, data, out_resp)
     rescue
       out_resp = {:code => 500, :message => "failed logout token"}
     end
@@ -116,6 +127,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
@@ -129,10 +141,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)
-    p res.body.to_s
-    {: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)
@@ -168,7 +187,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
@@ -191,13 +211,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
 
@@ -220,26 +248,22 @@ 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
+                             :app_key => app_id,
+                             :platform => "Huawei oceanconnect"
              }}
       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
 
@@ -271,6 +295,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
@@ -285,12 +310,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
@@ -305,11 +340,21 @@ 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
   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
@@ -323,14 +368,25 @@ 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,
+                           :platform => "Huawei oceanconnect"
+           }}
+    client_iot_mongo.audit_iot_logger(fff, url_string, req_body, output_str)
+    output_str
   end
 
 
   #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
@@ -345,13 +401,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
@@ -365,10 +432,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
 
 
@@ -390,7 +466,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
@@ -399,6 +476,14 @@ 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,
+                             :platform => "Huawei oceanconnect"
+             }}
+      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

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

@@ -155,6 +155,14 @@ 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
+
   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,7 @@ class MongoIot
             description: "test imei",
             note: "second description",
             profile: 0,
-            type: 0,
+            device_type: 0,
             address: "unknown"
         }
         result = collection.insert_one(l)
@@ -363,7 +366,7 @@ class MongoIot
             description: "test imei",
             note: "second description",
             profile: 0,
-            type: 0,
+            device_type: 0,
             address: "unknown"
         }
         result = collection.insert_one(l)
@@ -501,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
@@ -548,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
@@ -632,6 +637,9 @@ class MongoIot
     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
@@ -648,6 +656,7 @@ class MongoIot
     else
       tp1_data = {}
       tp2_data = {}
+      p "gggggggg"
       if tp1[:body][:string]
         tp1_data = self.get_type_by_name(type1)
       else
@@ -660,6 +669,11 @@ class MongoIot
         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
@@ -670,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,3 +1,4 @@
 module Imperituroard
-  VERSION = "1.0.1"
+  VERSION = "1.0.7"
 end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: imperituroard
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.7
 platform: ruby
 authors:
 - Dzmitry Buynovskiy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-07 00:00:00.000000000 Z
+date: 2020-06-08 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"