imperituroard 1.1.7 → 1.1.12

data/lib/imperituroard/projects/autovpn.rb

@@ -0,0 +1,27 @@
+require 'imperituroard/projects/autovpn/mongo_vpn'
+
+class Autovpn
+
+  attr_accessor :mongo_client
+
+  def initialize(mongo_vpn_ip, mongo_vpn_port, mongo_vpn_database)
+    @mongo_client = MongoVpn.new(mongo_vpn_ip, mongo_vpn_port, mongo_vpn_database)
+  end
+
+  def vpn_add_msisdn_by_example_2(new_msisdn, example_msisdn)
+
+  end
+
+  def test
+    mongo_client.get_mongo_msisdn("375298766719")
+  end
+
+end
+
+
+vvv = Autovpn.new("172.24.210.177",
+                  "27017",
+                  "autovpn"
+)
+
+vvv.test

data/lib/imperituroard/projects/autovpn/mongo_vpn.rb

@@ -0,0 +1,56 @@
+require 'mongo'
+
+require 'json'
+require 'rubygems'
+require 'nokogiri'
+require 'rails'
+
+require 'imperituroard/add_functions/logger/any_functions'
+
+class MongoVpn
+
+  attr_accessor :mongo_vpn_ip, :mongo_vpn_port, :client_vpn, :mongo_vpn_database, :internal_vpn_func, :logger_any
+
+  def initialize(mongo_vpn_ip, mongo_vpn_port, mongo_vpn_database)
+    @mongo_vpn_database = mongo_vpn_database
+    @mongo_vpn_ip = mongo_vpn_ip
+    @mongo_vpn_port = mongo_vpn_port
+    client_vpn_host = [mongo_vpn_ip + ":" + mongo_vpn_port]
+    @client_vpn = Mongo::Client.new(client_vpn_host, :database => mongo_vpn_database)
+    @logger_any = LogAddFunctions_2.new
+  end
+
+  #get data by msisdn. Validate data from collection msisdn_list
+  def get_mongo_msisdn(msisdn)
+    out_resp = {}
+    begin
+      msisdn_data = []
+      collection = client_vpn[:msisdn_list]
+      collection.find({:msisdn => msisdn.to_s}).each {|row|
+        msisdn_data = row
+      }
+      if msisdn_data != [] && msisdn_data["msisdn"] != nil && msisdn_data["msisdn"] != ""
+        if msisdn_data["group_id"] != [] && msisdn_data["group_id"] != nil && msisdn_data["group_id"] != ""
+          if msisdn_data["profile_id"] != [] && msisdn_data["profile_id"] != nil && msisdn_data["profile_id"] != ""
+            out_resp = {:code => 200, :result => "get_mongo_msisdn: Request completed successfully", :body => msisdn_data}
+          else
+            out_resp = {:code => 406, :result => "get_mongo_msisdn: invalid data. profile_id not found"}
+          end
+        else
+          out_resp = {:code => 405, :result => "get_mongo_msisdn: invalid data. organization_id not found"}
+        end
+      else
+        out_resp = {:code => 404, :result => "get_mongo_msisdn: login not found in database"}
+      end
+    rescue
+      out_resp = {:code => 507, :result => "get_mongo_msisdn: Unknown SDK error"}
+    end
+    logger_any.printer_texter(out_resp, "debug")
+    out_resp
+  end
+
+
+
+end
+
+

data/lib/imperituroard/projects/iot.rb

@@ -1427,6 +1427,6 @@ class IotFunctions_2
     p "yyyyy"
 
     #fff = HuaIot.new("134.17.93.4", "443", "/Users/imperituroard/Desktop/cert.crt", "/Users/imperituroard/Desktop/key.pem")
-    p hua_aceanconnect_connector.querying_device_id("Jy5KpoBUOScZEcrO2bRZhzfaIOUa", "VFFWTOb9k3_cQhzrGsRWT4HE8Z0a", "123456789876543")
+    p hua_aceanconnect_connector.querying_device_id("Jy5KpoBUOScZEcrO2bRZhzfaIOUa", "VFFWTOb9k3_cQhzrGsRWT4HE8Z0a", "123412341284999")
   end
 end

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

@@ -82,6 +82,7 @@ class HuaIot
       request.content_type = 'application/x-www-form-urlencoded'
       request.body = URI.encode_www_form(data)
       res = https.request(request)
+      p "get_token"
       p res.code
       p res.message
       p res.body.to_s
@@ -293,27 +294,30 @@ class HuaIot
 
   #2.2.44 Querying the Device ID
   def querying_device_id(app_id, secret, node_id)
