class AddFuncUkaz60_2

# File lib/imperituroard/projects/ukaz60/ukaz60_add_func.rb, line 8
def initialize
  @add_functions = LogAddFunctions_2.new
end

# File lib/imperituroard/projects/ukaz60/ukaz60_add_func.rb, line 116
def ansible_answer_parse(answer_string)
  input_data = {:answer_string => answer_string}
  output_data = {}

  begin
    answ_ans_parsed = answer_string.gsub("\n", " ")
    result_out = {}
    #result_out = []
    num_ok = 0
    num_failed = 0
    final_checks = /(\S+)\s+:\s+ok=(\d)\s+changed=(\d)\s+unreachable=(\d)\s+failed=(\d)\s+skipped=(\d)\s+rescued=(\d)\s+ignored=(\d)\s+/

    processed_data = answ_ans_parsed.scan(final_checks)
    if processed_data!=[] && processed_data!=""
      for aaa in processed_data
        begin
          if aaa[1].to_i>0 && aaa[3].to_i==0 && aaa[4].to_i==0 && aaa[5].to_i==0 && aaa[6].to_i==0 && aaa[7].to_i==0
            result_out[aaa[0]] = "Ok"
            #result_out.push({aaa[0] => "Ok"})
            num_ok = num_ok + 1
          else
            result_out[aaa[0]] = 'Failed'
            #result_out.push({aaa[0] => "Failed"})
            num_failed = num_failed + 1
          end
        rescue
          result_out['unknown'] = aaa.to_s
          #result_out.push({"unknown" => aaa.to_s})
          num_failed = num_failed + 1
        end
      end
      output_data = {:code => 200, :result => "ansible_answer_parse: Request completed successfully", :body => {:list => result_out, :num_ok => num_ok, :num_failed => num_failed}}
    else
      output_data = {:code => 400, :result => "ansible_answer_parse: Ansible returned empty data"}
    end
  rescue
    output_data = {:code => 507, :result => "ansible_answer_parse: Unknown error"}
  end
  add_functions.printer_texter(output_data, "debug")
  output_data
end

# File lib/imperituroard/projects/ukaz60/ukaz60_add_func.rb, line 159
def ansible_answer_parse_fmg(answer_string)
  input_data = {:answer_string => answer_string}
  output_data = {}

  begin
    answ_ans_parsed = answer_string.gsub("\n", " ")
    result_out = {}
    #result_out = []
    num_ok = 0
    num_failed = 0
    #final_checks = /(fortimanager1)\s+:\s+ok=(\d)\s+changed=(\d)\s+unreachable=(\d)\s+failed=(\d)\s+/
    final_checks = /(fortimanager1)\s+:\s+ok=(\d+)\s+changed=(\d+)\s+unreachable=(\d+)\s+failed=(\d+)\s+/

    #p answ_ans_parsed
    processed_data = answ_ans_parsed.scan(final_checks)
    #p processed_data
    if processed_data!=[] && processed_data!=""
      for aaa in processed_data
        begin
          if aaa[1].to_i>0 && aaa[3].to_i==0 && aaa[4].to_i==0
            result_out[aaa[0]] = {:ok => aaa[1], :changed => aaa[2], :unreachable => aaa[3], :failed => aaa[4], :result => "Ok"}
            #result_out.push({aaa[0] => "Ok"})
            num_ok = num_ok + 1
          else
            result_out[aaa[0]] = {:ok => aaa[1], :unreachable => aaa[3], :failed => aaa[4], :result => "Failed"}
            #result_out.push({aaa[0] => "Failed"})
            num_failed = num_failed + 1
          end
        rescue
          result_out["unknown"] = aaa.to_s
          #result_out.push({"unknown" => aaa.to_s})
          num_failed = num_failed + 1
        end
      end
      output_data = {:code => 200, :result => "ansible_answer_parse: Request completed successfully", :body => {:list => result_out, :num_ok => num_ok, :num_failed => num_failed}}
    else
      output_data = {:code => 400, :result => "ansible_answer_parse: Ansible returned empty data"}
    end
  rescue
    output_data = {:code => 507, :result => "ansible_answer_parse: Unknown error"}
  end
  add_functions.printer_texter(output_data, "debug")
  output_data
end

# File lib/imperituroard/projects/ukaz60/ukaz60_add_func.rb, line 218
def array_hash_compare(array1, array2)
  diff = []
  array2.each do |h1|
    if array1.include?(h1)
      nil
    else
      diff.push(h1)
    end
  end
  diff
end

# File lib/imperituroard/projects/ukaz60/ukaz60_add_func.rb, line 14
def delete_dump_symbols_url(stroka)
  input_params = {:stroka => stroka}
  output_answer = {}
  processed_domain_in_url = ""
  protocol = ""
  type = ""
  domain_only = ""
  begin

    #p "Step1 stroka: #{stroka}"

    first_url = stroka.gsub("</", "")

    if first_url != "-" && first_url != ""

      #check web protocol (http/https/unknown)
      if stroka.include? "http:"
        protocol = "http"
      elsif stroka.include? "https:"
        protocol = "https"
      else
        protocol = "unknown"
        p "ERROR: delete_dump_symbols_url.unknown protocol"
      end

      if first_url.include? "http://"
        processed_domain_in_url = first_url.gsub("http://", "")
      else
        processed_domain_in_url = processed_domain_in_url + first_url
      end

      if processed_domain_in_url.include? "http:///"
        processed_domain_in_url.gsub!("http:///", "")
      end

      if processed_domain_in_url.include? "http:/"
        processed_domain_in_url.gsub!("http:/", "")
      end

      if processed_domain_in_url.include? "https://"
        processed_domain_in_url.gsub!("https://", "")
      end

      if processed_domain_in_url.include? "https:/"
        processed_domain_in_url.gsub!("https:/", "")
      end

      if processed_domain_in_url.include? " "
        processed_domain_in_url = processed_domain_in_url.gsub!(" ", "")
      end

      #delete / at the end
      if processed_domain_in_url[processed_domain_in_url.size-1]=="/"
        sss = processed_domain_in_url.size
        processed_domain_in_url = processed_domain_in_url[0..sss-2]
      end

      #p "Step2 processed_domain_in_url: #{processed_domain_in_url}"

      if processed_domain_in_url != "-" && processed_domain_in_url != "" && processed_domain_in_url != nil
        #p "Step3 processed_domain_in_url: #{processed_domain_in_url}"
        #if include / then it is url. Else - domain
        if !processed_domain_in_url.include? "/"
          #it is domain. Process domain
          #if it is kirillica then process
          #if processed_domain_in_url.match(/а|б|в|г|д|е|ж|ё|Ё|з|и|й|к|л|м|н|о|п|р|с|т|у|ф|х|ц|ч|ш|щ|ь|ы|ъ|э|ю|я|А|Б|В|Г|Д|Е|Ж|З|И|Й|К|Л|М|Н|О|П|Р|С|Т|У|Ф|Х|Ц|Ч|Ш|Щ|Ь|Ы|Ъ|Э|Ю|Я/)
          if processed_domain_in_url.match(/[а-яА-ЯЁё]/)
            processed_domain_in_url = SimpleIDN.to_ascii(processed_domain_in_url)
          end
          domain_only = domain_only + processed_domain_in_url
          type = 'domain'
        else
          #it is url. process url
          hh = processed_domain_in_url.split('/')
          domain_only = hh[0]
          #if domain_only.match(/а|б|в|г|д|е|ж|ё|Ё|з|и|й|к|л|м|н|о|п|р|с|т|у|ф|х|ц|ч|ш|щ|ь|ы|ъ|э|ю|я|А|Б|В|Г|Д|Е|Ж|З|И|Й|К|Л|М|Н|О|П|Р|С|Т|У|Ф|Х|Ц|Ч|Ш|Щ|Ь|Ы|Ъ|Э|Ю|Я/)
          if domain_only.match(/[а-яА-ЯЁё]/)
            hh[0] = SimpleIDN.to_ascii(domain_only)
            processed_domain_in_url = ''
            for t in hh
              processed_domain_in_url = processed_domain_in_url + t + '/'
            end
            sss1len = processed_domain_in_url.size
            processed_domain_in_url = processed_domain_in_url[0..sss1len-2]
          end
          type = 'url'
        end
      else
        type = 'empty'
      end
      output_answer = {:code => 200, :result => 'Request processed', :ishodnye_dannye => stroka, :first_url => first_url, :processed_domain_in_url => processed_domain_in_url, :domain_only => domain_only, :protocol => protocol, :type => type}

    else
      output_answer = {:code => 202, :result => 'Data not found'}
    end
  rescue
    output_answer = {:code => 507, :result => 'Something wrong'}
  end
  output_answer
end

