imperituroard 1.1.9 → 1.1.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 629626efbfcfa0108c2b1646a42d25856e6f3135
-  data.tar.gz: 8a3a7f5357873aa432d9058a2a54d933e6177c7d
+  metadata.gz: 43b90b49ef287bd5255675f8687a9fb6cc036f85
+  data.tar.gz: 3e97f122233aa15acaaf07a6bd25b1bc98af1d69
 SHA512:
-  metadata.gz: 61e4e034d6b705161bc67e7c270406cbb62a0306ca18c17a619b04b6cf78af4bd802c0f59517e5856101ec75be031be38086872e68893de159412ef241aaaf53
-  data.tar.gz: 87151a1bbfa092b6d77fef7279cf114446dba7540ca949b897cad0a8f77270afe3833d7d49678f7e46476fb144be849a805d2bc493c2c625b3a185630f1e96ad
+  metadata.gz: 17e89a0109c1f6d8821a39e7e1a8572cf0d8fe3c6795120d3000a2242f6a9e1987bfa6b920d2a8b7b72bd39d74e8d08ec85ca1a2098844231ccaf7f1d3b6e51c
+  data.tar.gz: bacdd4a4e1f59f9530daede8cc142672d044fc16a04f8ed5d3a329e4c25007911f39b8b90ee828710743b17da5785473a3cec9f9bd3868d65a0a65c9a1e57152

data/.idea/runConfigurations/dabrab_proced.xml

@@ -0,0 +1,21 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="dabrab_proced" 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/projects/mhub/subs/dabrab" />
+    <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/projects/mhub/subs/dabrab/dabrab_proced.rb" />
+    <RUBY_RUN_CONFIG NAME="SCRIPT_ARGS" VALUE="" />
+    <method />
+  </configuration>
+</component>

data/.idea/runConfigurations/test9_dab.xml

@@ -0,0 +1,21 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="test9_dab" 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$/test" />
+    <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$/test/test9_dab.rb" />
+    <RUBY_RUN_CONFIG NAME="SCRIPT_ARGS" VALUE="" />
+    <method />
+  </configuration>
+</component>

data/lib/imperituroard.rb

@@ -311,19 +311,21 @@ class Mhub_2
                 :internal_func,
                 :dabrab_connecter,
                 :static_callback,
-                :crm_connector
+                :crm_connector,
+                :log_level
 
-  def initialize(sk_url_simple, sk_login, sk_password, telegram_api_url, telegram_chat_id, sk_url_broadcast, static_callback, crm_callback_url, crm_login, crm_password, sms_alphaname)
+  def initialize(sk_url_simple, sk_login, sk_password, telegram_api_url, telegram_chat_id, sk_url_broadcast, static_callback, crm_callback_url, crm_login, crm_password, sms_alphaname, log_level="error")
     @sk_url = sk_url_simple
     @sk_login = sk_login
     @sk_password = sk_password
+    @log_level = log_level
     @internal_func = InternalFunc.new
-    @mhub_connector = Sksk_2.new(sk_url_simple, sk_login, sk_password, sk_url_broadcast, telegram_api_url, telegram_chat_id)
+    @mhub_connector = Sksk_2.new(sk_url_simple, sk_login, sk_password, sk_url_broadcast, telegram_api_url, telegram_chat_id, log_level)
     @internal_func = InternalFunc.new
-    @dabrab_connecter = Dabrab.new
+    @dabrab_connecter = Dabrab.new(log_level)
     @static_callback = static_callback
-    @crm_connector = Crm_2.new(crm_callback_url, crm_login, crm_password, telegram_api_url, telegram_chat_id)
-    @mhub_connector = MhubFunctions_2.new(sk_url_simple, sk_login, sk_password, telegram_api_url, telegram_chat_id, sk_url_broadcast, static_callback, crm_callback_url, crm_login, crm_password, sms_alphaname)
+    @crm_connector = Crm_2.new(crm_callback_url, crm_login, crm_password, telegram_api_url, telegram_chat_id, log_level)
+    @mhub_connector = MhubFunctions_2.new(sk_url_simple, sk_login, sk_password, telegram_api_url, telegram_chat_id, sk_url_broadcast, static_callback, crm_callback_url, crm_login, crm_password, sms_alphaname, log_level)
   end
 
   #{"destinations"=>[{"to"=>{"phoneNumber"=>"375297116638", "emailAddress"=>nil}}],
@@ -339,8 +341,12 @@ class Mhub_2
     mhub_connector.get_send_message_2(params, ip_src, ip_real, ip_vip)
   end
 
-  def recieve_delivery_report(params, ip_src, ip_real, ip_vip)
-    mhub_connector.rec_deliv_report_2(params, ip_src, ip_real, ip_vip)
+  def get_send_message_mass(params, ip_src, ip_real, ip_vip, slice_number=100, time_pause_minutes=5)
+    mhub_connector.get_send_message_mass_2(params, ip_src, ip_real, ip_vip, slice_number, time_pause_minutes)
+  end
+
+  def recieve_delivery_report(params, ip_src, ip_real, ip_vip, crm_slice_num)
+    mhub_connector.rec_deliv_report_2(params, ip_src, ip_real, ip_vip, crm_slice_num)
   end
 
 end

data/lib/imperituroard/add_functions/logger/any_functions.rb

@@ -14,8 +14,10 @@ class LogAddFunctions_2
   end
 
   def printer_texter(text, log_level)
-    mess = {:datetime => datetimenow, :sdk => "imperituroard", :sdk_version => Imperituroard::VERSION, :message => text}
-    p mess
+    if log_level == debug
+      mess = {:datetime => datetimenow, :sdk => "imperituroard", :sdk_version => Imperituroard::VERSION, :message => text}
+      p mess
+    end
   end
 
 

data/lib/imperituroard/platforms/iwag/get_iwag_data.rb

@@ -0,0 +1,90 @@
+require 'net/ssh'
+
+class IwagRequester
+
+  attr_accessor :iwag_host, :iwag_login, :iwag_password
+
+  def initialize(iwag_host, iwag_login, iwag_password)
+    @iwag_host = iwag_host
+    @iwag_login = iwag_login
+    @iwag_password = iwag_password
+  end
+
+  def mac_parse(mac)
+    a = mac.upcase
+    pos = a[0] + a[1]
+    if pos == "01"
+      subscribers_mac = a[2] + a[3] + ":" + a[5] + a[6] + ":" + a[7] + a[8] + ":" + a[10] + a[11] + ":" + a[12] + a[13] + ":" + a[15] + a[16]
+    else
+      subscribers_mac = a[0] + a[1] + ":" + a[2] + a[3] + ":" + a[5] + a[6] + ":" + a[7] + a[8] + ":" + a[10] + a[11] + ":" + a[12] + a[13]
+    end
+    subscribers_mac
+  end
+
+
+  def iwag_get_dhcp_binding_ssh(bind_ip)
+    mac = "Unknown"
+    accessinterface = "Unknown"
+    hostname = "Unknown"
+    ssid = "Unknown"
+    iwag_thr = Thread.new do
+      Net::SSH.start(iwag_host, iwag_login, :password => iwag_password) do |session|
+        answ_bind = session.exec!("show ip dhcp binding #{bind_ip}")
+        regexp_main = /\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}\s{1,20}(\w{2,4}.\w{2,4}.\w{2,4}.\w{2,4})|\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}\s{1,20}(\w{4}.\w{4}.\w{4})/
+        #regexp_main = /\r\n(\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3})\s+(\S{13,18})\s+Sep 18 2020 07:44 PM\s+Automatic\s+Active\s+Tunnel201\r\n/
+        ggg7 = answ_bind.match(regexp_main)
+        begin
+          if ggg7[1] != nil
+            mac = mac_parse(ggg7[1])
+          else
+            mac = mac_parse(ggg7[2])
+          end
+        rescue
+          mac = "Unknown"
+        end
+        regexp_remote_id = /Remote id :\s(\S{2,100})/
+        regexp_tunnel = /Active\s{2,40}(\S{2,40})|Selecting\s{2,40}(\S{2,40})/
+        regexp_curcuit_id = /Circuit id :\s(\S{2,100})/
+        ggg9 = answ_bind.match(regexp_tunnel)
+
+        begin
+          if ggg9[1] != nil
+            accessinterface = ggg9[1]
+          else
+            accessinterface = ggg9[2]
+          end
+        rescue
+          accessinterface = "Unknown"
+        end
+        ggg8 = answ_bind.match(regexp_remote_id)
+        ggg10 = answ_bind.match(regexp_curcuit_id)
+        begin
+          a1 = ggg8[1].split(":")
+          hostname = a1[0]
+          ssid = a1[1]
+        rescue
+          begin
+            if ggg8[1] != nil
+              if ggg8[1].include?("wireless_public_interface")
+                hostname = ggg10[1]
+                ssid = "Unknown"
+              else
+                hostname = ggg8[1]
+                ssid = "Unknown"
+              end
+            else
+              ssid = "Unknown"
+              hostname = "Unknown"
+            end
+          rescue
+            ssid = "Unknown"
+            hostname = "Unknown"
+          end
+        end
+      end
+    end
+    iwag_thr.join
+    {"mac": mac, "iwaginterface": accessinterface, "aphostname": hostname, "SSID": ssid}
+  end
+
+end

data/lib/imperituroard/platforms/iwag/iwag_database_worker.rb

@@ -0,0 +1,24 @@
+
+
+class IwagDbCache
+
+  attr_accessor :db_host, :db_login, :db_password
+
+  def initialize(db_host, db_login, db_password)
+    @db_host = db_host
+    @db_login = db_login
+    @db_password = db_password
+  end
+
+  def check_db_exists(ip)
+
+  end
+
+
+  def insert_new_cache()
+
+  end
+
+
+end
+

data/lib/imperituroard/platforms/iwag/iwag_telnet_connector.rb

