imperituroard 0.5.7 → 1.0.2

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

@@ -6,13 +6,14 @@ require 'rubygems'
 require 'nokogiri'
 require 'rails'
 require "imperituroard/projects/iot/internal_functions"
+require 'imperituroard/projects/iot/mongoconnector'
 
 
 class HuaIot
 
-  attr_accessor :platformip, :platformport, :client, :database, :cert_file, :key_file, :internal_func
+  attr_accessor :platformip, :platformport, :client, :database, :cert_file, :key_file, :internal_func, :client_iot_mongo
 
-  def initialize(platformip, platformport, cert_file, key_file)
+  def initialize(platformip, platformport, cert_file, key_file, mongo_ip, mongo_port, mongo_database)
     @database = database
     @platformip = platformip
     @platformport = platformport
@@ -21,6 +22,7 @@ class HuaIot
     #client_host = [mongoip + ":" + mongoport]
     #@client = Mongo::Client.new(client_host, :database => database)
     @internal_func = InternalFunc.new
+    @client_iot_mongo = MongoIot.new(mongo_ip, mongo_port, mongo_database)
   end
 
   def parse_token(str)
@@ -72,6 +74,11 @@ class HuaIot
       request.body = URI.encode_www_form(data)
       res = https.request(request)
       out_resp = {:code => res.code, :message => res.message, :body => JSON.parse(res.body.to_s)}
+      fff = {:func => "get_token",
+             :iot_fun => "",
+             :req_header => {:content_type => 'application/x-www-form-urlencoded'
+             }}
+      client_iot_mongo.audit_iot_logger(fff, url_string, data, out_resp)
     rescue
       out_resp = {:code => 500, :message => "failed get token"}
     end
@@ -104,6 +111,10 @@ class HuaIot
       request.body = URI.encode_www_form(data)
       res = https.request(request)
       out_resp = {:code => res.code, :message => res.message, :body => JSON.parse(res.body.to_s)}
+      fff = {:func => "token_logout",
+             :iot_fun => "logout"
+      }
+      client_iot_mongo.audit_iot_logger(fff, url_string, data, out_resp)
     rescue
       out_resp = {:code => 500, :message => "failed logout token"}
     end
@@ -129,7 +140,6 @@ class HuaIot
     request['app_key'] = app_id
     request.body = {nodeId: node_id}.to_json
     res = https.request(request)
-    p res.body.to_s
     {:code => res.code, :message => res.message, :body => JSON.parse(res.body.to_s)}
   end
 
@@ -157,13 +167,18 @@ class HuaIot
                              manufacturerName: manufacturer_name,
                              model: model,
                              isSecurity: "FALSE",
-                             supportedSecurity: "FALSE"}}.to_json
+                             supportedSecurity: "FALSE"}}
     internal_func.printer_texter({:procedure => "dev_register_passw_code_mode2", :data => {:body => data_out, :url => url_string}}, "debug")
-    request.body = data_out
+    request.body = data_out.to_json
     res = https.request(request)
-    p res.body.to_s
     out_resp = {:code => res.code, :message => res.message, :body => JSON.parse(res.body.to_s)}
-    p out_resp
+    fff = {:func => "dev_register_passw_code_mode2",
+           :iot_fun => "2.2.4",
+           :req_header => {:authorization => 'Bearer ' + token,
+                           :content_type => 'application/json',
+                           :app_key => app_id
+           }}
+    client_iot_mongo.audit_iot_logger(fff, url_string, data_out, out_resp)
     out_resp
   end
 
@@ -213,18 +228,21 @@ class HuaIot
       request['Authorization'] = 'Bearer ' + token
       request['app_key'] = app_id
       res = https.request(request)
-      p "res.code"
-      p res.code
-      p res.body
       if res.body != nil
         out_resp = {:code => res.code, :message => res.message, :body => {:answ => JSON.parse(res.body.to_s)}}
       else
         out_resp = {:code => res.code, :message => res.message, :body => {:answ => "no data"}}
       end
+      fff = {:func => "dev_delete",
+             :iot_fun => "2.2.12",
+             :req_header => {:authorization => 'Bearer ' + token,
+                             :content_type => 'application/json',
+                             :app_key => app_id
+             }}
+      client_iot_mongo.audit_iot_logger(fff, url_string, "Delete", out_resp)
     rescue
       out_resp = {:code => 500, :message => "dev_delete: Unknown IOT error"}
     end
-    p out_resp
     out_resp
   end
 