-    token = get_token(app_id, secret)[:body]["accessToken"]
-    p token
-    path = "/iocm/app/dm/v1.1.0/queryDeviceIdByNodeId?nodeId=" + node_id + "&appId=Jy5KpoBUOScZEcrO2bRZhzfaIOUa"
-    p path
-    p path
-    url_string = "https://" + platformip + ":" + platformport + path
-    p url_string
-    uri = URI.parse url_string
-    https = Net::HTTP.new(uri.host, uri.port)
-    https.use_ssl = true
-    https.cert = OpenSSL::X509::Certificate.new(File.read(cert_file))
-    https.key = OpenSSL::PKey::RSA.new(File.read(key_file))
-    https.verify_mode = OpenSSL::SSL::VERIFY_NONE
-    request = Net::HTTP::Get.new(uri.path)
-    request.content_type = 'application/json'
-    request['Authorization'] = 'Bearer ' + token
-    request['app_key'] = app_id
-    res = https.request(request)
-    p res.body.to_s
-    p res.code
-    {:code => res.code, :message => res.message, :body => valid_json?(res.body.to_s)}
+    get_token_data = get_token(app_id, secret)
+    if get_token_data[:code]=="200"
+      token = get_token_data[:body]["accessToken"]
+      uri1 = URI("https://134.17.93.4:8743/iocm/app/dm/v1.1.0/queryDeviceIdByNodeId?nodeId=" + node_id + "&" + app_id)
+      https = Net::HTTP.new(uri1.host, uri1.port)
+      https.use_ssl = true
+      https.cert = OpenSSL::X509::Certificate.new(File.read(cert_file))
+      https.key = OpenSSL::PKey::RSA.new(File.read(key_file))
+      https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      request = Net::HTTP::Get.new(uri1)
+      request.content_type = 'application/json'
+      request['app_key'] = app_id
+      request['Authorization'] = 'Bearer ' + token
+      #request.set_form_data( params )
+      #request['node-id'] = node_id
+      bbb =  {"nodeId": node_id, "appId": "Jy5KpoBUOScZEcrO2bRZhzfaIOUa"}.to_json
+      #request.body = bbb
+      res = https.request(request)
+      #p res.body.to_s
+      #p res.code
+      {:code => res.code, :message => res.message, :body => valid_json?(res.body.to_s)}
+    else
+      {:code => "500", :message => "Something wrong", :body => {}}
+    end
   end
 
   #2.2.14 Querying Device Activation Status

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
     @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,7 +122,61 @@ 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
@@ -142,15 +200,11 @@ 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
 
 
-end

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

@@ -0,0 +1,96 @@
+require 'imperituroard/projects/mhub/subs/evrotorg/gms_connector'
+
+
+class Gmsgms_2
+
+  attr_accessor :gms_t_login, :gms_t_password, :gms_r_login, :gms_r_password, :gms_t_connector, :gms_r_connector
+
+
+  def initialize(gms_t_login, gms_t_password, gms_r_login, gms_r_password, telegram_api_url, telegram_chat_id)
+    @gms_t_login = gms_t_login
+    @gms_t_password = gms_t_password
+    @gms_r_login = gms_r_login
+    @gms_r_password = gms_r_password
+
+    @gms_t_connector = Gms_2.new(gms_t_login, gms_t_password, telegram_api_url, telegram_chat_id)
+    @gms_r_connector = Gms_2.new(gms_r_login, gms_r_password, telegram_api_url, telegram_chat_id)
+
+    @internal_func = InternalFunc.new
+    @telegram_connector = Telegram_2.new(telegram_api_url, telegram_chat_id)
+
+  end
+
+  def gms_parsing(gms_answer)
+    output = {}
+
+    status_dic = {
+        12033 => "Sent to Viber",
+        36013 => "Viber internal failure",
+        36023 => "Viber invalid service id",
+        36033 => "Viber invalid data",
+        36043 => "Viber blocked message type",
+        36053 => "Viber bad message type",
+        36063 => "Viber bad parameters",
+        36073 => "Viber timeout",
+        36083 => "Viber user blocked",
+        36093 => "Viber not viber user",
+        36103 => "Viber no suitable device",
+        36113 => "Viber unauthorized ip",
+        36123 => "Viber already sent",
+        36133 => "Viber not permitted",
+        36143 => "Viber billing failure",
+        36153 => "Viber word in black list",
+        36163 => "Viber internal process error",
+        36173 => "Viber wrong or missing Label",
+        36183 => "Viber invalid TTL value",
+        23033 => "Viber delivered",
+        35015 => "Viber expired",
+        24013 => "Viber delivered(seen)",
+        28013 => "Viber delivered(overdue)",
+        -1 => "in progress"
+    }
+
+    if gms_answer[:code] == 200
+      dt1 = gms_answer[:body][:res_body]["reports"][0]
+      hyber_status = dt1["hyber_status"]
+      output = {:code => 200, :result => "Processed", :body => {"status_code": hyber_status, "status": status_dic[hyber_status], "phone_number": dt1["phone_number"], "message_id": dt1["extra_id"]}}
+    elsif gms_answer[:code] == 404
+      output = {:code => 404, :result => "Not found", :body => {"status_code": "", "status": "", "phone_number": "", "message_id": gms_answer[:body][:request_message][:external_id]}}
+    else
+      output = {:code => gms_answer[:code], :result => gms_answer[:result], :body => {"status_code": "", "status": "", "phone_number": "", "message_id": gms_answer[:body][:request_message][:external_id]}}
+    end
+    output
+  end
+
+
+  def get_t_status_external_2(external_id)
+    output = {}
+    begin
+      ans = gms_t_connector.get_advanced_by_external(external_id)
+      parsed = gms_parsing(ans)
+      output = {:gms_answer => ans, :parsed_answer => parsed}
+    rescue
+      pars = {:code => "505", :result => "Failed", :body => {"status_code": "", "status": "", "phone_number": "", "message_id": ""}}
+      output = {:gms_answer => ans, :parsed_answer => pars}
+    end
+    output
+  end
+
+
+  def get_r_status_external_2(external_id)
+    output = {}
+    begin
+      ans = gms_r_connector.get_advanced_by_external(external_id)
+      parsed = gms_parsing(ans)
+      output = {:gms_answer => ans, :parsed_answer => parsed}
+    rescue
+      pars = {:code => "505", :result => "Failed", :body => {"status_code": "", "status": "", "phone_number": "", "message_id": ""}}
+      output = {:gms_answer => ans, :parsed_answer => pars}
+    end
+    output
+  end
+
+end
+
+
+

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

@@ -1,14 +1,16 @@
 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)
@@ -16,6 +18,13 @@ class Sksk_2
   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