imperituroard 0.5.7 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 96222a0e0f14b7abc4ff4d1434d6c55115f07623
-  data.tar.gz: 8d1d4264fa33fec3d27cfb5c7c900c1f293a1112
+  metadata.gz: e940fef724694620f92446e776b76f186aefb9f2
+  data.tar.gz: 7684c9da421ec5e068e1992aa69d9908d8617398
 SHA512:
-  metadata.gz: 3c8887a0051b6fb3e7d57d3092ae7ac343f677e32d2e24a2ebaaaf8e54acd15662ad41185d4e2c588a2987001c2c7a5a8fcdc24eb7c65bad6633bdf316f7634b
-  data.tar.gz: 98c743b8d56c5a6b637edeb8f11445664ab30af49625eae7d6d1e76f9fa04cebb9dffb07b30fa16a230b08034a86314c8eac6f93e9981476266c296f73113368
+  metadata.gz: 192b9dc5e4d12006aa68c10cd50455edffb5c6d0ed0452022437653c7780c506e40a99bf2a084c1ce264fd4f5214e8511e37f4e8c32e505a8b54638be9422bab
+  data.tar.gz: 65d41e4c02a8f54585dd6652e9637e60b0b60204788d7e0bcfd50ed7632ee3c9959dc7f50a26745189a11cf8104f1859843d67cedb0ed47602df6463a3d8b559

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/platforms/staros/staros_automation.rb

@@ -0,0 +1,95 @@
+require 'net/ssh'
+
+staros_thr_1233 = []
+conf = {}
+
+staros_hosts = {
+    #5700
+}
+
+def printer (config)
+  for gggg1 in config
+
+    p ""
+    p ""
+    p "##{gggg1[0]}"
+    for jjj in gggg1[1]
+      p jjj
+    end
+  end
+end
+
+staros_hosts.each do |ggsn|
+  staros_thr_1233 << Thread.new do
+
+    p ggsn
+
+    begin
+
+      conf[ggsn[0]] = []
+
+      Net::SSH.start(ggsn[1], "ывапывап", :password => "пыапыва") do |ssh|
+        staros_answer = ssh.exec!("show configuration context Ga | grep edr")
+
+        regexp = /file name (\S+) rotation volume (\d+) rotation time \d+ storage-limit \d+ headers edr-format-name compression gzip file-sequence-number rulebase-seq-num/
+
+        ggg = staros_answer.match(regexp)
+        conf[ggsn[0]].push("configure")
+        conf[ggsn[0]].push("context Ga")
+        conf[ggsn[0]].push("edr-module active-charging-service charging")
+        conf[ggsn[0]].push("file name #{ggg[1]} rotation volume 40000000 rotation time 600 storage-limit 536870912 headers edr-format-name compression gzip file-sequence-number rulebase-seq-num")
+        conf[ggsn[0]].push("end")
+
+        #config
+        # staros_answer1 = ssh.exec!("configure")
+        # p staros_answer1
+        # staros_answer2 = ssh.exec!("context Ga")
+        # p staros_answer2
+        # staros_answer3 = ssh.exec!("edr-module active-charging-service charging")
+        # p staros_answer3
+        # staros_answer4 = ssh.exec!("file name #{ggg[1]} rotation volume 40000000 rotation time 600 storage-limit 536870912 headers edr-format-name compression gzip file-sequence-number rulebase-seq-num")
+        # p staros_answer4
+        # staros_answer5 = ssh.exec!("end")
+        # p staros_answer5
+
+        #check
+        staros_answer7 = ssh.exec!("show configuration | grep hostname")
+        reggg = /system hostname (\S+)/
+        hostname_this = staros_answer7.match(reggg)[1]
+
+        staros_answer8 = ssh.exec!("show configuration context Ga | grep edr")
+        regexp2 = /file name (\S+) rotation volume (\d+) rotation time \d+ storage-limit \d+ headers edr-format-name compression gzip file-sequence-number rulebase-seq-num/
+
+        ggg2 = staros_answer8.match(regexp2)
+
+        a1 = ggg2[1].gsub("edr-", "")
+        #p a1
+        #p hostname_this
+        #p ggg2
+
+        if a1 != hostname_this
+          p "incorrect: #{hostname_this}"
+        end
+
+
+        if ggg2[2] == "40000000"
+        else
+          p "incorrect value: #{hostname_this}"
+        end
+
+      end
+
+    rescue
+
+      p "#{ggsn[0]} ERROR"
+
+    end
+
+  end
+end
+staros_thr_1233.each(&:join)
+
+#p conf
+
+
+#printer(conf)

data/lib/imperituroard/platforms/staros/staros_automation_fun.rb

@@ -0,0 +1,37 @@
+require 'net/ssh'
+
+class StarosAutomationFun
+
+  attr_accessor :ignore_y
+
+  def initialize
+    @ignore_y = 1 #1-yes, 0-no
+  end
+
+  def staros_massive_command(staros_hosts, staros_login, staros_password, command_array)
+
+
+    staros_thr_pool_222 = []
+
+    staros_hosts.each do |ggsn|
+      staros_thr_pool_222 << Thread.new do
+
+        Net::SSH.start(ggsn[1], staros_login, :password => staros_password) do |session|
+
+          gg = session.exec!("context AAA")
+          p gg
+          gg1 = session.exec!("show subscribers summary")
+          p gg1
+
+
+
+        end
+
+
+
+      end
+    end
+    staros_thr_pool_222.each(&:join)
+
+  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
+              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}
+
+                                  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