scinote-web/app/controllers/repository_rows_controller.rb

415 lines
15 KiB
Ruby
Raw Normal View History

2017-06-06 23:35:29 +08:00
class RepositoryRowsController < ApplicationController
include InputSanitizeHelper
include ActionView::Helpers::TextHelper
include ApplicationHelper
2020-05-08 17:56:29 +08:00
include MyModulesHelper
2017-06-06 23:35:29 +08:00
MAX_PRINTABLE_ITEM_NAME_LENGTH = 64
before_action :load_repository, except: %i(show print_modal print)
before_action :load_repository_or_snapshot, only: %i(print_modal print)
before_action :load_repository_row, only: %i(update assigned_task_list active_reminder_repository_cells)
before_action :check_read_permissions, except: %i(show create update delete_records copy_records reminder_repository_cells)
before_action :check_snapshotting_status, only: %i(create update delete_records copy_records)
2017-06-06 23:35:29 +08:00
before_action :check_create_permissions, only: :create
before_action :check_delete_permissions, only: %i(delete_records archive_records restore_records)
before_action :check_manage_permissions, only: %i(update copy_records)
2017-06-06 23:35:29 +08:00
def index
@draw = params[:draw].to_i
per_page = params[:length] == '-1' ? 100 : params[:length].to_i
page = (params[:start].to_i / per_page) + 1
datatable_service = RepositoryDatatableService.new(@repository, params, current_user)
@all_rows_count = datatable_service.all_count
@columns_mappings = datatable_service.mappings
@repository_rows = datatable_service.repository_rows
.preload(:repository_columns,
:created_by,
repository_cells: { value: @repository.cell_preload_includes })
.page(page)
.per(per_page)
2020-06-24 17:22:28 +08:00
@repository_rows = @repository_rows.where(archived: params[:archived]) unless @repository.archived?
rescue RepositoryFilters::ColumnNotFoundException
render json: { custom_error: I18n.t('repositories.show.repository_filter.errors.column_not_found') }
rescue RepositoryFilters::ValueNotFoundException
render json: { custom_error: I18n.t('repositories.show.repository_filter.errors.value_not_found') }
end
2017-06-06 23:35:29 +08:00
def create
2019-12-10 15:43:26 +08:00
service = RepositoryRows::CreateRepositoryRowService
.call(repository: @repository, user: current_user, params: update_params)
2017-06-22 23:26:11 +08:00
2019-12-10 15:43:26 +08:00
if service.succeed?
repository_row = service.repository_row
log_activity(:create_item_inventory, repository_row)
repository_row.repository_cells.where(value_type: 'RepositoryTextValue').each do |repository_cell|
record_annotation_notification(repository_row, repository_cell)
end
2019-12-10 15:43:26 +08:00
render json: { id: service.repository_row.id, flash: t('repositories.create.success_flash',
record: escape_input(repository_row.name),
2019-12-10 15:43:26 +08:00
repository: escape_input(@repository.name)) },
status: :ok
else
render json: service.errors, status: :bad_request
2017-06-06 23:35:29 +08:00
end
end
def show
@repository_row = RepositoryRow.find_by(id: params[:id])
2020-08-11 19:33:44 +08:00
return render_404 unless @repository_row
return render_404 unless @repository_row.repository_id == params[:repository_id].to_i
return render_403 unless can_read_repository?(@repository_row.repository)
2020-08-11 16:27:23 +08:00
@assigned_modules = @repository_row.my_modules.joins(experiment: :project)
@viewable_modules = @assigned_modules.viewable_by_user(current_user, current_user.teams)
@private_modules = @assigned_modules - @viewable_modules
respond_to do |format|
format.json do
render json: {
html: render_to_string(
partial: 'repositories/repository_row_info_modal.html.erb'
)
}
end
end
end
def print_modal
@repository_rows = @repository.repository_rows.where(id: params[:rows])
@printers = LabelPrinter.all
respond_to do |format|
format.json do
render json: {
html: render_to_string(
partial: 'repositories/print_label_modal.html.erb'
)
}
end
end
end
def print
# reset all potential error states for printers and discard all jobs
# rubocop:disable Rails/SkipsModelValidations
LabelPrinter.update_all(status: :ready, current_print_job_ids: [])
# rubocop:enable Rails/SkipsModelValidations
label_printer = LabelPrinter.find(params[:label_printer_id])
job_ids = RepositoryRow.where(id: params[:repository_row_ids]).flat_map do |repository_row|
LabelPrinters::PrintJob.perform_later(
label_printer,
LabelTemplate.first.render( # Currently we will only use the default template
item_id: repository_row.code,
item_name: repository_row.name.truncate(MAX_PRINTABLE_ITEM_NAME_LENGTH)
),
params[:copies].to_i
).job_id
end
label_printer.update!(current_print_job_ids: job_ids * params[:copies].to_i)
render json: {
html: render_to_string(
partial: 'label_printers/print_progress_modal.html.erb',
locals: { starting_item_count: label_printer.current_print_job_ids.length,
label_printer: label_printer }
)
}
end
2017-06-06 23:35:29 +08:00
def update
2019-12-10 15:43:26 +08:00
row_update = RepositoryRows::UpdateRepositoryRowService
.call(repository_row: @repository_row, user: current_user, params: update_params)
2017-06-06 23:35:29 +08:00
2019-12-10 15:43:26 +08:00
if row_update.succeed?
if row_update.record_updated
log_activity(:edit_item_inventory, @repository_row)
@repository_row.repository_cells.where(value_type: 'RepositoryTextValue').each do |repository_cell|
record_annotation_notification(@repository_row, repository_cell)
end
end
render json: {
id: @repository_row.id,
flash: t(
'repositories.update.success_flash',
record: escape_input(@repository_row.name),
repository: escape_input(@repository.name)
)
}, status: :ok
2018-04-16 20:10:49 +08:00
else
2019-12-10 15:43:26 +08:00
render json: row_update.errors, status: :bad_request
2018-04-16 20:10:49 +08:00
end
end
2017-06-06 23:35:29 +08:00
def delete_records
deleted_count = 0
2017-12-20 00:53:45 +08:00
if selected_params
selected_params.each do |row_id|
row = @repository.repository_rows.find_by(id: row_id)
2019-07-12 22:43:54 +08:00
next unless row && can_manage_repository_rows?(@repository)
2019-03-07 14:38:34 +08:00
2019-07-12 22:43:54 +08:00
log_activity(:delete_item_inventory, row)
row.destroy && deleted_count += 1
2017-06-06 23:35:29 +08:00
end
if deleted_count.zero?
flash = t('repositories.destroy.no_deleted_records_flash',
2017-12-20 00:53:45 +08:00
other_records_number: selected_params.count)
elsif deleted_count != selected_params.count
not_deleted_count = selected_params.count - deleted_count
2017-06-06 23:35:29 +08:00
flash = t('repositories.destroy.contains_other_records_flash',
records_number: deleted_count,
other_records_number: not_deleted_count)
else
flash = t('repositories.destroy.success_flash',
records_number: deleted_count)
end
respond_to do |format|
color = deleted_count.zero? ? 'info' : 'success'
format.json { render json: { flash: flash, color: color }, status: :ok }
2017-06-06 23:35:29 +08:00
end
else
respond_to do |format|
format.json do
render json: {
flash: t('repositories.destroy.no_records_selected_flash')
}, status: :bad_request
end
end
end
end
def copy_records
2018-04-13 17:47:33 +08:00
duplicate_service = RepositoryActions::DuplicateRows.new(
2020-06-11 22:11:23 +08:00
current_user, @repository, selected_rows_in_repo_params
2018-04-13 17:47:33 +08:00
)
duplicate_service.call
render json: {
flash: t('repositories.copy_records_report',
number: duplicate_service.number_of_duplicated_items)
}, status: :ok
end
def available_rows
2021-07-23 17:56:28 +08:00
if @repository.repository_rows.active.blank?
no_items_string =
"#{t('projects.reports.new.save_PDF_to_inventory_modal.no_items')} " \
"#{link_to(t('projects.reports.new.save_PDF_to_inventory_modal.here'),
repository_path(@repository),
data: { 'no-turbolink' => true })}"
render json: { no_items: no_items_string },
status: :ok
else
render json: { results: load_available_rows },
status: :ok
end
end
def assigned_task_list
assigned_modules = @repository_row.my_modules.joins(experiment: :project)
2020-05-28 21:35:19 +08:00
.where_attributes_like(
['my_modules.name', 'experiments.name', 'projects.name'],
params[:query],
whole_phrase: true
)
viewable_modules = assigned_modules.viewable_by_user(current_user, current_user.teams)
private_modules_number = assigned_modules.where.not(id: viewable_modules).count
2020-04-28 18:41:59 +08:00
render json: {
2020-05-07 18:51:18 +08:00
html: render_to_string(partial: 'shared/my_modules_list_partial.html.erb', locals: {
my_modules: viewable_modules,
private_modules_number: private_modules_number
2020-05-07 18:51:18 +08:00
})
2020-04-28 18:41:59 +08:00
}
end
def reminder_repository_cells
render json: @repository_row.repository_cells.with_active_reminder(current_user)
end
def archive_records
service = RepositoryActions::ArchiveRowsService.call(repository: @repository,
2020-06-11 22:11:23 +08:00
repository_rows: selected_rows_in_repo_params,
user: current_user,
team: current_team)
if service.succeed?
render json: { flash: t('repositories.archive_records.success_flash', repository: @repository.name) }, status: :ok
else
render json: { error: service.error_message }, status: :unprocessable_entity
end
end
def restore_records
service = RepositoryActions::RestoreRowsService.call(repository: @repository,
2020-06-11 22:11:23 +08:00
repository_rows: selected_rows_in_repo_params,
user: current_user,
team: current_team)
if service.succeed?
render json: { flash: t('repositories.restore_records.success_flash', repository: @repository.name) }, status: :ok
else
render json: { error: service.error_message }, status: :unprocessable_entity
end
end
def active_reminder_repository_cells
reminder_cells = @repository_row.repository_cells.with_active_reminder(current_user).distinct
render json: {
html: render_to_string(partial: 'shared/repository_row_reminder.html.erb', locals: {
reminders: reminder_cells
})
}
end
2017-06-06 23:35:29 +08:00
private
include StringUtility
AvailableRepositoryRow = Struct.new(:id, :name, :has_file_attached)
def load_repository
@repository = Repository.accessible_by_teams(current_team)
.eager_load(:repository_columns)
.find_by(id: params[:repository_id])
render_404 unless @repository
end
def load_repository_or_snapshot
@repository = Repository.accessible_by_teams(current_team).find_by(id: params[:repository_id])
@repository ||= RepositorySnapshot.find_by(id: params[:repository_id])
render_404 unless @repository
end
def load_repository_row
@repository_row = @repository.repository_rows.eager_load(:repository_columns).find_by(id: params[:id])
render_404 unless @repository_row
2017-06-06 23:35:29 +08:00
end
def check_read_permissions
render_403 unless can_read_repository?(@repository)
end
def check_snapshotting_status
return if @repository.repository_snapshots.provisioning.none?
respond_to do |format|
format.json do
render json: {
flash: t('repositories.index.snapshot_provisioning_in_progress')
}, status: :unprocessable_entity
end
end
end
2017-06-06 23:35:29 +08:00
def check_create_permissions
2019-07-12 22:43:54 +08:00
render_403 unless can_create_repository_rows?(@repository)
2017-06-06 23:35:29 +08:00
end
def check_manage_permissions
2019-07-12 22:43:54 +08:00
render_403 unless can_manage_repository_rows?(@repository)
2017-06-06 23:35:29 +08:00
end
2019-11-22 20:23:02 +08:00
def check_delete_permissions
render_403 unless can_delete_repository_rows?(@repository)
end
def remove_file_columns_params
JSON.parse(params.fetch(:remove_file_columns) { '[]' })
end
2017-12-20 00:53:45 +08:00
def selected_params
params.permit(selected_rows: []).to_h[:selected_rows]
2017-06-06 23:35:29 +08:00
end
2020-06-11 22:11:23 +08:00
# Selected rows in scope of current @repository
def selected_rows_in_repo_params
process_ids = params[:selected_rows].map(&:to_i).uniq
@repository.repository_rows.where(id: process_ids).pluck(:id)
end
def load_available_rows
@repository.repository_rows
.active
.includes(:repository_cells)
.name_like(search_params[:q])
.limit(Constants::SEARCH_LIMIT)
.select(:id, :name)
.collect do |row|
with_asset_cell = row.repository_cells.where(
'repository_cells.repository_column_id = ?',
search_params[:repository_column_id]
)
AvailableRepositoryRow.new(row.id,
2018-05-17 17:21:34 +08:00
ellipsize(row.name, 75, 50),
with_asset_cell.present?)
end
end
def search_params
params.permit(:q, :repository_id, :repository_column_id)
end
2017-06-06 23:35:29 +08:00
def record_annotation_notification(record, cell, old_text = nil)
smart_annotation_notification(
old_text: old_text,
2017-06-06 23:35:29 +08:00
new_text: cell.value.data,
title: t('notifications.repository_annotation_title',
user: current_user.full_name,
column: cell.repository_column.name,
record: record.name,
repository: record.repository.name),
2017-06-06 23:35:29 +08:00
message: t('notifications.repository_annotation_message_html',
record: link_to(record.name, repository_url(@repository)),
column: link_to(cell.repository_column.name, repository_url(@repository)))
2017-06-06 23:35:29 +08:00
)
end
def fetch_list_items(cell)
return [] if cell.value_type != 'RepositoryListValue'
RepositoryListItem.where(repository: @repository)
.where(repository_column: cell.repository_column)
.limit(Constants::SEARCH_LIMIT)
.pluck(:id, :data)
.map { |li| [li[0], escape_input(li[1])] }
end
def fetch_columns_list_items
collection = []
@repository.repository_columns
.list_type
.preload(:repository_list_items)
.each do |column|
collection << {
column_id: column.id,
list_items: column.repository_list_items
.limit(Constants::SEARCH_LIMIT)
.pluck(:id, :data)
.map { |li| [li[0], escape_input(li[1])] }
}
end
collection
end
2019-03-07 14:38:34 +08:00
2019-12-10 15:43:26 +08:00
def update_params
params.permit(repository_row: {}, repository_cells: {}).to_h
end
2019-03-07 14:38:34 +08:00
def log_activity(type_of, repository_row)
Activities::CreateActivityService
.call(activity_type: type_of,
owner: current_user,
subject: @repository,
team: current_team,
message_items: {
repository_row: repository_row.id,
repository: @repository.id
})
end
2017-06-06 23:35:29 +08:00
end