imperituroard 0.5.2 → 0.5.8

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

@@ -1,5 +1,117 @@
 class Dabrab
 
+  def dabrabyt_text_field_parse(stri)
+    button_url = ""
+    image = ""
+    button_text = ""
+    text = stri
+
+    #############
+    #0 - Text only
+    #1 - Text + Button
+    #2 - Text + Image + Button
+    #3 - image only
+    #############
+    scheme = 0
+    scheme_dic = {0 => "Text only", 1 => "Text+Button", 2 => "Text+Image+Button", 3 => "Image only"}
+    #############
+
+    output_answer = {}
+    sk_format = {}
+
+    begin
+
+      regexp_image1 = /(image:(\S+)[\s\n]?)/
+      button_url1 = /(button_url:(\S+)[\s\n]?)/
+      button_text1 = /(button_text:["']([^"]+)["'][\s\n])/
+
+      button_url_dat = stri.scan(button_url1)
+      button_text_dat = stri.scan(button_text1)
+      image_dat = stri.scan(regexp_image1)
+
+
+      p button_url_dat
+      p button_text_dat
+      p image_dat
+
+      begin
+        if button_url_dat != [] && button_url_dat != nil && button_url_dat != ""
+          button_url = button_url_dat[0][1]
+          text = text.gsub(button_url_dat[0][0], "")
+        end
+      rescue
+        nil
+      end
+
+      begin
+        if button_text_dat != [] && button_text_dat != nil && button_text_dat != ""
+          button_text = button_text_dat[0][1]
+          text = text.gsub(button_text_dat[0][0], "")
+        end
+      rescue
+        nil
+      end
+
+      begin
+        if image_dat != [] && image_dat != nil && image_dat != ""
+          image = image_dat[0][1]
+          text = text.gsub(image_dat[0][0], "")
+        end
+      rescue
+        nil
+      end
+      text = text.gsub(/\s+$/, '').gsub(/\n$/, '')
+
+
+      if button_url != "" && button_text != "" && image != "" #111
+        scheme = 2
+      elsif button_url != "" && button_text != "" && image == "" #110
+        scheme = 1
+      elsif button_url == "" && button_text == "" && image != "" #001
+        if text == ""
+          scheme = 3
+        else
+          scheme = 2
+          button_url = image
+          button_text = "Открыть"
+        end
+      elsif button_url != "" && button_text == "" && image != "" #101
+        scheme = 2
+        button_text = "Открыть"
+      elsif button_url == "" && button_text != "" && image != "" #011
+        scheme = 2
+        button_url = image
+      elsif button_url == "" && button_text != "" && image == "" #010
+        scheme = 0
+      elsif button_url != "" && button_text == "" && image == "" #100
+        button_text = "Открыть"
+        scheme = 1
+      else
+        scheme = 0
+      end
+
+      if scheme==0
+        sk_format = {"text": text, "ttl": 60}
+      elsif scheme==1
+        sk_format = {"text": text, "ttl": 60, "caption": button_text, "action": button_url}
+      elsif scheme==2
+        sk_format = {"text": text, "ttl": 60, "caption": button_text, "action": button_url, "img": image}
+      elsif scheme==3
+        sk_format = {"img": image, "ttl": 60}
+      else
+        nil
+      end
+
+      p sk_format
+
+      output_answer ={:code => 200, :result => "Success", :body => {:to_sk_format => sk_format, :button_url => button_url, :image => image, :button_text => button_text, :text => text, :scheme => scheme, :scheme_dic => scheme_dic[scheme]}}
+    rescue
+      output_answer ={:code => 507, :result => "dabrabyt_text_field_parse: Unknown error"}
+    end
+    output_answer
+  end
+
+
   def num_formatter(infobip_msisdn, extra_id)
     #[{"to"=>{"phoneNumber"=>"375297116638", "emailAddress"=>nil}}]
     # [{"phone_number": 375298766719}, {"phone_number": 375295730878}]
@@ -50,20 +162,20 @@ class Dabrab
       status1 = {}
       if a["processed"] == true && a["accepted"] == true
         status1 = {"to": {"phoneNumber": a["phone_number"]},
-              "status": {"groupId": 1,
-                         "groupName": "PENDING",
-                         "id": 26,
-                         "name": "MESSAGE_ACCEPTED",
-                         "description": "Message sent to next instance"},
-              "messageId": a["message_id"]}
+                   "status": {"groupId": 1,
+                              "groupName": "PENDING",
+                              "id": 26,
+                              "name": "MESSAGE_ACCEPTED",
+                              "description": "Message sent to next instance"},
+                   "messageId": a["message_id"]}
       else
         status1 = {"to": {"phoneNumber": a["phone_number"]},
-              "status": {"groupId": 5,
-                         "groupName": "REJECTED",
-                         "id": 21,
-                         "name": "REJECTED_SYSTEM_ERROR",
-                         "description": "Unknown error"},
-              "messageId": a["message_id"]}
+                   "status": {"groupId": 5,
+                              "groupName": "REJECTED",
+                              "id": 21,
+                              "name": "REJECTED_SYSTEM_ERROR",
+                              "description": "Unknown error"},
+                   "messageId": a["message_id"]}
       end
 
       messages_sect.append(status1)

data/lib/imperituroard/projects/ukaz60.rb

@@ -0,0 +1,140 @@
+$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
+          update_fortigate_ansible = forti_connector.update_weburl_fortimanager
+          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
+      p get_belgim_data
+
+      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,221 @@
+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
+      curl_belgie_command = "curl -d \"name=#{belgim_login}&pass=#{belgim_password}\" -H \"Content-Type: application/x-www-form-urlencoded\" -X POST #{belgim_url} --insecure"
+      #return_from_belgim = `curl -d "name=#{belgim_login}&pass=#{belgim_password}" -H "Content-Type: application/x-www-form-urlencoded" -X POST #{belgim_url} --insecure`
+      return_from_belgim = `#{curl_belgie_command}`
+      p curl_belgie_command
+
+      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