scinote-web/app/jobs/team_zip_export_job.rb

292 lines
9.3 KiB
Ruby
Raw Normal View History

# frozen_string_literal: true
require 'fileutils'
require 'csv'
require 'vips'
class TeamZipExportJob < ZipExportJob
include StringUtility
private
# Override
def zip_name
"projects_export_#{Time.now.utc.strftime('%F_%H-%M-%S_UTC')}.zip"
end
# Override
def fill_content(dir, params)
# Create team folder
@team = Team.find(params[:team_id])
projects = @team.projects.where(id: params[:project_ids])
team_path = "#{dir}/#{to_filesystem_name(@team.name)}"
FileUtils.mkdir_p(team_path)
# Iterate through every project
p_idx = p_archive_idx = 0
projects.each do |project|
idx = project.archived ? (p_archive_idx += 1) : (p_idx += 1)
project_path = make_model_dir(team_path, project, idx)
project_name = project_path.split('/')[-1]
obj_filenames = { repositories: {}, assets: {}, tables: {} }
# Change current dir for correct generation of relative links
Dir.chdir(project_path)
project_path = '.'
inventories = "#{project_path}/Inventories"
FileUtils.mkdir_p(inventories)
repositories = project.assigned_repositories_and_snapshots
# Iterate through every inventory repo and save it to CSV
repositories.each_with_index do |repo, repo_idx|
next if obj_filenames[:repositories][repo.id].present?
obj_filenames[:repositories][repo.id] = {
file: save_inventories_to_csv(inventories, repo, repo_idx)
}
end
# Include all experiments
ex_idx = ex_archive_idx = 0
project.experiments.each do |experiment|
idx = experiment.archived ? (ex_archive_idx += 1) : (ex_idx += 1)
experiment_path = make_model_dir(project_path, experiment, idx)
# Include all modules
mod_pos = mod_archive_pos = 0
experiment.my_modules.order(:workflow_order).each do |my_module|
pos = my_module.archived ? (mod_archive_pos += 1) : (mod_pos += 1)
my_module_path = make_model_dir(experiment_path, my_module, pos)
# Create upper directories for both elements
protocol_path = "#{my_module_path}/Protocol attachments"
result_path = "#{my_module_path}/Result attachments"
FileUtils.mkdir_p(protocol_path)
FileUtils.mkdir_p(result_path)
# Export protocols
steps = my_module.protocols.map(&:steps).flatten
obj_filenames[:assets].merge!(
export_assets(StepAsset.where(step: steps), :step, protocol_path)
)
obj_filenames[:tables].merge!(
export_tables(StepTable.where(step: steps), :step, protocol_path)
)
# Export results
[false, true].each do |archived|
obj_filenames[:assets].merge!(
export_assets(
ResultAsset.where(result: my_module.results.where(archived: archived)),
:result,
result_path,
archived
)
)
end
[false, true].each do |archived|
obj_filenames[:tables].merge!(
export_tables(
ResultTable.where(result: my_module.results.where(archived: archived)),
:result,
result_path,
archived
)
)
end
end
end
# Generate and export whole project report HTML
html_name = "#{project_name} Report.html"
project_report_pdf = project.generate_teams_export_report_html(
@user, @team, html_name, obj_filenames
)
File.binwrite("#{project_path}/#{html_name}", project_report_pdf)
end
ensure
# Change current dir outside dir, since it will be deleted
Dir.chdir(Rails.root)
end
# Create directory for project, experiment, or module
def make_model_dir(parent_path, model, index)
# For MyModule, the index indicates its position in project sidebar
if model.instance_of?(MyModule)
class_name = 'module'
model_format = '(%<idx>s) %<name>s'
else
class_name = model.class.to_s.downcase.pluralize
model_format = '%<name>s (%<idx>s)'
end
model_name =
format(model_format, idx: index, name: to_filesystem_name(model.name))
model_path = parent_path
if model.archived
model_path += "/Archived #{class_name}"
FileUtils.mkdir_p(model_path)
end
model_path += "/#{model_name}"
FileUtils.mkdir_p(model_path)
model_path
end
# Appends given suffix to file_name and then adds original extension
def append_file_suffix(file_name, suffix)
ext = File.extname(file_name)
File.basename(file_name, ext) + suffix + ext
end
def create_archived_results_folder(result_path)
path = "#{result_path}/Archived attachments"
FileUtils.mkdir_p(path) unless File.directory?(path)
path
end
# Helper method to extract given assets to the directory
def export_assets(elements, type, directory, archived = false)
directory = create_archived_results_folder(directory) if archived && elements.present?
asset_indexes = {}
elements.each_with_index do |element, i|
asset = element.asset
preview = prepare_preview(asset)
if type == :step
name = "#{directory}/" \
"#{append_file_suffix(asset.file_name, "_#{i}_Step#{element.step.position_plus_one}")}"
if preview
preview_name = "#{directory}/" \
"#{append_file_suffix(preview[:file_name], "_#{i}_Step#{element.step.position_plus_one}_preview")}"
end
elsif type == :result
name = "#{directory}/#{append_file_suffix(asset.file_name, "_#{i}")}"
preview_name = "#{directory}/#{append_file_suffix(preview[:file_name], "_#{i}_preview")}" if preview
end
if asset.file.attached?
begin
File.binwrite(name, asset.file.download)
File.binwrite(preview_name, preview[:file_data]) if preview
rescue ActiveStorage::FileNotFoundError
next
end
end
asset_indexes[asset.id] = {
file: name,
preview: preview_name
}
end
asset_indexes
end
def prepare_preview(asset)
if asset.previewable? && !asset.list?
preview = asset.inline? ? asset.large_preview : asset.medium_preview
if preview.is_a?(ActiveStorage::Preview)
return unless preview.image.attached?
file_name = preview.image.filename.to_s
file_data = preview.image.download
else
file_name = preview.blob.filename.to_s
file_data = nil
ActiveRecord::Base.transaction(requires_new: true) do
file_data = preview.processed.service.download(preview.key)
# handle files not processable by Vips (no preview available) or missing
rescue Vips::Error, ActiveStorage::FileNotFoundError => e
Rails.logger.error(e.message)
Rails.logger.error(e.backtrace.join("\n"))
raise ActiveRecord::Rollback
end
return nil if file_data.blank?
end
{
file_name: file_name,
file_data: file_data
}
end
end
# Helper method to extract given tables to the directory
def export_tables(elements, type, directory, archived = false)
directory = create_archived_results_folder(directory) if archived && elements.present?
table_indexes = {}
elements.each_with_index do |element, i|
table = element.table
table_name = table.name.presence || 'Table'
table_name += i.to_s
if type == :step
name = "#{directory}/#{to_filesystem_name(table_name)}" \
"_#{i}_Step#{element.step.position_plus_one}.csv"
elsif type == :result
name = "#{directory}/#{to_filesystem_name(table_name)}.csv"
end
File.binwrite(name, table.to_csv)
table_indexes[table.id] = {
file: name
}
end
table_indexes
end
# Helper method for saving inventories to CSV
def save_inventories_to_csv(path, repo, idx)
repo_name = "#{to_filesystem_name(repo.name)} (#{idx})"
# Attachment folder
rel_attach_path = "#{repo_name} attachments"
attach_path = "#{path}/#{rel_attach_path}"
FileUtils.mkdir_p(attach_path)
# CSV file
csv_file_path = "#{path}/#{repo_name}.csv"
# Define headers and columns IDs
col_ids = [-3, -4, -5, -6] + repo.repository_columns.map(&:id)
# Define callback function for file name
assets = {}
asset_counter = 0
handle_name_func = lambda do |asset|
file_name = append_file_suffix(asset.file_name, "_#{asset_counter}").to_s
# Save pair for downloading it later
assets[asset] = "#{attach_path}/#{file_name}"
asset_counter += 1
rel_path = "#{rel_attach_path}/#{file_name}"
return "=HYPERLINK(\"#{rel_path}\", \"#{rel_path}\")"
end
# Generate CSV
csv_data = RepositoryZipExport.to_csv(repo.repository_rows, col_ids, @user, repo, handle_name_func)
File.binwrite(csv_file_path, csv_data)
# Save all attachments (it doesn't work directly in callback function
assets.each do |asset, asset_path|
asset.file.open do |file|
FileUtils.cp(file.path, asset_path)
end
rescue ActiveStorage::FileNotFoundError
next
end
csv_file_path
end
def failed_notification_title
I18n.t('activejob.failure_notifiable_job.item_notification_title',
item: I18n.t('activejob.failure_notifiable_job.items.project'))
end
end