report.rb

class Report < ApplicationRecord
  has_ancestry
  serialize :account_type_data, Array
  serialize :total_calculation, Array
  serialize :meta_data, JSON
  serialize :outputs, JSON
  serialize :items, Array
  mount_uploader :attachment, PaymentReportUploader
  validates :attachment, presence: true
  before_create :set_default_value

  has_many :results, dependent: :destroy
  has_many :report_activities, dependent: :destroy
  has_many :expenses, dependent: :destroy
  has_many :decisions, dependent: :destroy
  has_many :report_documents, dependent: :destroy
  has_one :decision, dependent: :destroy
  has_many :receive_notifications, class_name: 'Notification', foreign_key: :notification_object_id 
  belongs_to :user
  belongs_to :budget_ceiling, optional: true

  accepts_nested_attributes_for :report_documents, reject_if: :all_blank, allow_destroy: true

  scope :approved, -> { joins(:decision).where('decisions.status = (?)', true) }
  scope :find_by_satker, -> (code) { where("(?) IN (SELECT value FROM OPENJSON(meta_data, '$.kdsatker'))", code.to_s) }
  validate :report_documents_existence

  # after_save :process_extract

  def generate_old_items
    file_info = Report.get_file_info_location(self.attachment.current_path)
    extract_target_dir = file_info[:extract_target_dir]
    number_xmlfilename = file_info[:number_xmlfilename]

    user = self.user
    group = user.group
    subdit = group.groupable_type.eql?("Admin") ? Subdit.find_by_name("Program dan Evaluasi") : group.groupable

    ditem_data = Report.load_data_expense(extract_target_dir, number_xmlfilename, 'd')

    if subdit.class.name != 'Province'
      if !user.has_role?(:admin) and !user.admin_proe?
        output_codes_only = subdit.subdit_outputs.map { |subdit_output| [subdit_output.output, subdit_output.sub_output] }
      else
        output_codes_only = []
      end

      if output_codes_only.present?
        ditem_data = ditem_data.select { |data| output_codes_only.include?([data[:kdoutput], data[:kdsoutput]]) }
      end
    end

    self.items = ditem_data
    self.save(validate: false)
  end

  def self.count_by_status
    unapproved = Report.joins(:decisions).where("decisions.status = (?) AND decisions.user_id IS NOT NULL", false).count
    approved = Report.joins(:decisions).where("decisions.status = (?) AND decisions.user_id IS NOT NULL", true).count
    pending = Decision.where(user_id: nil).count
    total = Report.count

    status_collection = [
      {status: 'pending', total: pending}, 
      {status: 'total', total: total},
      {status: 'unapproved', total: unapproved},
      {status: 'approved', total: approved} 
    ]
    status_collection
  end

  def self.collect_meta(data)
    kdsatker, kddept, kdunit, kdprogram, kdgiat = [], [], [], [], []
    data.each do |item|
      kdsatker << item[:kdsatker]
      kddept << item[:kddept]
      kdunit << item[:kdunit]
      kdprogram << item[:kdprogram]
      kdgiat << item[:kdgiat]
    end

    {kdsatker: kdsatker.uniq, kddept: kddept.uniq, kdunit: kdunit.uniq, kdprogram: kdprogram.uniq, kdgiat: kdgiat.uniq}
  end

  def self.find_by_account(collection, account)
    collection.select { |data| data[:kdakun].eql?(account) }.map{ |item| item[:jumlah].to_i }.sum 
  end

  def self.reports_by_group(obj, columns)
    begin
      class_name = obj.class.name
      class_id = obj.id
      Report.select(columns).joins(:user => :group).where("groups.groupable_type = (?) AND groups.groupable_id = (?)", class_name, class_id).by_year
    rescue
      Report.none
    end
  end

  def set_default_value
    self.budget_ceiling_id = BudgetCeiling.last.try(:id)
    self.status = "unapproved"
  end

  def total_became
    ExpenseBecame.where(report_id: self.id).sum(:total)
  end

  def generate_from_database
    result_data = Result.where(report_id: self.id)
    result_data.group_by{ |data| data.output.parent }.sort_by{ |k,v| k.code.to_i }
  end

  def generate_from_xml(page)
    user = self.user
    group = user.group
    if !user.has_role?(:admin) and !user.admin_proe?
      subdit = group.groupable
      if subdit.class.name.eql?('Province')
        output_codes_only = []
      else
        output_codes_only = subdit.subdit_outputs.map { |subdit_output| [subdit_output.output, subdit_output.sub_output] }
      end   
    end

    file_info = Report.get_file_info_location(self.attachment.current_path)
    extract_target_dir = file_info[:extract_target_dir]
    number_xmlfilename = file_info[:number_xmlfilename]

    ## Case SEMULA
    ## Load suboutput file
    msoutput_data = Report.load_data_output(extract_target_dir, number_xmlfilename, 'm')
    ## Load item file
    mitem_data = Report.load_data_expense(extract_target_dir, number_xmlfilename, 'm')
    
    ## Case MENJADI
    ## Load suboutput file
    dsoutput_data = Report.load_data_output(extract_target_dir, number_xmlfilename, 'd')
    ## Load item file
    ditem_data = Report.load_data_expense(extract_target_dir, number_xmlfilename, 'd')

    dsoutput_data_ids = dsoutput_data.map { |data| [data[:kdoutput], data[:kdsoutput]] }
    msoutput_data_ids = msoutput_data.map { |data| [data[:kdoutput], data[:kdsoutput]] }
    
    new_items = dsoutput_data_ids - msoutput_data_ids

    if new_items.present?
      new_items.each do |item|
        msoutput_data << dsoutput_data.select { |data| (data[:kdoutput] == item[0]) and (data[:kdsoutput] == item[1]) }.first
      end
    end

    if output_codes_only.present?
      msoutput_data = msoutput_data.select { |data| output_codes_only.include?([data[:kdoutput], data[:kdsoutput]]) }
      output_codes_only = subdit.subdit_outputs.map { |subdit_output| [subdit_output.output, subdit_output.sub_output, (subdit_output.components.split(",") rescue nil)] }
    end

    moutputs = msoutput_data.group_by { |k| k[:kdoutput] }
    moutputs.each do |output_code, sub_outputs|
      sub_outputs.uniq! { |sb| sb[:kdsoutput] }
      sub_outputs.each do |sub_output|
        sub_output[:became_obj] = dsoutput_data.detect { |data| (data[:kdoutput] == sub_output[:kdoutput]) and (data[:kdsoutput] == sub_output[:kdsoutput]) }
        
        dexpenses_data_arr = []
        ditem_data.each do |item|
          if output_codes_only.present?
            selected_output = output_codes_only.detect { |code| ((code[0] == item[:kdoutput]) and (item[:kdoutput] == sub_output[:kdoutput])) and ((code[1] == item[:kdsoutput]) and (item[:kdsoutput] == sub_output[:kdsoutput]) ) }

            if selected_output
              if selected_output[2].present?
                if selected_output[2].include? item[:kdkmpnen]
                  selected = true
                else
                  selected = false
                end
              else
                selected = true
              end
            else
              selected = false
            end

            if selected
              dexpenses_data_arr << item
            end
          else
            if(item[:kdoutput] == sub_output[:kdoutput]) and (item[:kdsoutput] == sub_output[:kdsoutput])
              dexpenses_data_arr << item
            end
          end
        end
        
        dexpenses_data = dexpenses_data_arr

        mexpenses_data_arr = []
        mitem_data.each do |item|
          if output_codes_only.present?
            selected_output = output_codes_only.detect { |code| ((code[0] == item[:kdoutput]) and (item[:kdoutput] == sub_output[:kdoutput])) and ((code[1] == item[:kdsoutput]) and (item[:kdsoutput] == sub_output[:kdsoutput]) ) }

            if selected_output
              if selected_output[2].present?
                if selected_output[2].include? item[:kdkmpnen]
                  selected = true
                else
                  selected = false
                end
              else
                selected = true
              end
            else
              selected = false
            end

            if selected
              mexpenses_data_arr << item
            end
          else
            if(item[:kdoutput] == sub_output[:kdoutput]) and (item[:kdsoutput] == sub_output[:kdsoutput])
              mexpenses_data_arr << item
            end
          end
        end

        mexpenses_data = mexpenses_data_arr

        sub_output[:expenses_previous] = mexpenses_data.map { |expense| expense[:jumlah].to_i }.sum
        sub_output[:expenses_became] = dexpenses_data.map { |expense| expense[:jumlah].to_i }.sum
      end
    end

    data_by_account = if page.to_i < 2
      self.account_type_data
    else
      []
    end
    
    {report: moutputs.sort_by{ |k,v| k.to_i }, by_account: data_by_account}
  end

  def generate_report_by_account_type
    file_info = Report.get_file_info_location(self.attachment.current_path)
    extract_target_dir = file_info[:extract_target_dir]
    number_xmlfilename = file_info[:number_xmlfilename]

    msoutput_data = Report.load_data_output(extract_target_dir, number_xmlfilename, 'm')
    dsoutput_data = Report.load_data_output(extract_target_dir, number_xmlfilename, 'd')

    ditem_data = Report.load_data_expense(extract_target_dir, number_xmlfilename, 'd')
    mitem_data = Report.load_data_expense(extract_target_dir, number_xmlfilename, 'm')

    dsoutput_data_ids = dsoutput_data.map { |data| [data[:kdoutput], data[:kdsoutput]] }
    msoutput_data_ids = msoutput_data.map { |data| [data[:kdoutput], data[:kdsoutput]] }
    
    new_items = dsoutput_data_ids - msoutput_data_ids

    if new_items.present?
      new_items.each do |item|
        msoutput_data << dsoutput_data.select { |data| (data[:kdoutput] == item[0]) and (data[:kdsoutput] == item[1]) }.first
      end
    end

    collection = Report.show_report_by_account_type(mitem_data, ditem_data, msoutput_data, false)

    data_accounts = []
    collection.each_with_index do |account_type, i|
      total_became = 0
      account_type_name = account_type.keys.first
      
      account_type.values.each do |account_type_item|
        account_type_item.each do |code|
          value_item = code.values.first
          became_value = value_item[:became]; 
          total_became += became_value if became_value > 0
        end
      end

      unless total_became.zero?
        data_accounts << {name: account_type_name, value: total_became}
      end
    end

    data_accounts
  end

  def self.account_type_lastest_by_subdit(collection)
    group_by_subdit = collection.group_by { |data| data.user.group.groupable }
    data_by_subdit = group_by_subdit.map { |subdit, reports| [subdit.name, reports] }
    data_by_month = data_by_subdit.map { |arr| [arr[0], Report.report_per_account_type_by_month(arr[1].group_by_month { |u| u.created_at })] }
  end

  def self.report_per_account_type_by_month(collection)
    # puts collection
    collection.map { |k, v| [k.month, v.sort_by { |data| data.created_at }.last.generate_report_by_account_type] }
  end

  def self.show_report_by_account_type(mitem_data, ditem_data, msoutput_data, validation_mode = false)
    total = ditem_data.map { |item| item[:jumlah].to_i }.sum
    msoutput_data_outputs = msoutput_data.map { |data| [data[:kdoutput], data[:kdsoutput]] }
    category_total = []
    main_collection = AccountType.get_report_by_account_column.dup
    main_collection.each do |account_types_item|
      account_types_item.each do |account_type, codes|
        total_became = 0
        codes.each do |code|
          key_name = code.keys.first
          ditem_selected = ditem_data.select { |data| (data[:kdakun] == key_name) and msoutput_data_outputs.include?([data[:kdoutput], data[:kdsoutput]]) }
          code[key_name][:became] = ditem_selected.map { |item| item[:jumlah].to_i }.sum
          total_became += code[key_name][:became]

          unless validation_mode
            mitem_selected = mitem_data.select { |data| data[:kdakun] == key_name and msoutput_data_outputs.include?([data[:kdoutput], data[:kdsoutput]]) }
            code[key_name][:previous] = mitem_selected.map { |item| item[:jumlah].to_i }.sum
          end
        end

        category_total << {name: account_types_item.keys.first, total_became: total_became}
      end
    end

    {total: category_total, collection: main_collection, grand_total: total, msoutput_data_outputs: msoutput_data_outputs}
  end

  def self.load_components_db(resultid)
    result_components = ResultComponent.where(result_id: resultid, ancestry: nil)
    result_components.sort_by { |rk| rk.component.code.to_i }
  end

  def self.load_sub_components_db(result_component)
    result_components = result_component.children
    result_components.sort_by { |rk| rk.component.code.to_i }
  end

  def load_all_components(output_codes_only = [])
    file_info = Report.get_file_info_location(self.attachment.current_path)
    extract_target_dir = file_info[:extract_target_dir]
    number_xmlfilename = file_info[:number_xmlfilename]
    ## Case SEMULA
    ## Load component file
    mkmpnen_data = Report.load_data_component(extract_target_dir, number_xmlfilename, 'm')    
    ## Case MENJADI
    ## Load component file
    dkmpnen_data = Report.load_data_component(extract_target_dir, number_xmlfilename, 'd')

    mkmpnen_data_ids = mkmpnen_data.map { |data| [data[:kdoutput], data[:kdsoutput], data[:kdkmpnen]] }
    dkmpnen_data_ids = dkmpnen_data.map { |data| [data[:kdoutput], data[:kdsoutput], data[:kdkmpnen]] }
    
    new_items = dkmpnen_data_ids - mkmpnen_data_ids

    if new_items.present?
      new_items.each do |item| 
        mkmpnen_data << dkmpnen_data.select { |data| (data[:kdoutput] == item[0]) and (data[:kdsoutput] == item[1]) and (item[2] == data[:kdkmpnen]) }.first
      end
    end

    # if output_codes_only.present?
    #   mkmpnen_data = mkmpnen_data.select { |data| output_codes_only.include?([data[:kdoutput], data[:kdsoutput]]) }
    # end

    if output_codes_only.present?
      new_arr = []
      mkmpnen_data.each do |data| 
        selected_output = output_codes_only.detect { |code| code[0] == data[:kdoutput] and code[1] == data[:kdsoutput] }

        if selected_output
          if selected_output[2].present?
            if selected_output[2].include? data[:kdkmpnen]
              selected = true
            else
              selected = false
            end
          else
            selected = true
          end
        else
          selected = false
        end

        if selected
          new_arr << data
        end
      end

      mkmpnen_data = new_arr
    end

    {mkmpnen_data: mkmpnen_data}
  end

  def load_components(kdoutput, kdsoutput)
    file_info = Report.get_file_info_location(self.attachment.current_path)
    extract_target_dir = file_info[:extract_target_dir]
    number_xmlfilename = file_info[:number_xmlfilename]
    ## Case SEMULA
    ## Load component file
    mkmpnen_data = Report.load_data_component(extract_target_dir, number_xmlfilename, 'm')
    ## Load item file
    mitem_data = Report.load_data_expense(extract_target_dir, number_xmlfilename, 'm')
    
    ## Case MENJADI
    ## Load component file
    dkmpnen_data = Report.load_data_component(extract_target_dir, number_xmlfilename, 'd')
    ## Load item file
    ditem_data = Report.load_data_expense(extract_target_dir, number_xmlfilename, 'd')

    mkmpnen_data_ids = mkmpnen_data.map { |data| [data[:kdoutput], data[:kdsoutput], data[:kdkmpnen]] }
    dkmpnen_data_ids = dkmpnen_data.map { |data| [data[:kdoutput], data[:kdsoutput], data[:kdkmpnen]] }
    
    new_items = dkmpnen_data_ids - mkmpnen_data_ids

    if new_items.present?
      new_items.each do |item| 
        mkmpnen_data << dkmpnen_data.select { |data| (data[:kdoutput] == item[0]) and (data[:kdsoutput] == item[1]) and (item[2] == data[:kdkmpnen]) }.first
      end
    end

    components = mkmpnen_data.select { |kmpnen| (kmpnen[:kdoutput] == kdoutput) and (kmpnen[:kdsoutput] == kdsoutput) }
    components.each do |component|
      component[:expenses_previous] = mitem_data.select { |item| (item[:kdoutput] == kdoutput) and (item[:kdsoutput] == kdsoutput) and (item[:kdkmpnen] == component[:kdkmpnen])  }.map { |expense| expense[:jumlah].to_i }.sum
      component[:expenses_became] = ditem_data.select { |item| (item[:kdoutput] == kdoutput) and (item[:kdsoutput] == kdsoutput) and (item[:kdkmpnen] == component[:kdkmpnen])  }.map { |expense| expense[:jumlah].to_i }.sum
    end
    components.sort_by { |component| component[:kdkmpnen].to_i }
  end

  def load_all_sub_component(output_codes_only = [])
    file_info = Report.get_file_info_location(self.attachment.current_path)
    extract_target_dir = file_info[:extract_target_dir]
    number_xmlfilename = file_info[:number_xmlfilename]
    ## Case SEMULA
    ## Load sub component file
    mskmpnen_data = Report.load_data_sub_component(extract_target_dir, number_xmlfilename, 'm')   
    ## Case MENJADI
    ## Load sub component file
    dskmpnen_data = Report.load_data_sub_component(extract_target_dir, number_xmlfilename, 'd')

    mskmpnen_data_ids = mskmpnen_data.map { |data| [data[:kdoutput], data[:kdsoutput], data[:kdkmpnen], data[:kdskmpnen]] }
    dskmpnen_data_ids = dskmpnen_data.map { |data| [data[:kdoutput], data[:kdsoutput], data[:kdkmpnen], data[:kdskmpnen]] }
    
    new_items = dskmpnen_data_ids - mskmpnen_data_ids

    if new_items.present?
      new_items.each do |item| 
        mskmpnen_data << dskmpnen_data.select { |data| (data[:kdoutput] == item[0]) and (data[:kdsoutput] == item[1]) and (item[2] == data[:kdkmpnen]) and (item[3] == data[:kdskmpnen]) }.first
      end
    end

    if output_codes_only.present?
      # mskmpnen_data = mskmpnen_data.select { |data| output_codes_only.include?([data[:kdoutput], data[:kdsoutput]]) }
      new_mskmpnen_data = []

      mskmpnen_data.each do |data| 
        selected_output = output_codes_only.detect { |code| code[0] == data[:kdoutput] and code[1] == data[:kdsoutput] }

        if selected_output
          if selected_output[2].present?
            if selected_output[2].include? data[:kdkmpnen]
              selected = true
            else
              selected = false
            end
          else
            selected = true
          end
        else
          selected = false
        end

        if selected
          new_mskmpnen_data << data
        end
      end

      mskmpnen_data = new_mskmpnen_data

    end

    {mskmpnen_data: mskmpnen_data}
  end

  def load_all_expenses(output_codes_only = [])
    file_info = Report.get_file_info_location(self.attachment.current_path)
    extract_target_dir = file_info[:extract_target_dir]
    number_xmlfilename = file_info[:number_xmlfilename]

    mitem_data = Report.load_data_expense(extract_target_dir, number_xmlfilename, 'm')
    ## Load item file
    ditem_data = Report.load_data_expense(extract_target_dir, number_xmlfilename, 'd')

    if output_codes_only.present?
      new_mitem_data = []
      new_ditem_data = []
      # mitem_data = mitem_data.select { |data| output_codes_only.include?([data[:kdoutput], data[:kdsoutput]]) }
      
      mitem_data.each do |data| 
        selected_output = output_codes_only.detect { |code| code[0] == data[:kdoutput] and code[1] == data[:kdsoutput] }

        if selected_output
          if selected_output[2].present?
            if selected_output[2].include? data[:kdkmpnen]
              selected = true
            else
              selected = false
            end
          else
            selected = true
          end
        else
          selected = false
        end

        if selected
          new_mitem_data << data
        end
      end

      mitem_data = new_mitem_data

      ditem_data.each do |data| 
        selected_output = output_codes_only.detect { |code| code[0] == data[:kdoutput] and code[1] == data[:kdsoutput] }

        if selected_output
          if selected_output[2].present?
            if selected_output[2].include? data[:kdkmpnen]
              selected = true
            else
              selected = false
            end
          else
            selected = true
          end
        else
          selected = false
        end

        if selected
          new_ditem_data << data
        end
      end

      ditem_data = new_ditem_data

      # ditem_data = ditem_data.select { |data| output_codes_only.include?([data[:kdoutput], data[:kdsoutput]]) }
    end

    {mitem_data: mitem_data, ditem_data: ditem_data}
  end

  def load_sub_component(kdoutput, kdsoutput, kdkmpnen)
    file_info = Report.get_file_info_location(self.attachment.current_path)
    extract_target_dir = file_info[:extract_target_dir]
    number_xmlfilename = file_info[:number_xmlfilename]
    ## Case SEMULA
    ## Load sub component file
    mskmpnen_data = Report.load_data_sub_component(extract_target_dir, number_xmlfilename, 'm')
    ## Load item file
    mitem_data = Report.load_data_expense(extract_target_dir, number_xmlfilename, 'm')
    
    ## Case MENJADI
    ## Load sub component file
    dskmpnen_data = Report.load_data_sub_component(extract_target_dir, number_xmlfilename, 'd')
    ## Load item file
    ditem_data = Report.load_data_expense(extract_target_dir, number_xmlfilename, 'd')

    mskmpnen_data_ids = mskmpnen_data.map { |data| [data[:kdoutput], data[:kdsoutput], data[:kdkmpnen], data[:kdskmpnen]] }
    dskmpnen_data_ids = dskmpnen_data.map { |data| [data[:kdoutput], data[:kdsoutput], data[:kdkmpnen], data[:kdskmpnen]] }
    
    new_items = dskmpnen_data_ids - mskmpnen_data_ids

    if new_items.present?
      new_items.each do |item| 
        mskmpnen_data << dskmpnen_data.select { |data| (data[:kdoutput] == item[0]) and (data[:kdsoutput] == item[1]) and (item[2] == data[:kdkmpnen]) and (item[3] == data[:kdskmpnen]) }.first
      end
    end

    sub_components = mskmpnen_data.select { |sub_kmpnen| (sub_kmpnen[:kdoutput] == kdoutput) and (sub_kmpnen[:kdsoutput] == kdsoutput) and (sub_kmpnen[:kdkmpnen] == kdkmpnen) }
    sub_components.each do |sub_component|
      sub_component[:expenses] =  mitem_data.select { |item| (item[:kdoutput] == kdoutput) and (item[:kdsoutput] == kdsoutput) and (item[:kdkmpnen] == kdkmpnen) and (item[:kdskmpnen] == sub_component[:kdskmpnen])  }
      sub_component[:expenses].each do |expense|
        expense[:expenses_became] = ditem_data.detect { |item| (item[:noitem] == expense[:noitem]) and (item[:kdoutput] == expense[:kdoutput]) and (item[:kdsoutput] == expense[:kdsoutput]) and (item[:kdkmpnen] == expense[:kdkmpnen]) and (item[:kdskmpnen] == expense[:kdskmpnen])  }
      end
    end

    sub_components.sort_by { |sub_component| sub_component[:kdskmpnen] }
  end

  def get_all_account_code
    expenses.map(&:account_code).uniq
  end

  def grand_total
    self.total_calculation.map { |item| item['total_became'] }.sum
  end

  def compare_with_report_prev
    unless self.root?
      report_prev = self.parent

      file_info_current = Report.get_file_info_location(self.attachment.current_path)
      extract_target_dir_current = file_info_current[:extract_target_dir]
      number_xmlfilename_current = file_info_current[:number_xmlfilename]

      ditem_data_current = Report.load_data_expense(extract_target_dir_current, number_xmlfilename_current, 'd')

      file_info_prev = Report.get_file_info_location(report_prev.attachment.current_path)
      extract_target_dir_prev = file_info_prev[:extract_target_dir]
      number_xmlfilename_prev = file_info_prev[:number_xmlfilename]

      ditem_data_prev = Report.load_data_expense(extract_target_dir_prev, number_xmlfilename_prev, 'd')

      ditem_data_current_ids = ditem_data_current.map { |data| [data[:kdoutput], data[:kdsoutput], data[:kdkmpnen], data[:kdskmpnen], data[:kdakun], data[:nmitem] ] }  
      ditem_data_prev_ids = ditem_data_prev.map { |data| [data[:kdoutput], data[:kdsoutput], data[:kdkmpnen], data[:kdskmpnen], data[:kdakun], data[:nmitem] ] }  

      new_items = ditem_data_current_ids - ditem_data_prev_ids

      collection = ditem_data_prev
      collection_updates = []

      if new_items.present?
        new_items.each do |item| 
          collection << ditem_data_current.detect { |data| (data[:kdoutput] == item[0]) and 
            (data[:kdsoutput] == item[1]) and 
            (item[2] == data[:kdkmpnen]) and 
            (item[3] == data[:kdskmpnen]) and 
            (item[4] == data[:kdakun]) and 
            (item[5] == data[:nmitem]) }
        end
      end

      collection.each do |item|
        item[:prev] = ditem_data_prev.detect { |data| (data[:kdoutput] == item[:kdoutput]) and 
            (data[:kdsoutput] == item[:kdsoutput]) and 
            (item[:kdkmpnen] == data[:kdkmpnen]) and 
            (item[:kdskmpnen] == data[:kdskmpnen]) and 
            (item[:kdakun] == data[:kdakun]) and 
            (item[:nmitem] == data[:nmitem]) }
        item[:became] = ditem_data_current.detect { |data| (data[:kdoutput] == item[:kdoutput]) and 
            (data[:kdsoutput] == item[:kdsoutput]) and 
            (item[:kdkmpnen] == data[:kdkmpnen]) and 
            (item[:kdskmpnen] == data[:kdskmpnen]) and 
            (item[:kdakun] == data[:kdakun]) and 
            (item[:nmitem] == data[:nmitem]) }
      end

      collection.each do |item|
        begin
          if item[:became][:jumlah] != item[:prev][:jumlah]
            collection_updates << item
          end
        rescue Exception => e
          collection_updates << item
          puts item
        end
      end

      puts "collection_updates size : #{collection_updates.size}"
      # puts collection_updates
    end
  end

  def self.load_file_to_xml(file)
    data_xml = File.open(file)
    Ox.load(data_xml.read, mode: :hash)
  end

  def self.load_data_output(extract_target_dir, number_xmlfilename, type)
    dsoutput_file = extract_target_dir + "/#{type}_soutput#{number_xmlfilename}.XML"
    dsoutput_data = Report.load_file_to_xml(dsoutput_file)
    dsoutput_data[:VFPData].delete_if { |k| !k[:c_soutput].present?  }.map{ |k| k.values }.flatten.delete_if { |k| k[:kdgiat] != '5628' }
  end

  def self.load_data_component(extract_target_dir, number_xmlfilename, type)
    dkmpnen_file = extract_target_dir + "/#{type}_kmpnen#{number_xmlfilename}.XML"
    dkmpnen_data = Report.load_file_to_xml(dkmpnen_file)
    dkmpnen_data[:VFPData].delete_if { |k| !k[:c_kmpnen].present?  }.map{ |k| k.values }.flatten.delete_if { |k| k[:kdgiat] != '5628' }
  end

  def self.load_data_sub_component(extract_target_dir, number_xmlfilename, type)
    dskmpnen_file = extract_target_dir + "/#{type}_skmpnen#{number_xmlfilename}.XML"
    dskmpnen_data = Report.load_file_to_xml(dskmpnen_file)
    dskmpnen_data[:VFPData].delete_if { |k| !k[:c_skmpnen].present?  }.map{ |k| k.values }.flatten.delete_if { |k| k[:kdgiat] != '5628' }
  end

  def self.load_data_expense(extract_target_dir, number_xmlfilename, type)
    ditem_file = extract_target_dir + "/#{type}_item#{number_xmlfilename}.XML"
    ditem_data = Report.load_file_to_xml(ditem_file)
    ditem_data[:VFPData].delete_if { |k| !k[:c_item].present?  }.map{ |k| k.values }.flatten.delete_if { |k| k[:kdgiat] != '5628' }
  end


  def self.get_file_info_location(file_path)
    filename = File.basename(file_path, File.extname(file_path))
    number_xmlfilename = filename.split('_')[1..-1].join("")
    extract_target_dir = File.dirname(file_path) + "/#{filename}"

    return {extract_target_dir: extract_target_dir, number_xmlfilename: number_xmlfilename}
  end


  private

  def report_documents_existence
    unless user.group.groupable_type.eql?("Admin")
      report_document_types = ReportDocumentType.where(required: true)
      report_document_types.each do |report_document_type|
        report_documents.select {|report_document| report_document.report_document_type_id.eql?(report_document_type.id) }.each do |report_document|
          errors.add(report_document_type.name.to_sym, "tidak boleh kosong") unless report_document.attachment.present?
        end
      end
    end
  end

  def process_extract
    response = ExtractDataFile.process_file(attachment.current_path, id)
    unless response[:stderr_str].blank?
      errors.add(:attachment, "format file tidak sesuai")
      raise ActiveRecord::RecordInvalid.new(self)
    end
  end

end