# File lib/imperituroard/projects/ukaz60/ukaz60_add_func.rb, line 313
def format_star_processed_answ(data)
  answ_out = {:body => {:to_message => {:code => 200, :result => "Staros processed", :data => {:block_me => {}, :unblock_me=> {}}}, :config => {}}}
  compa_n = 0
  compa_n_data = ""
  flag = 0
  notbl_equal = 0
  data[:body][:for_block][:notblocked_stat].each do |blo_for|
    if flag == 0
      compa_n = blo_for[1]
      compa_n_data = blo_for[0]
    end
    if compa_n == blo_for[1]
      nil
    else
      notbl_equal = 1
    end
  end

  #p notbl_equal
  if notbl_equal == 0
    block_me = {:for_block_count => data[:body][:for_block][:notblocked_stat][compa_n_data]}
    unblock_me = {:for_unblock_count => data[:body][:for_unblock][:for_unblock_stat][compa_n_data]}

    if block_me[:for_block_count] != 0 && unblock_me[:for_unblock_count] != 0
      answ_out[:body][:to_message][:code] = 202
      answ_out[:body][:to_message][:result] = "Something not actual"
    else
      answ_out[:body][:to_message][:code] = 200
      answ_out[:body][:to_message][:result] = "Staros processed"
    end

    answ_out[:body][:to_message][:data][:block_me]= block_me
    answ_out[:body][:to_message][:data][:unblock_me]= unblock_me
  else
    answ_out[:body][:to_message][:data][:block_me] = data[:body][:for_block][:notblocked_stat]
    answ_out[:body][:to_message][:data][:unblock_me] = data[:body][:for_unblock][:for_unblock_stat]
  end

  answ_out
end

# File lib/imperituroard/projects/ukaz60/ukaz60_add_func.rb, line 211
def http_to_forti_prep(domain)
  domain.gsub("#", "")
end

# File lib/imperituroard/projects/ukaz60/ukaz60_add_func.rb, line 205
def https_to_forti_prep(domain)
  f0 = domain.gsub("#", "")
  f1 = f0.gsub("https://", "").split("/")
  f1[0]
end

# File lib/imperituroard/projects/ukaz60/ukaz60_add_func.rb, line 232
def staros_compare_http(data_staros, data_belgim)

  notblocked_stat = {}
  alert_unprotected = {}
  alert_unprotected_out = {}
  output_answ = {:body => {:for_block => {}, :for_unblock => {}}}
  for_unblock_tmp = {}
  for_unblock = {}
  for_unblock_stat = {}


  begin
    #only for one ECS instance
    data_staros[:mpc_data].each do |star_host|
      alert_unprotected[star_host[:hostname]] = []
      for_unblock_tmp[star_host[:hostname]] = []

      #check if belgim http url is blocked on STAROS
      data_belgim[:url_all].each do |belg_url|
        blocked = 0
        star_host[:body][:blocked_urls_http].each do |star_dom|
          star_url_curr = star_dom[:url]
          star_dom_len = star_url_curr.length
          star_dom_x = ""
          if star_url_curr[star_dom_len - 1] == "/"
            star_dom_x = star_url_curr[0..star_dom_len - 2]
          else
            star_dom_x = star_url_curr
          end
          if belg_url.include?(star_dom_x) || belg_url.include?(URI.decode(star_dom_x))
            blocked = 1
            for_unblock_tmp[star_host[:hostname]].push(star_dom)
          end
        end
        if blocked == 0
          alert_unprotected[star_host[:hostname]].push(belg_url)
        end
      end
    end

    alert_unprotected.each do |proc_unpro|
      da123 = proc_unpro[1]
      alert_unprotected_out[proc_unpro[0]] = da123.uniq
      notblocked_stat[proc_unpro[0]] = proc_unpro[1].length
    end

    for_unblock_tmp.each do |tmp_unbl|
      hostname_st = tmp_unbl[0]
      host_data_tmp = tmp_unbl[1].uniq
      staros_all = data_staros[:add_format][hostname_st][:blocked_urls_http].uniq
      da_annn = self.array_hash_compare(host_data_tmp, staros_all)
      for_unblock[hostname_st] = da_annn.uniq
      for_unblock_stat[hostname_st] = da_annn.uniq.length
    end

    output_answ[:code] = 200
    output_answ[:result] = "Success"
    output_answ[:body][:for_block][:notblocked_stat] = notblocked_stat
    output_answ[:body][:for_block][:not_blocked_belgim] = alert_unprotected_out
    output_answ[:body][:for_unblock][:for_unblock] = for_unblock
    output_answ[:body][:for_unblock][:for_unblock_stat] = for_unblock_stat

  rescue
    output_answ = {:code => 507, :result => "staros_compare_http: Unknown SDK error"}
  end

  #p JSON.pretty_generate(output_answ)
  #p "staros_compare_http"
  #p output_answ

  #p "temp data"
  for i in output_answ[:body][:for_unblock][:for_unblock]["vit11asr2"]
  #for i in output_answ[:body][:for_block][:not_blocked_belgim]["vit11asr2"]
    p i
  end
  output_answ
end