@@ -295,6 +313,7 @@ class HuaIot
 
   #2.9.6 Querying Directly Connected Devices and Their Mounted Devices in Batches
   def querying_device_direct_conn(app_id, secret, dev_list)
+    output_str = {}
     token = get_token(app_id, secret)[:body]["accessToken"]
     path = "/iocm/app/dm/v1.1.0/queryDevicesByIds"
     url_string = "https://" + platformip + ":" + platformport + path
@@ -308,9 +327,18 @@ class HuaIot
     request.content_type = 'application/json'
     request['Authorization'] = 'Bearer ' + token
     request['app_key'] = app_id
-    request.body = {deviceIds: dev_list}.to_json
+    req_body = {deviceIds: dev_list}
+    request.body = req_body.to_json
     res = https.request(request)
-    {:code => res.code, :message => res.message, :body => JSON.parse(res.body.to_s)}
+    output_str = {:code => res.code, :message => res.message, :body => JSON.parse(res.body.to_s)}
+    fff = {:func => "querying_device_direct_conn",
+           :iot_fun => "2.9.6",
+           :req_header => {:authorization => 'Bearer ' + token,
+                           :content_type => 'application/json',
+                           :app_key => app_id
+           }}
+    client_iot_mongo.audit_iot_logger(fff, url_string, req_body, output_str)
+    output_str
   end
 
 
@@ -364,7 +392,7 @@ class HuaIot
     begin
       path = "/iocm/app/dm/v1.4.0/devices/" + dev_id + "?app_Id=" + app_id
       url_string = "https://" + platformip + ":" + platformport + path
-      internal_func.printer_texter({:url_string=>url_string, :procedure=>"dev_modify_location_v2"}, "debug")
+      internal_func.printer_texter({:url_string => url_string, :procedure => "dev_modify_location_v2"}, "debug")
       uri = URI.parse url_string
       https = Net::HTTP.new(uri.host, uri.port)
       https.use_ssl = true
@@ -375,7 +403,8 @@ class HuaIot
       request.content_type = 'application/json'
       request['Authorization'] = 'Bearer ' + token
       request['app_key'] = app_id
-      request.body = {location: address}.to_json
+      req_b = {location: address}
+      request.body = req_b.to_json
       res = https.request(request)
       p res.code
       p res.body
@@ -384,6 +413,13 @@ class HuaIot
       else
         out_resp = {:code => res.code, :message => res.message, :body => {:answ => "no data"}}
       end
+      fff = {:func => "dev_modify_location_v2",
+             :iot_fun => "2.2.11",
+             :req_header => {:authorization => 'Bearer ' + token,
+                             :content_type => 'application/json',
+                             :app_key => app_id
+             }}
+      client_iot_mongo.audit_iot_logger(fff, url_string, req_b, out_resp)
     rescue
       out_resp = {:code => 500, :message => "dev_modify_location_v2: Unknown IOT error"}
     end
@@ -392,7 +428,6 @@ class HuaIot
   end
 
 
-
   ##2.10.7 Adding Members to a Device Group
 
 

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

@@ -41,6 +41,30 @@ class MongoIot
     out_resp
   end
 
+  def audit_iot_logger(proc_name, url_str, input_json, output_json)
+    out_resp = {}
+    p "iiiiiiiot"
+    p input_json
+    begin
+      current = internal_func.datetimenow
+      collection = client[:audit_iot_platform]
+      doc = {
+          :proc_name => proc_name,
+          :date => current,
+          :url => url_str,
+          :iot_platform_request => input_json,
+          :iot_platform_responce => output_json
+      }
+      p doc
+      result = collection.insert_one(doc)
+      out_resp = {:code => 200, :result => "audit_logger: Request completed successfully", :body => result}
+    rescue
+      out_resp = {:code => 507, :result => "audit_logger: Unknown SDK error"}
+    end
+    internal_func.printer_texter(out_resp, "debug")
+    out_resp
+  end
+
   #:code => 507, :result => "Unknown SDK error"
   #{:code => 200, :result => "Request completed successfully", :body => result_ps}
   def get_profiles_by_login(login)
@@ -364,6 +388,7 @@ class MongoIot
 
   def get_profile_name_from_imei(imei)
     out_resp = {}
+    info = {}
     begin
       id = ""
       begin
@@ -387,7 +412,7 @@ class MongoIot
           end
           begin
             if res["profile"]!=nil
-              out_resp = {:code => 200, :result => "get_profile_name_from_imei: Request completed successfully", :body => res}
+              out_resp = {:code => 200, :result => "get_profile_name_from_imei: Request completed successfully", :body => res, :imei_info => info}
             end
           rescue
             out_resp = {:code => 506, :result => "get_profile_name_from_imei: Function get_profile_name_by_id not processed correctly and returned: #{res.to_s}"}
@@ -523,5 +548,155 @@ class MongoIot
     out_resp
   end
 
+  def get_device_type_info_universal(device_model)
+    out_resp = {}
+    begin
+      as = internal_func.if_digit_or_string(device_model)
+
+      if as[:body][:string]
+        result_ps = []
+        collection = client[:device_types]
+        collection.find({"model" => device_model}).each {|row|
+          result_ps.append(row)
+        }
+        dattaa = result_ps[0]
+        if dattaa!=nil
+          out_resp = {:code => 200, :result => "get_device_type_info_by_model: Request completed successfully", :body => dattaa}
+        else
+          out_resp = {:code => 404, :result => "get_device_type_info_by_model: Device info not found", :body => {"model" => device_model, "ManufacturerID" => "unknown", "ManufacturerNAME" => "unknown", "device_type" => "unknown"}}
+        end
+      else
+        result_ps2 = []
+        collection = client[:device_types]
+        collection.find({"type_id" => device_model.to_i}).each {|row|
+          result_ps2.append(row)
+        }
+        dattaa = result_ps2[0]
+        if dattaa!=nil
+          out_resp = {:code => 200, :result => "get_device_type_info_by_model: Request completed successfully", :body => dattaa}
+        else
+          out_resp = {:code => 404, :result => "get_device_type_info_by_model: Device info not found", :body => {"model" => device_model, "ManufacturerID" => "unknown", "ManufacturerNAME" => "unknown", "device_type" => "unknown"}}
+        end
+      end
+
+    rescue
+      out_resp = {:code => 500, :result => "get_device_type_info_universal: procedure error", :body => {"model" => device_model, "ManufacturerID" => "unknown", "ManufacturerNAME" => "unknown", "device_type" => "unknown"}}
+    end
+    internal_func.printer_texter(out_resp, "debug")
+    out_resp
+  end
+
+
+
+  def compare_profiles(profile1, profile2)
+    out_answ = {}
+    ch1 = internal_func.if_digit_or_string(profile1)
+    ch2 = internal_func.if_digit_or_string(profile2)
+    if ch1[:body][:string] == ch2[:body][:string] && ch1[:body][:string] == false
+      if profile1.to_i == profile2.to_i
+        out_answ = {:code => 200, :result => "compare_profiles: profiles are the same", :is_the_same => true, :data_type => "integer"}
+      else
+        out_answ = {:code => 200, :result => "compare_profiles: profiles are different", :is_the_same => false, :data_type => "integer"}
+      end
+    elsif ch1[:body][:string] == ch2[:body][:string] && ch1[:body][:string] == true
+      if profile1 == profile2
+        out_answ = {:code => 200, :result => "compare_profiles: profiles are the same", :is_the_same => true, :data_type => "string"}
+      else
+        out_answ = {:code => 200, :result => "compare_profiles: profiles are different", :is_the_same => false, :data_type => "string"}
+      end
+    else
+      ch1_data = {}
+      ch2_data = {}
+      if ch1[:body][:string]
+        ch1_data = self.get_profile_id_by_name(profile1)
+      else
+        ch1_data = self.get_profile_name_by_id(profile1.to_i)
+      end
+
+      if ch2[:body][:string]
+        ch2_data = self.get_profile_id_by_name(profile2)
+      else
+        ch2_data = self.get_profile_name_by_id(profile2.to_i)
+      end
+
+      if ch1_data["profile_id"] == ch2_data["profile_id"]
+        out_answ = {:code => 200, :result => "compare_profiles: profiles are the same", :is_the_same => true, :data_type => "different"}
+      else
+        out_answ = {:code => 200, :result => "compare_profiles: profiles are different", :is_the_same => false, :data_type => "different"}
+      end
+    end
+    out_answ
+  end
+
+  def compare_device_types(type1, type2)
+    out_answ = {}
+    tp1 = internal_func.if_digit_or_string(type1)
+    tp2 = internal_func.if_digit_or_string(type2)
+
+    if tp1[:body][:string] == tp2[:body][:string] && tp1[:body][:string] == false
+      if type1.to_i == type2.to_i
+        out_answ = {:code => 200, :result => "compare_device_types: types are the same", :is_the_same => true, :data_type => "integer"}
+      else
+        out_answ = {:code => 200, :result => "compare_device_types: types are different", :is_the_same => false, :data_type => "integer"}
+      end
+    elsif tp1[:body][:string] == tp2[:body][:string] && tp1[:body][:string] == true
+      if type1 == type2
+        out_answ = {:code => 200, :result => "compare_device_types: types are the same", :is_the_same => true, :data_type => "string"}
+      else
+        out_answ = {:code => 200, :result => "compare_device_types: types are different", :is_the_same => false, :data_type => "string"}
+      end
+    else
+      tp1_data = {}
+      tp2_data = {}
+      if tp1[:body][:string]
+        tp1_data = self.get_type_by_name(type1)
+      else
+        tp1_data = self.get_type_by_id(type1.to_i)
+      end
+
+      if tp2[:body][:string]
+        tp2_data = self.get_type_by_name(type2)
+      else
+        tp2_data = self.get_type_by_id(type2.to_i)
+      end
+
+      if tp1_data["type_id"] == tp2_data["type_id"]
+        out_answ = {:code => 200, :result => "compare_device_types: profiles are the same", :is_the_same => true, :data_type => "different"}
+      else
+        out_answ = {:code => 200, :result => "compare_device_types: profiles are different", :is_the_same => false, :data_type => "different"}
+      end
+    end
+    out_answ
+  end
+
+
+  def get_profile_universal(profile)
+    inn = internal_func.if_digit_or_string(profile)
+    out = {}
+    if inn[:body][:string]
+      out = self.get_profile_id_by_name(profile)
+    else
+      out = self.get_profile_name_by_id(profile.to_i)
+    end
+    out
+  end
+
+  def modify_attr_mongo_universal(imei, attribute)
+    out_resp = {}
+    begin
+      collection = client[:device_imei]
+      doc = {
+          "imei" => imei
+      }
+      sett = {'$set' => attribute}
+      result = collection.update_one(doc, sett)
+      out_resp = {:code => 200, :result => "modify_attr_mongo_universal: Request completed successfully"}
+    rescue
+      out_resp = {:code => 507, :result => "modify_attr_mongo_universal: Unknown SDK error"}
+    end
+    internal_func.printer_texter(out_resp, "debug")
+    out_resp
+  end
+
+end
 
-end

data/lib/imperituroard/projects/mhub.rb

@@ -51,6 +51,7 @@ class MhubFunctions_2
   # "notifyContentType"=>"application/json"}}
 
 
+  #for bank dabrabyt
   def get_send_message_2(params, ip_src, ip_real, ip_vip)
 
     input_params = {:params => params}
@@ -123,6 +124,7 @@ class MhubFunctions_2
   end
 
 
+  #for bank dabrabyt
   def rec_deliv_report_2(params, ip_src, ip_real, ip_vip)
     input_params = {:params => params, :ip_src => ip_src, :ip_real => ip_real, :ip_vip => ip_vip}
     output_params = {}

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

@@ -1,8 +1,9 @@
 require 'imperituroard/projects/iot/internal_functions'
+require 'imperituroard/projects/mhub/subs/dabrab/dabrab_proced'
 
 class Sksk_2
 
-  attr_accessor :sk_url, :sk_url_broadcast, :sk_login, :sk_password, :internal_func, :telegram_connector
+  attr_accessor :sk_url, :sk_url_broadcast, :sk_login, :sk_password, :internal_func, :telegram_connector, :dabrab_add_func
 
   def initialize(sk_url, sk_login, sk_password, sk_url_broadcast, telegram_api_url, telegram_chat_id)
     @sk_url = sk_url
@@ -11,6 +12,7 @@ class Sksk_2
     @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
   end
 
 
@@ -82,50 +84,49 @@ class Sksk_2
     request_message = {}
 
     begin
-
       thr_sk_send_viber_one = Thread.new do
+        viber_mess_ans = dabrab_add_func.dabrabyt_text_field_parse(text)
+
+        if viber_mess_ans[:code] == 200
+          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
+
+          req["Content-Type"] = "application/json"
+          req["Accept"] = "application/json"
+
+          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": viber_mess_ans[:body][:to_sk_format]
+              }
+          }
+          req.body = request_message.to_json
+          res = https.request(req)
+          output_params = {:code => 200,
+                           :result => "Sksk_2.sk_send_viber_one: Request processed",
+                           :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_one: Something wrong with dabrabyt_text_field_parse"}
+        end
 
 
-        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
-
-        req["Content-Type"] = "application/json"
-        req["Accept"] = "application/json"
-
-        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_2.sk_send_viber_one: Request processed",
-                         :body => {:request_message => request_message,
-                                   :res_code => res.code,
-                                   :res_body => JSON.parse(res.body.to_s)}}
-
       end
 
       thr_sk_send_viber_one.join
@@ -149,53 +150,54 @@ class Sksk_2
 
       thr_sk_send_viber_sms_one = Thread.new do
 
-        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
-
-        req["Content-Type"] = "application/json"
-        req["Accept"] = "application/json"
-
-        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_2.sk_send_viber_sms_one: Request processed",
-                         :body => {:request_message => request_message,
-                                   :res_code => res.code,
-                                   :res_body => JSON.parse(res.body.to_s)}}
+        viber_mess_ans = dabrab_add_func.dabrabyt_text_field_parse(viber_txt)
+
+        if viber_mess_ans[:code] == 200
+          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
+
+          req["Content-Type"] = "application/json"
+          req["Accept"] = "application/json"
+
+          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": viber_mess_ans[:body][:to_sk_format]
+              }
+          }
+
+          req.body = request_message.to_json
+          res = https.request(req)
+
+          output_params = {:code => 200,
+                           :result => "Sksk_2.sk_send_viber_sms_one: Request processed",
+                           :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_one: Something wrong with dabrabyt_text_field_parse"}
+        end
 
       end
 
@@ -281,44 +283,49 @@ class Sksk_2
     begin
 
       thr_sk_send_viber_list = Thread.new do
-        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'})
+        viber_mess_ans = dabrab_add_func.dabrabyt_text_field_parse(text)
 
-        req["Content-Type"] = "application/json"
-        req["Accept"] = "application/json"
+        if viber_mess_ans[:code] == 200
+          uri = URI(sk_url_broadcast)
+          #8 - client id
 
-        req.basic_auth sk_login, sk_password
+          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["Content-Type"] = "application/json"
+          req["Accept"] = "application/json"
 
-        # [{"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
-                }
-            }
-        }
+          req.basic_auth sk_login, sk_password
 
-        req.body = request_message.to_json
-        res = https.request(req)
 
-        output_params = {:code => 200,
-                         :result => "Sksk_2.sk_send_viber_list: Request processed",
-                         :body => {:request_message => request_message,
-                                   :res_code => res.code,
-                                   :res_body => JSON.parse(res.body.to_s)}}
+          # [{"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": viber_mess_ans[:body][:to_sk_format]
+              }
+          }
+
+          req.body = request_message.to_json
+          res = https.request(req)
+
+          output_params = {:code => 200,
+                           :result => "Sksk_2.sk_send_viber_list: Request processed",
+                           :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_list: Something wrong with dabrabyt_text_field_parse"}
+        end
+
       end
       thr_sk_send_viber_list.join
     rescue
@@ -337,50 +344,57 @@ class Sksk_2
 
     begin
       thr_sk_send_viber_sms_list = Thread.new do
-        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'})
+        viber_mess_ans = dabrab_add_func.dabrabyt_text_field_parse(viber_text)
 
-        req.basic_auth sk_login, sk_password
+        if viber_mess_ans[:code] == 200
 
+          uri = URI(sk_url_broadcast)
+          #8 - client id
 
-        req["Content-Type"] = "application/json"
-        req["Accept"] = "application/json"
+          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'})
 
-        # [{"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": sms_text,
-                    "ttl": 60
-                },
-                "viber": {
-                    "text": viber_text,
-                    "ttl": 60
-                }
-            }
-        }
+          req.basic_auth sk_login, sk_password
 
-        req.body = request_message.to_json
-        res = https.request(req)
 
-        output_params = {:code => 200,
-                         :result => "Sksk_2.sk_send_viber_sms_list: Request processed",
-                         :body => {:request_message => request_message,
-                                   :res_code => res.code,
-                                   :res_body => JSON.parse(res.body.to_s)}}
+          req["Content-Type"] = "application/json"
+          req["Accept"] = "application/json"
+
+          # [{"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": sms_text,
+                      "ttl": 60
+                  },
+                  "viber": viber_mess_ans[:body][:to_sk_format]
+              }
+          }
+
+          req.body = request_message.to_json
+          res = https.request(req)
+
+          output_params = {:code => 200,
+                           :result => "Sksk_2.sk_send_viber_sms_list: Request processed",
+                           :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