@@ -0,0 +1,112 @@
+require 'net-telnet'
+require 'net/ssh'
+require 'date'
+
+class CSRtelnet_1
+
+  attr_accessor :iwag1_host, :iwag_username, :iwag_password
+
+  def initialize(iwag1_host, iwag_username, iwag_password)
+    @iwag1_host = iwag1_host
+    @iwag_username = iwag_username
+    @iwag_password = iwag_password
+  end
+
+  def get_subs_mac2_1(ipaddress)
+
+    subscribers_mac = ""
+
+    #begin
+
+      dump =""
+      connection = Net::Telnet.new( "Host" => iwag1_host, "Timeout" => false, "Prompt" => /.*\#/ ) { |str| }
+      connection.login({ "Name" => iwag_username, "Password" => iwag_password, "LoginPrompt" => /Username:/ }) { |str|  }
+      connection.cmd("show ip dhcp binding #{ipaddress}") {
+          |c|
+        p c
+        dump << c
+      }
+      connection.close
+      as = dump.split("\n")
+      p as
+      reer = as[4].split(" ")
+
+      ma = reer[1].to_s.upcase
+      pos = ma[0]+ma[1]
+      if pos=="01"
+        subscribers_mac = ma[2]+ma[3]+":"+ma[5]+ma[6]+":"+ma[7]+ma[8]+":"+ma[10]+ma[11]+":"+ma[12]+ma[13]+":"+ma[15]+ma[16]
+      else
+        subscribers_mac = ma[0]+ma[1]+":"+ma[2]+ma[3]+":"+ma[5]+ma[6]+":"+ma[7]+ma[8]+":"+ma[10]+ma[11]+":"+ma[12]+ma[13]
+      end
+
+
+    #rescue
+    #  subscribers_mac = "unknown"
+    #end
+
+    return subscribers_mac
+
+  end
+
+
+  #test function. Not used
+  def get_iwag_info_ssh_1(ipaddress)
+    p DateTime.now
+    Net::SSH.start(iwag1_host, iwag_username, :password => iwag_password) do |ssh|
+      result = ssh.exec!("show ip dhcp binding #{ipaddress}\n")
+      p result
+    end
+    p DateTime.now
+  end
+
+
+
+  def return_iwag_access_interface_1(ipaddress)
+    host_iwag = iwag1_host
+    username_iwag = iwag_username
+    password_iwag = iwag_password
+    answer =""
+
+    dump =""
+    begin
+      connection = Net::Telnet.new("Host" => host_iwag, "Timeout" => false, "Prompt" => /.*\#/) {|str| print str}
+      connection.login({"Name" => username_iwag, "Password" => password_iwag, "LoginPrompt" => /Username:/}) {|str| print str}
+      connection.cmd("show ip dhcp binding #{ipaddress}") {
+          |c|
+        dump << c
+      }
+      connection.close
+      as = dump.split("\n")
+
+      if as[4] != nil && as[3] != ""
+        access_interface = as[4].gsub!("  ", "").split(" ").last
+        return access_interface
+      else
+        answer ="false"
+        return answer
+      end
+    rescue
+      begin
+        connection = Net::Telnet.new("Host" => host_iwag, "Timeout" => false, "Prompt" => /.*\#/) {|str| print str}
+        connection.login({"Name" => username_iwag, "Password" => password_iwag, "LoginPrompt" => /Username:/}) {|str| print str}
+        connection.cmd("show ip dhcp binding #{ipaddress}") {
+            |c|
+          dump << c
+        }
+        connection.close
+        as = dump.split("\n")
+        if as[4] != nil && as[3] != ""
+          access_interface = as[4].gsub!("  ", "").split(" ").last
+          return access_interface
+        else
+          answer ="false"
+          return answer
+        end
+      rescue
+        return "unknown"
+      end
+    end
+  end
+
+
+end

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

@@ -21,8 +21,10 @@ class InternalFunc
   end
 
   def printer_texter(text, log_level)
-    mess = {:datetime => datetimenow, :sdk => "imperituroard", :sdk_version => Imperituroard::VERSION, :message => text}
-    p mess
+    if log_level == "debug"
+      mess = {:datetime => datetimenow, :sdk => "imperituroard", :sdk_version => Imperituroard::VERSION, :message => text}
+      p mess
+    end
   end
 
   def prof_id_list_transform_mongo(id_list)
@@ -176,7 +178,7 @@ class InternalFunc
       end
     end
     out_data = res
-    printer_texter({:out_data => out_data, :inp_fun => inp_fun, :fun => "delete_key_hash" }, "debug")
+    printer_texter({:out_data => out_data, :inp_fun => inp_fun, :fun => "delete_key_hash"}, "debug")
     out_data
   end
 
@@ -191,7 +193,6 @@ class InternalFunc
   end
 
 
-
   def test()
     p "eeeeeeeeeeeeeeeeeeeeeeee"
   end

data/lib/imperituroard/projects/mhub.rb

@@ -24,19 +24,21 @@ class MhubFunctions_2
                 :static_callback,
                 :crm_connector,
                 :telegram_connector,
-                :sms_alphaname
+                :sms_alphaname,
+                :log_level
 
-  def initialize(sk_url_simple, sk_login, sk_password, telegram_api_url, telegram_chat_id, sk_url_broadcast, static_callback, crm_callback_url, crm_login, crm_password, sms_alphaname)
+  def initialize(sk_url_simple, sk_login, sk_password, telegram_api_url, telegram_chat_id, sk_url_broadcast, static_callback, crm_callback_url, crm_login, crm_password, sms_alphaname, log_level)
     @sk_url = sk_url_simple
     @sk_login = sk_login
     @sk_password = sk_password
+    @log_level = log_level
     @internal_func = InternalFunc.new
-    @mhub_connector = Sksk_2.new(sk_url_simple, sk_login, sk_password, sk_url_broadcast, telegram_api_url, telegram_chat_id)
+    @mhub_connector = Sksk_2.new(sk_url_simple, sk_login, sk_password, sk_url_broadcast, telegram_api_url, telegram_chat_id, log_level)
     @internal_func = InternalFunc.new
-    @dabrab_connecter = Dabrab.new
+    @dabrab_connecter = Dabrab.new(log_level)
     @telegram_connector = Telegram_2.new(telegram_api_url, telegram_chat_id)
     @static_callback = static_callback
-    @crm_connector = Crm_2.new(crm_callback_url, crm_login, crm_password, telegram_api_url, telegram_chat_id)
+    @crm_connector = Crm_2.new(crm_callback_url, crm_login, crm_password, telegram_api_url, telegram_chat_id, log_level)
     @sms_alphaname = sms_alphaname
   end
 
@@ -58,6 +60,7 @@ class MhubFunctions_2
     output_params = {}
     hub_resp = {}
     null_statement = [nil, "nil", "", "null"]
+    mes_data = {}
 
     begin
 
@@ -93,6 +96,7 @@ class MhubFunctions_2
 
         msisdn2 = dabrab_connecter.num_formatter(params["destinations"], params["notifyUrl"].split(":")[2])
 
+
         if null_statement.include?(params["viber"]) && !null_statement.include?(params["sms"])
           hub_resp = mhub_connector.sk_send_sms_list(msisdn2, static_callback, params["sms"]["text"], sms_alphaname)
         elsif !null_statement.include?(params["viber"]) && null_statement.include?(params["sms"])
@@ -104,13 +108,13 @@ class MhubFunctions_2
         else
           output_params = {"code": 502, "result": "Invalid input data st2", "body": {"answer": {}, "sender": {"ip_src": ip_src, "ip_real": ip_real, "ip_vip": ip_vip}}}
         end
+        mes_data = dabrab_connecter.send_responce_formatter(hub_resp)
+
+
       else
         output_params = {"code": 503, "result": "Invalid recipients", "body": {"answer": {}, "sender": {"ip_src": ip_src, "ip_real": ip_real, "ip_vip": ip_vip}}}
       end
 
-      mes_data = dabrab_connecter.send_responce_formatter(hub_resp)
-      p hub_resp
-
       output_params = {"code": 200, "result": "Data processed", "body": {"answer": mes_data[:body][:mess_to_recip], "sender": {"ip_src": ip_src, "ip_real": ip_real, "ip_vip": ip_vip}}}
 
     rescue
@@ -118,21 +122,75 @@ class MhubFunctions_2
       telegram_connector.telegram_message(output_params)
     end
 
-    internal_func.printer_texter({:input => input_params, :output => output_params, :hub_resp => hub_resp, :procedure => "Mhub_2.get_send_message"}, "debug")
+    internal_func.printer_texter({:input => input_params, :output => output_params, :hub_resp => hub_resp, :procedure => "Mhub_2.get_send_message"}, log_level)
+    output_params
+
+  end
+
+
+  #for bank dabrabyt for massive nums
+  def get_send_message_mass_2(params, ip_src, ip_real, ip_vip, slice_number, time_pause_minutes)
+
+    input_params = {:params => params}
+    output_params = {}
+
+    null_statement = [nil, "nil", "", "null"]
+    mes_data_answ = []
+
+    begin
+      internal_func.printer_texter({:input => params, :procedure => "Mhub_2.get_send_message_mass_2"}, log_level)
+      if params["destinations"].length >= 1
+        msisdn2 = dabrab_connecter.num_formatter(params["destinations"], params["notifyUrl"].split(":")[2])
+        splitted_parts = msisdn2.each_slice(slice_number).to_a
+        for part_list in splitted_parts
+
+          internal_func.printer_texter({:input => part_list, :procedure => "Mhub_2.get_send_message_mass_2"}, log_level)
+
+          hub_resp = {}
+
+          if null_statement.include?(params["viber"]) && !null_statement.include?(params["sms"])
+            hub_resp = mhub_connector.sk_send_sms_list(part_list, static_callback, params["sms"]["text"], sms_alphaname, time_pause_minutes)
+          elsif !null_statement.include?(params["viber"]) && null_statement.include?(params["sms"])
+            hub_resp = mhub_connector.sk_send_viber_list(part_list, static_callback, params["viber"]["text"], time_pause_minutes)
+          elsif !null_statement.include?(params["viber"]) && !null_statement.include?(params["sms"])
+            hub_resp = mhub_connector.sk_send_viber_sms_list(part_list, static_callback, params["sms"]["text"], params["viber"]["text"], sms_alphaname, time_pause_minutes)
+          else
+            output_params = {"code": 502, "result": "Invalid input data st2", "body": {"answer": {}, "sender": {"ip_src": ip_src, "ip_real": ip_real, "ip_vip": ip_vip}}}
+          end
+          mes_data = dabrab_connecter.send_responce_formatter(hub_resp)
+
+          internal_func.printer_texter({:input => mes_data, :procedure => "Mhub_2.get_send_message_mass_2"}, log_level)
+
+          mes_data_answ = mes_data_answ + mes_data[:body][:mess_to_recip][:messages]
+
+        end
+
+      else
+        output_params = {"code": 503, "result": "Invalid recipients", "body": {"answer": {}, "sender": {"ip_src": ip_src, "ip_real": ip_real, "ip_vip": ip_vip}}}
+      end
+
+      output_params = {"code": 200, "result": "Data processed", "body": {"answer": {"bulkId": "00000000-0000-0000-0000-000000000000", "messages": mes_data_answ}, "sender": {"ip_src": ip_src, "ip_real": ip_real, "ip_vip": ip_vip}}}
+
+    rescue
+      output_params = {"code": 500, "result": "MhubFunctions_2.get_send_message_2: Unknown SDK error", "body": {"answer": {}, "sender": {"ip_src": ip_src, "ip_real": ip_real, "ip_vip": ip_vip}}}
+      telegram_connector.telegram_message(output_params)
+    end
+
+    internal_func.printer_texter({:input => input_params, :output => output_params, :hub_resp => {}, :procedure => "Mhub_2.get_send_message"}, log_level)
     output_params
 
   end
 
 
   #for bank dabrabyt
-  def rec_deliv_report_2(params, ip_src, ip_real, ip_vip)
+  def rec_deliv_report_2(params, ip_src, ip_real, ip_vip, crm_slice_num=2)
     input_params = {:params => params, :ip_src => ip_src, :ip_real => ip_real, :ip_vip => ip_vip}
     output_params = {}
     hub_resp = {}
 
     begin
       mes_report = dabrab_connecter.delivery_report_transform(params)[:body][:report_to_recip]
-      result = crm_connector.crm_status_2(mes_report)
+      result = crm_connector.crm_status_2(mes_report, crm_slice_num)
       if result[:body][:res_body]["GetReportsResult"]==""
         output_params = {"code": 200, "result": "Data processed", "body": {"answer": {"code": 200, "status": "Success"}, "sender": {"ip_src": ip_src, "ip_real": ip_real, "ip_vip": ip_vip}}}
       else
@@ -142,15 +200,10 @@ class MhubFunctions_2
       output_params = {"code": 500, "result": "MhubFunctions_2.rec_deliv_report_2: Unknown SDK error", "body": {"answer": {}, "sender": {"ip_src": ip_src, "ip_real": ip_real, "ip_vip": ip_vip}}}
       telegram_connector.telegram_message(output_params)
     end
-    internal_func.printer_texter({:input => input_params, :output => output_params, :hub_resp => hub_resp, :procedure => "Mhub_2.recieve_delivery_report"}, "debug")
+    internal_func.printer_texter({:input => input_params, :output => output_params, :hub_resp => hub_resp, :procedure => "Mhub_2.recieve_delivery_report"}, log_level)
     output_params
   end
 
-  def test2
-    hh = Infobip_1.new
-    hh.test
-  end
-
 
 end
 

data/lib/imperituroard/projects/mhub/sk.rb

@@ -1,21 +1,30 @@
 require 'imperituroard/projects/iot/internal_functions'
 require 'imperituroard/projects/mhub/subs/dabrab/dabrab_proced'
+require 'date'
 
 class Sksk_2
 
-  attr_accessor :sk_url, :sk_url_broadcast, :sk_login, :sk_password, :internal_func, :telegram_connector, :dabrab_add_func
+  attr_accessor :sk_url, :sk_url_broadcast, :sk_login, :sk_password, :internal_func, :telegram_connector, :dabrab_add_func, :log_level
 
-  def initialize(sk_url, sk_login, sk_password, sk_url_broadcast, telegram_api_url, telegram_chat_id)
+  def initialize(sk_url, sk_login, sk_password, sk_url_broadcast, telegram_api_url, telegram_chat_id, log_level)
     @sk_url = sk_url
     @sk_login = sk_login
     @sk_password = sk_password
+    @log_level = log_level
     @internal_func = InternalFunc.new
     @sk_url_broadcast = sk_url_broadcast
     @telegram_connector = Telegram_2.new(telegram_api_url, telegram_chat_id)
-    @dabrab_add_func = Dabrab.new
+    @dabrab_add_func = Dabrab.new(log_level)
   end
 
 
+  def get_start_date(addit_min)
+    date_b = Time.now
+    (date_b + addit_min * 60).strftime("%Y-%m-%d %H:%M:%S")
+  end
+
+
+
   def sk_send_sms_one(msisdn, callback_url, text, alphaname)
 
     input_params = {:msisdn => msisdn, :callback_url => callback_url, :text => text, :alphaname => alphaname}
@@ -72,7 +81,7 @@ class Sksk_2
       output_params = {:code => 500, :result => "Sksk_2.sk_send_sms_one: Something wrong", :body => {:request_message => request_message}}
       telegram_connector.telegram_message(output_params)
     end
-    internal_func.printer_texter({:input => input_params, :output => output_params, :procedure => "Sksk_1.sk_send_sms_one"}, "debug")
+    internal_func.printer_texter({:input => input_params, :output => output_params, :procedure => "Sksk_1.sk_send_sms_one"}, log_level)
     output_params
   end
 
@@ -131,12 +140,11 @@ class Sksk_2
 
       thr_sk_send_viber_one.join
 
-
     rescue
       output_params = {:code => 500, :result => "Sksk_2.sk_send_viber_one: Something wrong"}
       telegram_connector.telegram_message(output_params)
     end
-    internal_func.printer_texter({:input => input_params, :output => output_params, :procedure => "Sksk_2.sk_send_viber_one"}, "debug")
+    internal_func.printer_texter({:input => input_params, :output => output_params, :procedure => "Sksk_2.sk_send_viber_one"}, log_level)
     output_params
   end
 
@@ -198,7 +206,6 @@ class Sksk_2
         else
           output_params = {:code => 508, :result => "Sksk_2.sk_send_viber_sms_one: Something wrong with dabrabyt_text_field_parse"}
         end
-
       end
 
       thr_sk_send_viber_sms_one.join
@@ -207,13 +214,13 @@ class Sksk_2
       output_params = {:code => 500, :result => "Sksk_2.sk_send_viber_sms_one: Something wrong"}
       telegram_connector.telegram_message(output_params)
     end
-    internal_func.printer_texter({:input => input_params, :output => output_params, :procedure => "Sksk_2.sk_send_viber_sms_one"}, "debug")
+    internal_func.printer_texter({:input => input_params, :output => output_params, :procedure => "Sksk_2.sk_send_viber_sms_one"}, log_level)
     output_params
 
   end
 
 
-  def sk_send_sms_list(msisdn_list, callback_url, text, alphaname)
+  def sk_send_sms_list(msisdn_list, callback_url, text, alphaname, time_pause_minutes=1)
 
     input_params = {:msisdn_list => msisdn_list, :callback_url => callback_url, :text => text, :alphaname => alphaname}
     output_params = {}
@@ -240,6 +247,7 @@ class Sksk_2
         request_message = {
             "recipients": msisdn_list,
             "callback_url": callback_url,
+            "start_time": get_start_date(time_pause_minutes),
             "tag": "Dabrab_custom_api_1",
             "channels": [
                 "sms"
@@ -269,12 +277,12 @@ class Sksk_2
       output_params = {:code => 500, :result => "Sksk_2.sk_send_sms_list: Something wrong"}
       telegram_connector.telegram_message(output_params)
     end
-    internal_func.printer_texter({:input => input_params, :output => output_params, :procedure => "Sksk_2.sk_send_sms_list"}, "debug")
+    internal_func.printer_texter({:input => input_params, :output => output_params, :procedure => "Sksk_2.sk_send_sms_list"}, log_level)
     output_params
   end
 
 
-  def sk_send_viber_list(msisdn_list, callback_url, text)
+  def sk_send_viber_list(msisdn_list, callback_url, text, time_pause_minutes)
 
     input_params = {:msisdn_list => msisdn_list, :callback_url => callback_url, :text => text}
     output_params = {}
@@ -305,6 +313,7 @@ class Sksk_2
           request_message = {
               "recipients": msisdn_list,
               "callback_url": callback_url,
+              "start_time": get_start_date(time_pause_minutes),
               "tag": "Dabrab_custom_api_1",
               "channels": [
                   "viber"
@@ -332,12 +341,12 @@ class Sksk_2
       output_params = {:code => 500, :result => "Sksk_2.sk_send_viber_list: Something wrong"}
       telegram_connector.telegram_message(output_params)
     end
-    internal_func.printer_texter({:input => input_params, :output => output_params, :procedure => "Sksk_2.sk_send_viber_list"}, "debug")
+    internal_func.printer_texter({:input => input_params, :output => output_params, :procedure => "Sksk_2.sk_send_viber_list"}, log_level)
     output_params
   end
 
 
-  def sk_send_viber_sms_list(msisdn_list, callback_url, sms_text, viber_text, alphaname)
+  def sk_send_viber_sms_list(msisdn_list, callback_url, sms_text, viber_text, alphaname, time_pause_minutes)
     input_params = {:msisdn_list => msisdn_list, :callback_url => callback_url, :sms_text => sms_text, :viber_text => viber_text, :alphaname => alphaname}
     output_params = {}
     request_message = {}
@@ -345,10 +354,13 @@ class Sksk_2
     begin
       thr_sk_send_viber_sms_list = Thread.new do
 
+
         viber_mess_ans = dabrab_add_func.dabrabyt_text_field_parse(viber_text)
 
         if viber_mess_ans[:code] == 200
 
+
+
           uri = URI(sk_url_broadcast)
           #8 - client id
 
@@ -359,7 +371,6 @@ class Sksk_2
 
           req.basic_auth sk_login, sk_password
 
-
           req["Content-Type"] = "application/json"
           req["Accept"] = "application/json"
 
@@ -367,6 +378,7 @@ class Sksk_2
           request_message = {
               "recipients": msisdn_list,
               "callback_url": callback_url,
+              "start_time": get_start_date(time_pause_minutes),
               "tag": "Dabrab_custom_api_1",
               "channels": [
                   "viber",
@@ -390,20 +402,16 @@ class Sksk_2
                            :body => {:request_message => request_message,
                                      :res_code => res.code,
                                      :res_body => JSON.parse(res.body.to_s)}}
-
         else
           output_params = {:code => 508, :result => "Sksk_2.sk_send_viber_sms_list: Something wrong with dabrabyt_text_field_parse"}
         end
-
       end
-
       thr_sk_send_viber_sms_list.join
-
     rescue
       output_params = {:code => 500, :result => "Sksk_2.sk_send_viber_sms_list: Something wrong"}
       telegram_connector.telegram_message(output_params)
     end
-    internal_func.printer_texter({:input => input_params, :output => output_params, :procedure => "Sksk_2.sk_send_viber_sms_list"}, "debug")
+    internal_func.printer_texter({:input => input_params, :output => output_params, :procedure => "Sksk_2.sk_send_viber_sms_list"}, log_level)
     output_params
   end
 

data/lib/imperituroard/projects/mhub/subs/dabrab/dabrab_platform.rb

@@ -3,17 +3,18 @@ require 'imperituroard/projects/iot/internal_functions'
 
 class Crm_2
 
-  attr_accessor :crm_callback_url, :crm_login, :crm_password, :internal_func, :telegram_connector
+  attr_accessor :crm_callback_url, :crm_login, :crm_password, :internal_func, :telegram_connector, :log_level
 
-  def initialize(crm_callback_url, crm_login, crm_password, telegram_api_url, telegram_chat_id)
+  def initialize(crm_callback_url, crm_login, crm_password, telegram_api_url, telegram_chat_id, log_level)
     @crm_callback_url = crm_callback_url
     @crm_login = crm_login
+    @log_level = log_level
     @crm_password = crm_password
     @internal_func = InternalFunc.new
     @telegram_connector = Telegram_2.new(telegram_api_url, telegram_chat_id)
   end
 
-  def crm_status_2(crm_payload)
+  def crm_status_2(crm_payload, slice_num)
 
     input_params = {:crm_payload => crm_payload}
     output_params = {}
@@ -21,30 +22,51 @@ class Crm_2
 
     begin
 
+      internal_func.printer_texter({:input => "Start process", :procedure => "Crm_2.crm_status_2"}, log_level)
+
+
       thr_crm_status_2 = Thread.new do
-        uri = URI(crm_callback_url)
-        #8 - client id
 
-        https = Net::HTTP.new(uri.host, uri.port)
-        https.use_ssl = true
-        https.verify_mode = OpenSSL::SSL::VERIFY_NONE
-        req = Net::HTTP::Post.new(uri.path, initheader = {:"Content-Type" => 'application/json'})
+        partnnn = crm_payload[:results].each_slice(slice_num).to_a
+
+        partnnn.each { |one_part_reports|
+
+          crm_payload2 = {:results => one_part_reports }
+
+
+          uri = URI(crm_callback_url)
+          #8 - client id
+
+          https = Net::HTTP.new(uri.host, uri.port)
+          https.use_ssl = true
+          https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          req = Net::HTTP::Post.new(uri.path, initheader = {:"Content-Type" => 'application/json'})
+
+          req.basic_auth crm_login, crm_password
+
+          req["Content-Type"] = "application/json"
+          req["Accept"] = "application/json"
+
+          internal_func.printer_texter({:input => {:crm_payload2 => crm_payload2}, :procedure => "Crm_2.crm_status_2"}, log_level)
+
+
+          req.body = crm_payload2.to_json
 
-        req.basic_auth crm_login, crm_password
+          internal_func.printer_texter({:input => "Before send request to crm", :procedure => "Crm_2.crm_status_2"}, log_level)
 
-        req["Content-Type"] = "application/json"
-        req["Accept"] = "application/json"
+          res = https.request(req)
 
-        req.body = crm_payload.to_json
-        res = https.request(req)
+          internal_func.printer_texter({:input => "After send request to crm", :procedure => "Crm_2.crm_status_2"}, log_level)
+          internal_func.printer_texter({:input => {:res_code => res.code, :res_body => JSON.parse(res.body.to_s)}, :procedure => "Crm_2.crm_status_2"}, log_level)
 
+        }
 
         output_params = {:code => 200,
                          :result => "Crm_2.crm_status_2: Request processed",
                          :body => {:request_message => crm_payload,
-                                   :res_code => res.code,
-                                   :res_body => JSON.parse(res.body.to_s)}}
-        p res.body
+                                   :res_code => "200",
+                                   :res_body => ""}}
+        #p res.body
       end
       thr_crm_status_2.join
 
@@ -52,7 +74,7 @@ class Crm_2
       output_params = {:code => 500, :result => "Crm_2.crm_status_2: Something wrong", :body => {:request_message => request_message}}
       telegram_connector.telegram_message(output_params)
     end
-    internal_func.printer_texter({:input => input_params, :output => output_params, :procedure => "Crm_2.crm_status_2"}, "debug")
+    internal_func.printer_texter({:input => input_params, :output => output_params, :procedure => "Crm_2.crm_status_2"}, log_level)
     output_params
 
   end

data/lib/imperituroard/projects/mhub/subs/dabrab/dabrab_proced.rb

@@ -1,5 +1,14 @@
+require 'imperituroard/projects/iot/internal_functions'
+
 class Dabrab
 
+  attr_accessor :internal_func, :log_level
+
+  def initialize(log_level)
+    @internal_func = InternalFunc.new
+    @log_level = log_level
+  end
+
   def dabrabyt_text_field_parse(stri)
     button_url = ""
     image = ""
@@ -30,9 +39,9 @@ class Dabrab
       image_dat = stri.scan(regexp_image1)
 
 
-      p button_url_dat
-      p button_text_dat
-      p image_dat
+      #p button_url_dat
+      #p button_text_dat
+      #p image_dat
 
       begin
         if button_url_dat != [] && button_url_dat != nil && button_url_dat != ""
@@ -90,19 +99,20 @@ class Dabrab
         scheme = 0
       end
 
-      if scheme==0
-        sk_format = {"text": text, "ttl": 60}
-      elsif scheme==1
-        sk_format = {"text": text, "ttl": 60, "caption": button_text, "action": button_url}
-      elsif scheme==2
-        sk_format = {"text": text, "ttl": 60, "caption": button_text, "action": button_url, "img": image}
-      elsif scheme==3
-        sk_format = {"img": image, "ttl": 60}
-      else
-        nil
+      case scheme
+        when 0
+          sk_format = {"text": text, "ttl": 60}
+        when 1
+          sk_format = {"text": text, "ttl": 60, "caption": button_text, "action": button_url}
+        when 2
+          sk_format = {"text": text, "ttl": 60, "caption": button_text, "action": button_url, "img": image}
+        when 3
+          sk_format = {"img": image, "ttl": 60}
+        else
+          nil
       end
 
-      p sk_format
+      #p sk_format
 
       output_answer ={:code => 200, :result => "Success", :body => {:to_sk_format => sk_format, :button_url => button_url, :image => image, :button_text => button_text, :text => text, :scheme => scheme, :scheme_dic => scheme_dic[scheme]}}
     rescue
@@ -125,11 +135,12 @@ class Dabrab
                                          #"extra_id": extra_id
                                      })
       rescue
-        p "failed: #{g.to_s}"
+        nil
+        #p "failed: #{g.to_s}"
       end
 
     end
-    p converted_msisdn_list
+    #p converted_msisdn_list
     converted_msisdn_list
 
   end
@@ -155,8 +166,8 @@ class Dabrab
         ]
     }
 
-    p "send_responce_formatter(hub_answer)"
-    p hub_answer
+    #p "send_responce_formatter(hub_answer)"
+    #p hub_answer
 
     for a in hub_answer[:body][:res_body]["messages"]
       status1 = {}
@@ -181,17 +192,22 @@ class Dabrab
       messages_sect.append(status1)
     end
 
-    p messages_sect
+    #p messages_sect
 
     mess_to_recip = {"bulkId": "00000000-0000-0000-0000-000000000000", "messages": messages_sect}
     {:code => 200, :result => "Data processed", :body => {:mess_to_recip => mess_to_recip}}
   end
 
 
-  def delivery_report_transform(hub_report)
+  def delivery_report_transform(hub_report_in)
+
+    internal_func.printer_texter({:input => "Start delivery_report_transform", :procedure => "Dabrab.delivery_report_transform"}, log_level)
+
 #{"number"=>"375297116638", "time"=>1588673492000, "status"=>2, "substatus"=>23, "msg_status"=>23033, "message_id"=>"486649ba-a573-4ee9-8f58-018ed20ca6fd", "extra_id"=>"444/0/ServiceModel/ScGetReports.svc/GetReports", "sent_via"=>"viber", "controller"=>"reports", "action"=>"delivery", "report"=>{"number"=>"375297116638", "time"=>1588673492000, "status"=>2, "substatus"=>23, "msg_status"=>23033, "message_id"=>"486649ba-a573-4ee9-8f58-018ed20ca6fd", "extra_id"=>"444/0/ServiceModel/ScGetReports.svc/GetReports", "sent_via"=>"viber"}}
-    p hub_report
-    p "hub_report"
+#p hub_report
+#p "hub_report"
+    report_to_recip = []
+
     data_for_status = {
         23011 => {:status_id => 5, :status_grid => 3, :status_grname => "DELIVERED", :status_name => "DELIVERED_TO_HANDSET", :status_descr => "Message delivered by SMS",
                   :error_id => 0, :error_grid => 0, :error_grname => "Ok", :error_name => "NO_ERROR", :error_descr => "No Error", :error_permanent => false
@@ -216,66 +232,132 @@ class Dabrab
         } #Viber subscriber not exists
     }
 
-    if data_for_status[hub_report[:msg_status]] != nil && data_for_status[hub_report[:msg_status]] != {} && data_for_status[hub_report[:msg_status]] != [] && data_for_status[hub_report[:msg_status]] != ""
-      report_to_recip = {
-          "results": [
-              {
-
-                  "bulkId": "00000000-0000-0000-0000-000000000000",
-                  "messageId": hub_report[:report][:message_id],
-                  "to": hub_report[:report][:number],
-                  #    "sentAt": "2020-05-05T20:00:00.000+0000",
-                  #    "doneAt": "2020-05-05T20:00:00.000+0000",
-                  "status": {
-                      "groupId": data_for_status[hub_report[:msg_status]][:status_grid],
-                      "groupName": data_for_status[hub_report[:msg_status]][:status_grname],
-                      "id": data_for_status[hub_report[:msg_status]][:status_id],
-                      "name": data_for_status[hub_report[:msg_status]][:status_name],
-                      "description": data_for_status[hub_report[:msg_status]][:status_descr]
-                  },
-                  "error": {
-                      "groupId": data_for_status[hub_report[:msg_status]][:error_grid],
-                      "groupName": data_for_status[hub_report[:msg_status]][:error_grname],
-                      "id": data_for_status[hub_report[:msg_status]][:error_id],
-                      "name": data_for_status[hub_report[:msg_status]][:error_name],
-                      "description": data_for_status[hub_report[:msg_status]][:error_descr],
-                      "permanent": data_for_status[hub_report[:msg_status]][:error_permanent]
-                  }
-              }
-          ]
-      }
+    if hub_report_in.key?("msg_status") && !hub_report_in.key?("_json") && !hub_report_in["report"].key?("_json")
+      internal_func.printer_texter({:input => "One message delivery_report_transform", :procedure => "Dabrab.delivery_report_transform"}, log_level)
+
+      hub_report = hub_report_in
+
+      if data_for_status[hub_report["msg_status"]] != nil && data_for_status[hub_report["msg_status"]] != {} && data_for_status[hub_report["msg_status"]] != [] && data_for_status[hub_report["msg_status"]] != ""
+
+        report_to_recip.push({
+
+                                 "bulkId": "00000000-0000-0000-0000-000000000000",
+                                 "messageId": hub_report["report"]["message_id"],
+                                 "to": hub_report["report"]["number"],
+                                 #    "sentAt": "2020-05-05T20:00:00.000+0000",
+                                 #    "doneAt": "2020-05-05T20:00:00.000+0000",
+                                 "status": {
+                                     "groupId": data_for_status[hub_report["msg_status"]][:status_grid],
+                                     "groupName": data_for_status[hub_report["msg_status"]][:status_grname],
+                                     "id": data_for_status[hub_report["msg_status"]][:status_id],
+                                     "name": data_for_status[hub_report["msg_status"]][:status_name],
+                                     "description": data_for_status[hub_report["msg_status"]][:status_descr]
+                                 },
+                                 "error": {
+                                     "groupId": data_for_status[hub_report["msg_status"]][:error_grid],
+                                     "groupName": data_for_status[hub_report["msg_status"]][:error_grname],
+                                     "id": data_for_status[hub_report["msg_status"]][:error_id],
+                                     "name": data_for_status[hub_report["msg_status"]][:error_name],
+                                     "description": data_for_status[hub_report["msg_status"]][:error_descr],
+                                     "permanent": data_for_status[hub_report["msg_status"]][:error_permanent]
+                                 }
+                             })
+
+
+      else
+
+        report_to_recip.push({
+
+                                 "bulkId": "00000000-0000-0000-0000-000000000000",
+                                 "messageId": hub_report["report"]["message_id"],
+                                 "to": hub_report["report"]["number"],
+                                 #    "sentAt": "2020-05-05T20:00:00.000+0000",
+                                 #    "doneAt": "2020-05-05T20:00:00.000+0000",
+                                 "status": {
+                                     "groupId": 2,
+                                     "groupName": "UNDELIVERABLE_NOT_DELIVERED",
+                                     "id": 9,
+                                     "name": "UNDELIVERED",
+                                     "description": "Unknown error"
+                                 },
+                                 "error": {
+                                     "groupId": 1,
+                                     "groupName": "HANDSET_ERRORS",
+                                     "id": 32,
+                                     "name": "EC_SM_DELIVERY_FAILURE",
+                                     "description": "Unknown error",
+                                     "permanent": false
+                                 }
+                             })
+
+      end
 
     else
 
-      report_to_recip = {
-          "results": [
-              {
-
-                  "bulkId": "00000000-0000-0000-0000-000000000000",
-                  "messageId": hub_report[:report][:message_id],
-                  "to": hub_report[:report][:number],
-                  #    "sentAt": "2020-05-05T20:00:00.000+0000",
-                  #    "doneAt": "2020-05-05T20:00:00.000+0000",
-                  "status": {
-                      "groupId": 2,
-                      "groupName": "UNDELIVERABLE_NOT_DELIVERED",
-                      "id": 9,
-                      "name": "UNDELIVERED",
-                      "description": "Unknown error"
-                  },
-                  "error": {
-                      "groupId": 1,
-                      "groupName": "HANDSET_ERRORS",
-                      "id": 32,
-                      "name": "EC_SM_DELIVERY_FAILURE",
-                      "description": "Unknown error",
-                      "permanent": false
-                  }
-              }
-          ]
+      hub_report_in["_json"].each {|hub_report2|
+
+        internal_func.printer_texter({:input => "Start Mass message delivery_report_transform", :procedure => "Dabrab.delivery_report_transform"}, log_level)
+
+        internal_func.printer_texter({:input => {:hub_report2 => hub_report2}, :procedure => "Dabrab.delivery_report_transform"}, log_level)
+
+
+        if data_for_status[hub_report2["msg_status"]] != nil && data_for_status[hub_report2["msg_status"]] != {} && data_for_status[hub_report2["msg_status"]] != [] && data_for_status[hub_report2["msg_status"]] != ""
+          report_to_recip.push({
+
+                                   "bulkId": "00000000-0000-0000-0000-000000000000",
+                                   "messageId": hub_report2["message_id"],
+                                   "to": hub_report2["number"],
+                                   #    "sentAt": "2020-05-05T20:00:00.000+0000",
+                                   #    "doneAt": "2020-05-05T20:00:00.000+0000",
+                                   "status": {
+                                       "groupId": data_for_status[hub_report2["msg_status"]][:status_grid],
+                                       "groupName": data_for_status[hub_report2["msg_status"]][:status_grname],
+                                       "id": data_for_status[hub_report2["msg_status"]][:status_id],
+                                       "name": data_for_status[hub_report2["msg_status"]][:status_name],
+                                       "description": data_for_status[hub_report2["msg_status"]][:status_descr]
+                                   },
+                                   "error": {
+                                       "groupId": data_for_status[hub_report2["msg_status"]][:error_grid],
+                                       "groupName": data_for_status[hub_report2["msg_status"]][:error_grname],
+                                       "id": data_for_status[hub_report2["msg_status"]][:error_id],
+                                       "name": data_for_status[hub_report2["msg_status"]][:error_name],
+                                       "description": data_for_status[hub_report2["msg_status"]][:error_descr],
+                                       "permanent": data_for_status[hub_report2["msg_status"]][:error_permanent]
+                                   }
+                               })
+
+
+        else
+
+          report_to_recip.push({
+
+                                   "bulkId": "00000000-0000-0000-0000-000000000000",
+                                   "messageId": hub_report2["message_id"],
+                                   "to": hub_report2["number"],
+                                   #    "sentAt": "2020-05-05T20:00:00.000+0000",
+                                   #    "doneAt": "2020-05-05T20:00:00.000+0000",
+                                   "status": {
+                                       "groupId": 2,
+                                       "groupName": "UNDELIVERABLE_NOT_DELIVERED",
+                                       "id": 9,
+                                       "name": "UNDELIVERED",
+                                       "description": "Unknown error"
+                                   },
+                                   "error": {
+                                       "groupId": 1,
+                                       "groupName": "HANDSET_ERRORS",
+                                       "id": 32,
+                                       "name": "EC_SM_DELIVERY_FAILURE",
+                                       "description": "Unknown error",
+                                       "permanent": false
+                                   }
+                               })
+        end
+
       }
     end
-    {:code => 200, :result => "Data processed", :body => {:report_to_recip => report_to_recip}}
+
+    {:code => 200, :result => "Data processed", :body => {:report_to_recip => {"results": report_to_recip}}}
   end
 
 end

data/lib/imperituroard/projects/wttx/updatepostcps.rb

@@ -45,25 +45,25 @@ class StateWTTX
     http = Net::HTTP.new(uri.host, uri.port)
     response = http.request(Net::HTTP::Get.new(uri.request_uri))
     p content = response.body
-    p resultcode = response.to_s.include?("OK")
+    p result_code = response.to_s.include?("OK")
     #Rails.logger = Logger.new(STDOUT)
     #logger.info "WTTX service getrestCPS result code: #{response.to_s}"
     #logger.info "WTTX service getrestCPS soap body: #{content.to_s}"
 
 
 
-    if resultcode == false
+    if !result_code
       "false"
     else
-      regimsi = /<field code=\"imsi\" value=\"([0-9]{10,15})\"/
-      regimei = /<field code=\"imei\" value=\"([0-9]{10,17})\"/
+      reg_imsi = /<field code=\"imsi\" value=\"([0-9]{10,15})\"/
+      reg_imei = /<field code=\"imei\" value=\"([0-9]{10,17})\"/
 
-      m1 = regimsi.match(content)
-      m2 = regimei.match(content)
+      m1 = reg_imsi.match(content)
+      m2 = reg_imei.match(content)
       imsi = m1[1]
       imei = m2[1]
 
-      res = resultcode.to_s + " " + imsi + " " + imei
+      res = result_code.to_s + " " + imsi + " " + imei
       p res
       res
     end

data/lib/imperituroard/version.rb

@@ -1,4 +1,4 @@
 module Imperituroard
-  VERSION = "1.1.9"
+  VERSION = "1.1.14"
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: imperituroard
 version: !ruby/object:Gem::Version
-  version: 1.1.9
+  version: 1.1.14
 platform: ruby
 authors:
 - Dzmitry Buynovskiy
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-09-01 00:00:00.000000000 Z
+date: 2020-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -187,7 +187,9 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".idea/runConfigurations/autovpn.xml"
+- ".idea/runConfigurations/dabrab_proced.xml"
 - ".idea/runConfigurations/hua_oceanconnect_adapter.xml"
+- ".idea/runConfigurations/test9_dab.xml"
 - ".idea/runConfigurations/version.xml"
 - ".ruby-gemset"
 - ".ruby-version"
@@ -207,6 +209,9 @@ files:
 - lib/imperituroard/platforms/cps/cps_multiple_thread_req.rb
 - lib/imperituroard/platforms/cps/qps_connector.rb
 - lib/imperituroard/platforms/cps/request_formatter.rb
+- lib/imperituroard/platforms/iwag/get_iwag_data.rb
+- lib/imperituroard/platforms/iwag/iwag_database_worker.rb
+- lib/imperituroard/platforms/iwag/iwag_telnet_connector.rb
 - lib/imperituroard/platforms/public/telegram.rb
 - lib/imperituroard/platforms/staros/get_data_ssh.rb
 - lib/imperituroard/platforms/staros/staros_automation.rb