imperituroard 0.3.8 → 0.3.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 105b8bfcf0691a85c3e70bd793cceb9cfde52aa4
-  data.tar.gz: 6bed91d82f8ae0174587ddc05837284411b218d1
+  metadata.gz: 541de7d03bfd56a1dcb6d5bcdc4b5be30984ab52
+  data.tar.gz: cea1b867c6a8c5692bbcaceaed72c00be1b5a448
 SHA512:
-  metadata.gz: dccc03ba30a1ca692af12363c70ee3f405a73d87e3a767784b750661ca2b926efd9dba540876b76dae5f90e6091252b643e3bc6acd35d9f77fda88c6e22c27cd
-  data.tar.gz: 9d4917de0ab216a8a6e76379879793833c526768bd11a13f70efcfd1c512d44617305dc864821fb447b430485a72124a6cfee58f5739ac038a47597e45568207
+  metadata.gz: 5da3dac0cd2ea28ac338b7d9d6931988f00f58d871a39cfba3c81544928da902984723241d4d4b1cb9ec881775f0120145386cf8ad7f4d83428494d2d3da9bdc
+  data.tar.gz: 3f50dd6c0252afd409be4081c225fbacf5d8ee37c8a5528bfb8f30f143ed40753fa349b9f78f0e17c8b82223d4ec59a1296de2091ad792ad04139dfb9233c1b4

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

@@ -1,152 +1,343 @@
-
-
-
+require 'imperituroard/projects/iot/internal_functions'
 
 class Sksk_1
 
-  attr_accessor :sk_url, :sk_login, :sk_password
+  attr_accessor :sk_url, :sk_url_broadcast, :sk_login, :sk_password, :internal_func
 
-  def initialize(sk_url, sk_login, sk_password)
+  def initialize(sk_url, sk_login, sk_password, sk_url_broadcast)
     @sk_url = sk_url
     @sk_login = sk_login
     @sk_password = sk_password
     @internal_func = InternalFunc.new
+    @sk_url_broadcast = sk_url_broadcast
   end
 
 
