Skip to content

Instantly share code, notes, and snippets.

@madaarya

madaarya/report.rb

Last active January 21, 2020 16:04
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save madaarya/495d08edee519da15511a3f5abf0065b to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save madaarya/495d08edee519da15511a3f5abf0065b to your computer and use it in GitHub Desktop.
Download ZIP
Raw
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
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment