imperituroard 0.5.1 → 0.5.7

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

@@ -96,27 +96,27 @@ class AdditionalFunc
   end
 
   def check_input_1(login, imei_list)
-    {:code=>200, :result=>"Request completed successfully", :body=>"Data checked"}
+    {:code => 200, :result => "Request completed successfully", :body => "Data checked"}
   end
 
   def check_input_2(login, imei_list)
-    {:code=>200, :result=>"Request completed successfully", :body=>"Data checked"}
+    {:code => 200, :result => "Request completed successfully", :body => "Data checked"}
   end
 
   def check_input_3(login, imei_list)
-    {:code=>200, :result=>"Request completed successfully", :body=>"Data checked"}
+    {:code => 200, :result => "Request completed successfully", :body => "Data checked"}
   end
 
   def check_input_4(login, imei_list)
-    {:code=>200, :result=>"Request completed successfully", :body=>"Data checked"}
+    {:code => 200, :result => "Request completed successfully", :body => "Data checked"}
   end
 
   def check_input_5(login, imei_list)
-    {:code=>200, :result=>"Request completed successfully", :body=>"Data checked"}
+    {:code => 200, :result => "Request completed successfully", :body => "Data checked"}
   end
 
   def check_input_6(login, imei_list)
-    {:code=>200, :result=>"Request completed successfully", :body=>"Data checked"}
+    {:code => 200, :result => "Request completed successfully", :body => "Data checked"}
   end
 
   def iot_query_dev_soapgw_answer(input_params, output_answer)
@@ -127,28 +127,28 @@ class AdditionalFunc
 
     begin
 
-    if output_answer[:code]==200
-      dataaa = []
-      dataaa_failed = []
-
-      ddd = answ_dev_query_format_process(output_answer[:data])[:body]
-      p ddd
-
-      answ = { :code => output_answer[:code],
-               :result => output_answer[:result],
-               :data => ddd[:ok],
-               :error_list => ddd[:failed]
-      }
-    else
-      answ = { :code => output_answer[:code],
-               :result => output_answer[:result],
-               :data => [],
-               :error_list => input_params[:imei]
-      }
-    end
+      if output_answer[:code]==200
+        dataaa = []
+        dataaa_failed = []
+
+        ddd = answ_dev_query_format_process(output_answer[:data])[:body]
+        p ddd
+
+        answ = {:code => output_answer[:code],
+                :result => output_answer[:result],
+                :data => ddd[:ok],
+                :error_list => ddd[:failed]
+        }
+      else
+        answ = {:code => output_answer[:code],
+                :result => output_answer[:result],
+                :data => [],
+                :error_list => input_params[:imei]
+        }
+      end
     rescue
-      answ = { :code => 500,
-               :result => "Unknown error"
+      answ = {:code => 500,
+              :result => "Unknown error"
       }
     end
 

data/lib/imperituroard/projects/mhub.rb

@@ -23,9 +23,10 @@ class MhubFunctions_2
                 :dabrab_connecter,
                 :static_callback,
                 :crm_connector,
-                :telegram_connector
+                :telegram_connector,
+                :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)
+  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)
     @sk_url = sk_url_simple
     @sk_login = sk_login
     @sk_password = sk_password
@@ -36,6 +37,7 @@ class MhubFunctions_2
     @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)
+    @sms_alphaname = sms_alphaname
   end
 
 
@@ -91,13 +93,13 @@ 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"], "TEST")
+          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"])
           hub_resp = mhub_connector.sk_send_viber_list(msisdn2, static_callback, params["viber"]["text"])
         elsif !null_statement.include?(params["viber"]) && !null_statement.include?(params["sms"])
           p "vibersms"
           p msisdn2
-          hub_resp = mhub_connector.sk_send_viber_sms_list(msisdn2, static_callback, params["sms"]["text"], params["viber"]["text"], "TEST")
+          hub_resp = mhub_connector.sk_send_viber_sms_list(msisdn2, static_callback, params["sms"]["text"], params["viber"]["text"], sms_alphaname)
         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
@@ -128,8 +130,12 @@ class MhubFunctions_2
 
     begin
       mes_report = dabrab_connecter.delivery_report_transform(params)[:body][:report_to_recip]
-      result = crm_connector.crm_status_1(mes_report)
-      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}}}
+      result = crm_connector.crm_status_2(mes_report)
+      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
+        output_params = {"code": 202, "result": "CRM returned error #{result[:body][:res_body]["GetReportsResult"].to_s}", "body": {"answer": {"code": 200, "status": "Success"}, "sender": {"ip_src": ip_src, "ip_real": ip_real, "ip_vip": ip_vip}}}
+      end
     rescue
       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)

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

@@ -5,7 +5,7 @@
 
 
 
-class Infobip_1
+class Infobip_2
 
   def test
     gg = "{\"destinations\"=>[{\"to\"=>{\"phoneNumber\"=>\"375297116638\", \"emailAddress\"=>nil}}], \"scenarioKey\"=>\"1\", \"viber\"=>nil, \"sms\"=>{\"text\"=>\"карточка готова\"}, \"sendAt\"=>\"2019-08-15T08:40:00.000\", \"notifyUrl\"=>\"https://bpmonline.bankdabrabyt.by:444/0/ServiceModel/ScGetReports.svc/GetReports\", \"notifyContentType\"=>\"application/json\", \"controller\"=>\"bank\", \"action\"=>\"api\", \"bank\"=>{\"destinations\"=>[{\"to\"=>{\"phoneNumber\"=>\"375297116638\", \"emailAddress\"=>nil}}], \"scenarioKey\"=>\"1\", \"viber\"=>nil, \"sms\"=>{\"text\"=>\"карточка готова\"}, \"sendAt\"=>\"2019-08-15T08:40:00.000\", \"notifyUrl\"=>\"https://bpmonline.bankdabrabyt.by:444/0/ServiceModel/ScGetReports.svc/GetReports\", \"notifyContentType\"=>\"application/json\"}}"

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

@@ -37,6 +37,8 @@ class Crm_2
 
         req.body = crm_payload.to_json
         res = https.request(req)
+
+
         output_params = {:code => 200,
                          :result => "Crm_2.crm_status_2: Request processed",
                          :body => {:request_message => crm_payload,

data/lib/imperituroard/projects/ukaz60.rb

@@ -0,0 +1,138 @@
+$LOAD_PATH.unshift File.expand_path("../projects/ukaz60", __dir__)
+
+require 'json'
+
+require 'imperituroard/projects/ukaz60/belgim'
+require 'imperituroard/projects/ukaz60/fortigate'
+require 'imperituroard/projects/ukaz60/staros'
+
+class Ukaz60All_2
+
+  attr_accessor :telegram_messanger,
+                :belgim_login,
+                :belgim_password,
+                :belgim_url,
+                :ukaz60_add_func,
+                :belgim_connector,
+                :forti_connector,
+                :staros_connector
+
+  def initialize(telegram_api_url,
+                 telegram_chat_id,
+                 belgim_login,
+                 belgim_password,
+                 belgim_url,
+                 ansible_tmp_folder,
+                 local_tmp_directory,
+                 ansible_ssh_user,
+                 ansible_ssh_password,
+                 ansible_host,
+                 url_backup_dir,
+                 staros_login,
+                 staros_password,
+                 ukaz60_http_groups,
+                 ukaz60_https_groups,
+                 staros_hosts
+
+  )
+    @telegram_messanger = Telegram_2.new(telegram_api_url, telegram_chat_id)
+    @belgim_login = belgim_login
+    @belgim_password = belgim_password
+    @belgim_url = belgim_url
+    @ukaz60_add_func = AddFuncUkaz60_2.new
+    @belgim_connector = Belgim_2.new(telegram_api_url, telegram_chat_id, belgim_login, belgim_password, belgim_url)
+    @forti_connector = FortiUkaz60_2.new(ansible_tmp_folder, local_tmp_directory, ansible_ssh_user, ansible_ssh_password, ansible_host, url_backup_dir)
+    @staros_connector = Ukaz60Staros_2.new(staros_login, staros_password, ukaz60_http_groups, ukaz60_https_groups, staros_hosts)
+
+  end
+
+  def forti_process(get_belgim_data)
+    forti_answer = {}
+    begin
+      format_for_forti = forti_connector.prepare_url_config_fortigate(get_belgim_data)
+      if format_for_forti[:code] == 200
+        url_uploading = forti_connector.upload_url(format_for_forti[:body][:to_fortigate])
+        if url_uploading[:code] == 200
+          update_fortigate_ansible = forti_connector.update_weburl_fortigate
+          if update_fortigate_ansible[:code] == 200
+            forti_answer = {:code => 200, :result => "Fortigate processed", :data => update_fortigate_ansible[:body][:body], :num_uploaded_to_forti => format_for_forti[:body][:num_list]}
+          else
+            forti_answer = {:code => update_fortigate_ansible[:code], :result => update_fortigate_ansible[:result]}
+          end
+          forti_connector.clean_tmp_folders
+        else
+          forti_answer = {:code => 401, :result => "Failed for uploading data to ansible server"}
+        end
+      else
+        forti_answer = {:code => 400, :result => "Error while processing data"}
+      end
+    rescue
+      forti_answer = {:code => 507, :result => "Unknown error with Forti"}
+    end
+    forti_answer
+  end
+
+  def staros_process(get_belgim_data)
+
+    output_starprocess = {}
+
+    begin
+      #get data from staros
+      staros_blocks_current = staros_connector.get_all_staros_ukaz60
+
+      if staros_blocks_current[:code] == 200
+        #compare data with belgim
+        answ = ukaz60_add_func.staros_compare_http(staros_blocks_current, get_belgim_data)
+
+        if answ[:code] == 200
+          #output_starprocess = {:code => 200, :result => "Staros processed", :data => {:block_me => answ[:body][:for_block][:notblocked_stat], :unblock_me =>answ[:body][:for_unblock][:for_unblock_stat]}}
+          output_starprocess = ukaz60_add_func.format_star_processed_answ(answ)[:body][:to_message]
+        else
+          output_starprocess = answ
+        end
+
+      else
+        output_starprocess = staros_blocks_current
+      end
+    rescue
+      output_starprocess = {:code => 507, :result => "staros_process: Something wrong"}
+    end
+
+    output_starprocess
+  end
+
+  def no_pasaran
+
+    answer_output = {}
+    forti_answer = {}
+    staros_answer = {}
+
+    begin
+      get_belgim_data = belgim_connector.belgim_ukaz60_get
+
+      if get_belgim_data[:code] == 200
+
+        thr_forti = Thread.new do
+          forti_answer = self.forti_process(get_belgim_data)
+        end
+
+        thr_staros = Thread.new do
+          staros_answer = staros_process(get_belgim_data)
+        end
+
+        thr_staros.join
+        thr_forti.join
+
+        answer_output = {:code => 200, :result => "No pasaran", :fortigate => forti_answer, :staros => staros_answer, :info_belgim => get_belgim_data[:number]}
+      else
+        answer_output = {:code => 404, :result => "Failed to receive data from Belgim"}
+      end
+
+    rescue
+      answer_output = {:code => 507, :result => "no_pasaran: Unknown SDK error"}
+    end
+    telegram_messanger.telegram_message(JSON.pretty_generate(answer_output))
+    answer_output
+  end
+
+end

data/lib/imperituroard/projects/ukaz60/belgim.rb

@@ -0,0 +1,217 @@
+require 'imperituroard/platforms/public/telegram'
+require 'imperituroard/projects/ukaz60/ukaz60_add_func'
+
+require 'simpleidn'
+
+class Belgim_2
+
+
+  attr_accessor :telegram_messanger,
+                :belgim_login,
+                :belgim_password,
+                :belgim_url,
+                :ukaz60_add_func
+
+  def initialize(telegram_api_url,
+                 telegram_chat_id,
+                 belgim_login,
+                 belgim_password,
+                 belgim_url
+  )
+    @telegram_messanger = Telegram_2.new(telegram_api_url, telegram_chat_id)
+    @belgim_login = belgim_login
+    @belgim_password = belgim_password
+    @belgim_url = belgim_url
+    @ukaz60_add_func = AddFuncUkaz60_2.new
+  end
+
+
+  #get domains from belgim and parse data
+  #return all domains urls ips. Selection specific data for dns or firewall do by additional functions
+  #full ready for dns and firewall
+  def belgim_ukaz60_get
+
+    output_data = {}
+
+    begin
+
+      #data peremennye
+      regexp_redns = /<dns>(.{1,100})dns>/
+      regexp_reurl = /<url>(.{1,100})url>/
+      regexp_reip = /<ip>(.{1,100})ip>/
+
+      #processed data in correct format
+      domain_parsed = []
+      url_parsed = []
+      ipv4_parsed = []
+      ipv6_parsed = []
+      https_parsed = []
+      url_all = []
+
+      f2 =[]
+      results = {}
+
+      # Get data from Belgim site by curl
+      return_from_belgim = `curl -d "name=#{belgim_login}&pass=#{belgim_password}" -H "Content-Type: application/x-www-form-urlencoded" -X POST #{belgim_url}`
+      return_from_belgim = return_from_belgim.gsub!("\n", "")
+
+      #parse Belgim file by regexpression
+      # and split by 3 categories: url, dns, ip
+      belgim_domains = return_from_belgim.scan(regexp_redns)
+      belgim_urls = return_from_belgim.scan(regexp_reurl)
+      belgim_ips = return_from_belgim.scan(regexp_reip)
+
+      #process only domains.
+      for i in belgim_domains
+        a1 = i[0]
+        elem = a1.gsub("</", "")
+
+        if elem.include? " "
+          elem = elem.gsub(" ", "")
+        end
+
+        if elem.match(/а|б|в|г|д|е|ж|ё|Ё|з|и|й|к|л|м|н|о|п|р|с|т|у|ф|х|ц|ч|ш|щ|ь|ы|ъ|э|ю|я|А|Б|В|Г|Д|Е|Ж|З|И|Й|К|Л|М|Н|О|П|Р|С|Т|У|Ф|Х|Ц|Ч|Ш|Щ|Ь|Ы|Ъ|Э|Ю|Я/)
+          elem = SimpleIDN.to_ascii(elem)
+        end
+
+        if elem != "-" && elem != ""
+          domain_parsed.push(elem)
+          if_www = elem[0]+elem[1]+elem[2]+elem[3]
+
+          #if not contain www - add domain with www
+          if if_www != "www."
+            domain_parsed.push("www."+elem)
+          end
+
+          #if contain www - add domain without www
+          if if_www == "www."
+            gar = elem[4..elem.length]
+            domain_parsed.push(gar)
+          end
+        end
+      end
+
+      #process only urls
+      for s in belgim_urls
+
+        #process every domain. Find if https or http and domain
+        func_processed = ukaz60_add_func.delete_dump_symbols_url(s[0])
+
+        if func_processed[:code] == 200
+          processed_url = func_processed[:domain_only]
+          processed_domain_in_url = func_processed[:processed_domain_in_url]
+
+          if func_processed[:type] == "domain"
+            domain_parsed.push(processed_url)
+            check_if_www = processed_url[0]+processed_url[1]+processed_url[2]+processed_url[3]
+
+            #if not contains www then add with www too
+            if check_if_www != "www."
+              domain_parsed.push("www."+processed_url)
+            end
+
+            #if contains www then add without www too
+            if check_if_www == "www."
+              gar2domain = processed_url[4..processed_url.length]
+              domain_parsed.push(gar2domain)
+            end
+          elsif func_processed[:type] == "url" && func_processed[:protocol] != "https"
+            #p "Step4 processed_domain_in_url: #{processed_domain_in_url}"
+            #p "Step5 func_processed: #{func_processed.to_s}"
+
+            url_parsed.push(func_processed[:protocol] + "://" + processed_domain_in_url)
+            check_if_www2 = processed_domain_in_url[0]+processed_domain_in_url[1]+processed_domain_in_url[2]+processed_domain_in_url[3]
+            if check_if_www2 != "www."
+              url_parsed.push(func_processed[:protocol] + "://" + "www."+processed_domain_in_url)
+            end
+            if check_if_www2 == "www."
+              gar1url = processed_domain_in_url[4..processed_domain_in_url.length]
+              url_parsed.push(func_processed[:protocol] + "://" + gar1url)
+            end
+          elsif func_processed[:protocol] == "https"
+            #additional section for https urls
+            https_parsed.push(func_processed[:protocol] + "://" + processed_domain_in_url)
+            check_if_www2https = processed_domain_in_url[0]+processed_domain_in_url[1]+processed_domain_in_url[2]+processed_domain_in_url[3]
+            if check_if_www2https != "www."
+              https_parsed.push(func_processed[:protocol] + "://" + "www."+processed_domain_in_url)
+            end
+            if check_if_www2https == "www."
+              gar1url_https = processed_domain_in_url[4..processed_domain_in_url.length]
+              https_parsed.push(func_processed[:protocol] + "://" + gar1url_https)
+            end
+          end
+        end
+      end
+
+      #process only IPs
+      for f in belgim_ips
+
+        a2ip = f[0]
+
+        if a2ip.include? " "
+          a2ip = a2ip.gsub(" ", "")
+        end
+
+        elem_ip = a2ip.gsub("</", "")
+
+        if elem_ip != "-" && elem_ip != ""
+          if elem_ip.include?(":")
+            ipv6_parsed.push(elem_ip)
+          else
+            ipv4_parsed.push(elem_ip)
+          end
+        end
+      end
+
+      domain_parsed = domain_parsed.uniq
+      url_parsed = url_parsed.uniq
+      ipv6_parsed = ipv6_parsed.uniq
+      ipv4_parsed = ipv4_parsed.uniq
+      https_parsed = https_parsed.uniq
+
+      https_parsed_tmmp = []
+      https_parsed.each do |tmp_tmp|
+        https_parsed_tmmp.push(tmp_tmp.gsub("https://", "http://"))
+      end
+      url_all = https_parsed_tmmp + url_parsed
+      url_all = url_all.uniq
+      url_all_num = url_all.length
+
+
+      dns_num = domain_parsed.length
+      ipv4_num = ipv4_parsed.length
+      ipv6_num = ipv6_parsed.length
+      url_num = url_parsed.length
+      https_num = https_parsed.length
+
+      all_num = dns_num + ipv4_num + ipv6_num + url_num + https_num
+
+
+
+      output_data = {:code => 200,
+                     :result => "Request completed successfully",
+                     :number => {:domain_num => dns_num,
+                                 :url_http_num => url_num,
+                                 :ipv4_num => ipv4_num,
+                                 :ipv6_num => ipv6_num,
+                                 :url_https_num => https_num,
+                                 :url_all_num => url_all_num,
+                                 :all_num => all_num
+                     },
+                     :domains_for_block => domain_parsed,
+                     :url_for_block => url_parsed,
+                     :ipv6_parsed => ipv6_parsed,
+                     :ipv4_parsed => ipv4_parsed,
+                     :https_parsed => https_parsed,
+                     :url_all => url_all
+      }
+
+    rescue
+      output_data = {:code => 507, :result => "belgim_ukaz60_get: Unknown error"}
+    end
+    output_data
+
+  end
+
+
+end