+  def sk_send_sms_one(msisdn, callback_url, text, alphaname)
+
+    input_params = {:msisdn => msisdn, :callback_url => callback_url, :text => text, :alphaname => alphaname}
+    output_params = {}
+    request_message = {}
+
+    begin
+      uri = URI(sk_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 sk_login, sk_password
+
+      request_message = {
+          "phone_number": msisdn,
+          "extra_id": "4232j4h89932kjhs",
+          "callback_url": callback_url,
+          #"start_time": "2019-08-16 09:59:10",
+          "tag": "Dabrab_custom_api_1",
+          "channels": [
+              "sms"
+          ],
+          "channel_options": {
+              "sms": {
+                  "text": text,
+                  "alpha_name": alphaname,
+                  "ttl": 600
+              }
+          }
+      }
+
+      req.body = request_message.to_json
+      res = https.request(req)
+      output_params = {:code => 200,
+                       :result => "Sksk_1.sk_send_sms_one: Request processed",
+                       :body => {:request_message => request_message,
+                                 :res_code => res.code,
+                                 :res_body => JSON.parse(res.body.to_s)}}
+      p res.body
+
+    rescue
+      output_params = {:code => 500, :result => "Sksk_1.sk_send_sms_one: Something wrong", :body => {:request_message => request_message}}
+    end
+    internal_func.printer_texter({:input => input_params, :output => output_params, :procedure => "Sksk_1.sk_send_sms_one"}, "debug")
+    output_params
+  end
 
-  def sk_send_sms(msisdn, callback_url, text, alphaname)
-
-    uri = URI(sk_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 sk_login, sk_password
-
-
-    request_message = {
-        "phone_number": msisdn,
-        "extra_id": "4232j4h89932kjhs",
-        "callback_url": callback_url,
-        #"start_time": "2019-08-16 09:59:10",
-        "tag": "Dabrab_custom_api_1",
-        "channels": [
-            "sms"
-        ],
-        "channel_options": {
-            "sms": {
-                "text": text,
-                "alpha_name": alphaname,
-                "ttl": 600
-            }
-        }
-    }
 
-    p request_message
+  def sk_send_viber_one(msisdn, callback_url, text)
+
+    input_params = {:msisdn => msisdn, :callback_url => callback_url, :text => text}
+    output_params = {}
+    request_message = {}
+
+    begin
+
+      uri = URI(sk_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 sk_login, sk_password
+
+      request_message = {
+          "phone_number": msisdn,
+          "extra_id": "4232j4h89932kjhs",
+          "callback_url": callback_url,
+          #"start_time": "2019-08-16 09:59:10",
+          "tag": "Dabrab_custom_api_1",
+          "channels": [
+              "viber"
+          ],
+          "channel_options": {
+              "viber": {
+                  "text": text,
+                  "ttl": 60,
+                  # "img": "http://olddogs.org/logo.png",
+                  # "caption": "Old Dogs need you!",
+                  # "action": "http://olddogs.org",
+              },
+          }
+      }
+      req.body = request_message.to_json
+      res = https.request(req)
+      output_params = {:code => 200,
+                       :result => "Sksk_1.sk_send_viber_one: Request processed",
+                       :body => {:request_message => request_message,
+                                 :res_code => res.code,
+                                 :res_body => JSON.parse(res.body.to_s)}}
+
+    rescue
+      output_params = {:code => 500, :result => "Sksk_1.sk_send_viber_one: Something wrong"}
+    end
+    internal_func.printer_texter({:input => input_params, :output => output_params, :procedure => "Sksk_1.sk_send_viber_one"}, "debug")
+    output_params
+  end
 
-    req.body = request_message.to_json
-    p req.body
-    p req
+  def sk_send_viber_sms_one(msisdn, callback_url, sms_text, viber_txt, alphaname)
+
+    input_params = {:msisdn => msisdn, :callback_url => callback_url, :sms_text => sms_text, :viber_txt => viber_txt, :alphaname => alphaname}
+    output_params = {}
+    request_message = {}
+
+    begin
+
+      uri = URI(sk_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 sk_login, sk_password
+
+      request_message = {
+          "phone_number": msisdn,
+          "extra_id": "4232j4h89932kjhs",
+          "callback_url": callback_url,
+          #"start_time": "2019-08-16 09:59:10",
+          "tag": "Dabrab_custom_api_1",
+          "channels": [
+              "viber",
+              "sms"
+          ],
+          "channel_options": {
+              "sms": {
+                  "text": sms_text,
+                  "alpha_name": alphaname,
+                  "ttl": 600
+              },
+              "viber": {
+                  "text": viber_txt,
+                  "ttl": 60,
+                  # "img": "http://olddogs.org/logo.png",
+                  # "caption": "Old Dogs need you!",
+                  # "action": "http://olddogs.org",
+              },
+          }
+      }
+
+      req.body = request_message.to_json
+      res = https.request(req)
+
+      output_params = {:code => 200,
+                       :result => "Sksk_1.sk_send_viber_sms_one: Request processed",
+                       :body => {:request_message => request_message,
+                                 :res_code => res.code,
+                                 :res_body => JSON.parse(res.body.to_s)}}
+
+    rescue
+      output_params = {:code => 500, :result => "Sksk_1.sk_send_viber_sms_one: Something wrong"}
+    end
+    internal_func.printer_texter({:input => input_params, :output => output_params, :procedure => "Sksk_1.sk_send_viber_sms_one"}, "debug")
+    output_params
 
-    res = https.request(req)
+  end
 
-    p res.body
-    p res.code
 
+  def sk_send_sms_list(msisdn_list, callback_url, text, alphaname)
+
+    input_params = {:msisdn_list => msisdn_list, :callback_url => callback_url, :text => text, :alphaname => alphaname}
+    output_params = {}
+    request_message = {}
+
+    begin
+      uri = URI(sk_url_broadcast)
+      #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 sk_login, sk_password
+
+      # [{"phone_number": 375298766719}, {"phone_number": 375295730878}]
+      request_message = {
+          "recipients": msisdn_list,
+          "callback_url": callback_url,
+          "tag": "Dabrab_custom_api_1",
+          "channels": [
+              "sms"
+          ],
+          "channel_options": {
+              "sms": {
+                  "alpha_name": alphaname,
+                  "text": text,
+                  "ttl": 60
+              }
+          }
+      }
+
+      p request_message
+
+      req.body = request_message.to_json
+      res = https.request(req)
+
+      output_params = {:code => 200,
+                       :result => "Sksk_1.sk_send_sms_list: Request processed",
+                       :body => {:request_message => request_message,
+                                 :res_code => res.code,
+                                 :res_body => JSON.parse(res.body.to_s)}}
+    rescue
+      output_params = {:code => 500, :result => "Sksk_1.sk_send_sms_list: Something wrong"}
+    end
+    internal_func.printer_texter({:input => input_params, :output => output_params, :procedure => "Sksk_1.sk_send_sms_list"}, "debug")
+    output_params
   end
 
 
-
-  def sk_send_viber(msisdn, callback_url, text)
-
-    uri = URI(sk_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 sk_login, sk_password
-
-    request_message = {
-        "phone_number": msisdn,
-        "extra_id": "4232j4h89932kjhs",
-        "callback_url": callback_url,
-        #"start_time": "2019-08-16 09:59:10",
-        "tag": "Dabrab_custom_api_1",
-        "channels": [
-            "viber"
-        ],
-        "channel_options": {
-            "viber": {
-                "text": text,
-                "ttl": 60,
-               # "img": "http://olddogs.org/logo.png",
-               # "caption": "Old Dogs need you!",
-               # "action": "http://olddogs.org",
-            },
-        }
-    }
-    p request_message
-    req.body = request_message.to_json
-    p req.body
-    p req
-    res = https.request(req)
-    p res.body
-    p res.code
+  def sk_send_viber_list(msisdn_list, callback_url, text)
+
+    input_params = {:msisdn_list => msisdn_list, :callback_url => callback_url, :text => text}
+    output_params = {}
+    request_message = {}
+
+    begin
+      uri = URI(sk_url_broadcast)
+      #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 sk_login, sk_password
+
+      # [{"phone_number": 375298766719}, {"phone_number": 375295730878}]
+      request_message = {
+          "recipients": msisdn_list,
+          "callback_url": callback_url,
+          "tag": "Dabrab_custom_api_1",
+          "channels": [
+              "viber"
+          ],
+          "channel_options": {
+              "viber": {
+                  "text": text,
+                  "ttl": 60
+              }
+          }
+      }
+
+      p request_message
+
+      req.body = request_message.to_json
+      res = https.request(req)
+
+      output_params = {:code => 200,
+                       :result => "Sksk_1.sk_send_viber_list: Request processed",
+                       :body => {:request_message => request_message,
+                                 :res_code => res.code,
+                                 :res_body => JSON.parse(res.body.to_s)}}
+    rescue
+      output_params = {:code => 500, :result => "Sksk_1.sk_send_viber_list: Something wrong"}
+    end
+    internal_func.printer_texter({:input => input_params, :output => output_params, :procedure => "Sksk_1.sk_send_viber_list"}, "debug")
+    output_params
   end
 
-  def sk_send_viber_sms(msisdn, callback_url, sms_text, viber_txt, alphaname)
-
-    uri = URI(sk_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 sk_login, sk_password
-
-    request_message = {
-        "phone_number": msisdn,
-        "extra_id": "4232j4h89932kjhs",
-        "callback_url": callback_url,
-        #"start_time": "2019-08-16 09:59:10",
-        "tag": "Dabrab_custom_api_1",
-        "channels": [
-            "viber",
-            "sms"
-        ],
-        "channel_options": {
-            "sms": {
-                "text": sms_text,
-                "alpha_name": alphaname,
-                "ttl": 600
-            },
-            "viber": {
-                "text": viber_txt,
-                "ttl": 60,
-                # "img": "http://olddogs.org/logo.png",
-                # "caption": "Old Dogs need you!",
-                # "action": "http://olddogs.org",
-            },
-        }
-    }
-    p request_message
-    req.body = request_message.to_json
-    p req.body
-    p req
-    res = https.request(req)
-    p res.body
-    p res.code
-  end
 
+  def sk_send_viber_sms_list(msisdn_list, callback_url, text, alphaname)
+
+    input_params = {:msisdn_list => msisdn_list, :callback_url => callback_url, :text => text, :alphaname => alphaname}
+    output_params = {}
+    request_message = {}
+
+    begin
+      uri = URI(sk_url_broadcast)
+      #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 sk_login, sk_password
+
+      # [{"phone_number": 375298766719}, {"phone_number": 375295730878}]
+      request_message = {
+          "recipients": msisdn_list,
+          "callback_url": callback_url,
+          "tag": "Dabrab_custom_api_1",
+          "channels": [
+              "viber",
+              "sms"
+          ],
+          "channel_options": {
+              "sms": {
+                  "alpha_name": alphaname,
+                  "text": text,
+                  "ttl": 60
+              },
+              "viber": {
+                  "text": text,
+                  "ttl": 60
+              }
+          }
+      }
+
+
+      p request_message
+
+      req.body = request_message.to_json
+      res = https.request(req)
+
+      output_params = {:code => 200,
+                       :result => "Sksk_1.sk_send_viber_sms_list: Request processed",
+                       :body => {:request_message => request_message,
+                                 :res_code => res.code,
+                                 :res_body => JSON.parse(res.body.to_s)}}
+    rescue
+      output_params = {:code => 500, :result => "Sksk_1.sk_send_viber_sms_list: Something wrong"}
+    end
+    internal_func.printer_texter({:input => input_params, :output => output_params, :procedure => "Sksk_1.sk_send_viber_sms_list"}, "debug")
+    output_params
+  end
 
 
 end

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

@@ -3,6 +3,67 @@
 
 class Dabrab
 
+def num_formatter(infobip_msisdn, extra_id)
+  #[{"to"=>{"phoneNumber"=>"375297116638", "emailAddress"=>nil}}]
+  # [{"phone_number": 375298766719}, {"phone_number": 375295730878}]
 
+  converted_msisdn_list = []
+
+  for g in infobip_msisdn
+    begin
+    converted_msisdn_list.append({"phone_number": g["to"]["phoneNumber"].to_i, "extra_id": extra_id})
+    rescue
+      p "failed: #{g.to_s}"
+    end
+
+  end
+  p converted_msisdn_list
+
+  converted_msisdn_list
+
+end
+
+
+  def send_responce_formatter(hub_answer)
+    input = {:hub_answer => hub_answer}
+    mess_to_recip = {}
+    messages_sect = []
+    example = {
+        "bulkId": "2034072219640523072",
+        "messages": [{
+                         "to": "41793026727",
+                         "status": {
+                             "groupId": 1,
+                             "groupName": "PENDING",
+                             "id": 26,
+                             "name": "MESSAGE_ACCEPTED",
+                             "description": "Message sent to next instance"
+                         },
+                         "messageId": "2250be2d4219-3af1-78856-aabe-1362af1edfd2"
+                     }
+        ]
+    }
+
+    p "send_responce_formatter(hub_answer)"
+
+    p hub_answer
+
+    for a in hub_answer[:body][:res_body]["messages"]
+      s1 = {"to": a["phone_number"], "status": {"groupId": 1,
+                                                "groupName": "PENDING",
+                                                "id": 26,
+                                                "name": "MESSAGE_ACCEPTED",
+                                                "description": "Message sent to next instance"},
+            "messageId": a["message_id"]}
+      messages_sect.append(s1)
+    end
+
+    p messages_sect
+
+    mess_to_recip = {"messages": messages_sect}
+
+    {:code => 200, :result => "Data processed", :body => {:mess_to_recip => mess_to_recip}}
+
+  end
 
 end

data/lib/imperituroard/version.rb

@@ -1,3 +1,3 @@
 module Imperituroard
-  VERSION = "0.3.8"
+  VERSION = "0.3.9"
 end

data/lib/imperituroard.rb

@@ -1,6 +1,8 @@
 $LOAD_PATH.unshift File.expand_path("../projects/iot", __dir__)
 $LOAD_PATH.unshift File.expand_path("../projects/wttx", __dir__)
 $LOAD_PATH.unshift File.expand_path("../projects/mhub", __dir__)
+$LOAD_PATH.unshift File.expand_path("../projects/mhub/subs/dabrab", __dir__)
+
 
 require "imperituroard/version"
 require "imperituroard/phpipamdb"
@@ -11,6 +13,7 @@ require "imperituroard/projects/iot/add_functions"
 require "imperituroard/projects/iot/internal_functions"
 require 'imperituroard/projects/mhub/infobip'
 require 'imperituroard/projects/mhub/sk'
+require 'imperituroard/projects/mhub/subs/dabrab/dabrab_proced'
 require 'json'
 require 'ipaddr'
 require 'date'
@@ -797,15 +800,16 @@ end
 
 class Mhub_2
 
-  attr_accessor :sk_url, :sk_login, :sk_password, :mhub_connector, :internal_func
+  attr_accessor :sk_url, :sk_login, :sk_password, :mhub_connector, :internal_func, :dabrab_connecter
 
-  def initialize(sk_url, sk_login, sk_password, telegram_api_url, telegram_chat_id)
-    @sk_url = sk_url
+  def initialize(sk_url_simple, sk_login, sk_password, telegram_api_url, telegram_chat_id, sk_url_broadcast)
+    @sk_url = sk_url_simple
     @sk_login = sk_login
     @sk_password = sk_password
     @internal_func = InternalFunc.new
-    @mhub_connector = Sksk_1.new(sk_url, sk_login, sk_password)
+    @mhub_connector = Sksk_1.new(sk_url_simple, sk_login, sk_password, sk_url_broadcast)
     @internal_func = InternalFunc.new
+    @dabrab_connecter = Dabrab.new
     @add_functions_connector = AdditionalFunc.new(telegram_api_url, telegram_chat_id)
   end
 
@@ -820,43 +824,70 @@ class Mhub_2
   # "notifyContentType"=>"application/json"}}
 
 
-  def get_send_message(params)
+  def get_send_message(params, ip_src, ip_real, ip_vip)
 
     input_params = {:params => params}
-
-    p input_params
-
     output_params = {}
+    hub_resp = {}
+    null_statement = [nil, "nil", "", "null"]
 
     begin
 
-      msisdn = params["destinations"][0]["to"]["phoneNumber"]
-
-
-      if params["viber"] == nil && params["sms"] != nil
-
-        mhub_connector.sk_send_sms(msisdn, params["notifyUrl"], params["sms"]["text"], "TEST")
-
-      elsif params["viber"] != nil && params["sms"] == nil
-
-        mhub_connector.sk_send_viber(msisdn, params["notifyUrl"], params["viber"]["text"])
-
-      elsif params["viber"] != nil && params["sms"] != nil
-
-        mhub_connector.sk_send_viber_sms(msisdn, params["notifyUrl"], params["sms"]["text"], params["viber"]["text"], "TEST")
-
+      # if params["destinations"].length == 1
+      #   msisdn = params["destinations"][0]["to"]["phoneNumber"]
+      #   if null_statement.include?(params["viber"]) && !null_statement.include?(params["sms"])
+      #     hub_resp = mhub_connector.sk_send_sms_one(msisdn, params["notifyUrl"], params["sms"]["text"], "TEST")
+      #   elsif !null_statement.include?(params["viber"]) && null_statement.include?(params["sms"])
+      #     hub_resp = mhub_connector.sk_send_viber_one(msisdn, params["notifyUrl"], params["viber"]["text"])
+      #   elsif !null_statement.include?(params["viber"]) && !null_statement.include?(params["sms"])
+      #     hub_resp = mhub_connector.sk_send_viber_sms_one(msisdn, params["notifyUrl"], params["sms"]["text"], params["viber"]["text"], "TEST")
+      #   else
+      #     output_params = {"code": 501, "result": "Invalid input data st1", "answer": {}, "sender": {"ip_src": ip_src, "ip_real": ip_real, "ip_vip": ip_vip}}
+      #   end
+      # elsif params["destinations"].length > 1
+      #
+      #   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, params["notifyUrl"], params["sms"]["text"], "TEST")
+      #   elsif !null_statement.include?(params["viber"]) && null_statement.include?(params["sms"])
+      #     hub_resp = mhub_connector.sk_send_viber_list(msisdn2, params["notifyUrl"], params["viber"]["text"])
+      #   elsif !null_statement.include?(params["viber"]) && !null_statement.include?(params["sms"])
+      #     hub_resp = mhub_connector.sk_send_viber_sms_list(msisdn2, params["notifyUrl"], params["sms"]["text"], params["viber"]["text"], "TEST")
+      #   else
+      #     output_params = {"code": 502, "result": "Invalid input data st2", "answer": {}, "sender": {"ip_src": ip_src, "ip_real": ip_real, "ip_vip": ip_vip}}
+      #   end
+      # else
+      #   output_params = {"code": 503, "result": "Invalid recipients", "answer": {}, "sender": {"ip_src": ip_src, "ip_real": ip_real, "ip_vip": ip_vip}}
+      # end
+
+      if params["destinations"].length >= 1
+
+        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, params["notifyUrl"], params["sms"]["text"], "TEST")
+        elsif !null_statement.include?(params["viber"]) && null_statement.include?(params["sms"])
+          hub_resp = mhub_connector.sk_send_viber_list(msisdn2, params["notifyUrl"], params["viber"]["text"])
+        elsif !null_statement.include?(params["viber"]) && !null_statement.include?(params["sms"])
+          hub_resp = mhub_connector.sk_send_viber_sms_list(msisdn2, params["notifyUrl"], params["sms"]["text"], params["viber"]["text"], "TEST")
+        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
       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": 500, "result": "Invalid input data"}
+      mes_data = dabrab_connecter.send_responce_formatter(hub_resp)
+      p hub_resp
 
-      end
+      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
-      output_params = {"code": 500, "result": "Invalid input data"}
+      output_params = {"code": 500, "result": "Unknown SDK error", "body": {"answer": {}, "sender": {"ip_src": ip_src, "ip_real": ip_real, "ip_vip": ip_vip}}}
     end
 
-    internal_func.printer_texter({:input => input_params, :output => output_params, :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"}, "debug")
     output_params
 
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: imperituroard
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.3.9
 platform: ruby
 authors:
 - Dzmitry Buynovskiy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-04 00:00:00.000000000 Z
+date: 2020-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler