Class: AgentsController

Inherits:

ApplicationController

• Object
• ActionController::Base
• ApplicationController
• AgentsController

Defined in:

frontend/app/controllers/agents_controller.rb,
public/app/controllers/agents_controller.rb

Overview

frozen_string_literal: true

Constant Summary

DEFAULT_AG_TYPES =

%w{repository resource accession archival_object digital_object classification}

DEFAULT_AG_FACET_TYPES =

%w{primary_type subjects}

DEFAULT_AG_SEARCH_OPTS =

{
  'sort' => 'title_sort asc',
  'resolve[]' => ['repository:id', 'resource:id@compact_resource', 'ancestors:id@compact_resource'],
  'facet.mincount' => 1
}

DEFAULT_AG_SEARCH_PARAMS =

{
  :q => ['*'],
  :limit => 'agent',
  :op => ['OR'],
  :field => ['title']
}

RETAINED_PARAMETERS =

['filter_fields', 'filter_values']

Instance Method Summary

• #create ⇒ Object
• #current_record ⇒ Object
• #defaults ⇒ Object
• #delete ⇒ Object
• #edit ⇒ Object
• #index ⇒ Object
• #merge ⇒ Object
• #merge_detail ⇒ Object
• #merge_selector ⇒ Object
• #new ⇒ Object
• #publish ⇒ Object
• #required ⇒ Object
• #search ⇒ Object
• #show ⇒ Object
• #update ⇒ Object
• #update_defaults ⇒ Object
• #update_required ⇒ Object

Methods inherited from ApplicationController

#archivesspace, can_access?, permission_mappings, set_access_control

Instance Method Details

#create ⇒ Object

# File 'frontend/app/controllers/agents_controller.rb', line 63

def create
  handle_crud(instance: :agent,
              model: JSONModel(@agent_type),
              required_fields: @required_fields,
              find_opts: find_opts,
              before_hooks: [method(:set_structured_date_type)],
              on_invalid: lambda {
                ensure_auth_and_display
                return render_aspace_partial partial: 'agents/new' if inline?
                return render action: :new
              },
              on_valid: lambda  { |id|
                flash[:success] = t('agent._frontend.messages.created')

                if @agent['is_slug_auto'] == false &&
                   @agent['slug'].nil? &&
                   params['agent'] &&
                   params['agent']['is_slug_auto'] == '1'

                  flash[:warning] = t('slug.autogen_disabled')
                end

                return render json: @agent.to_hash if inline?
                if params.key?(:plus_one)
                  return redirect_to({ controller: :agents, action: :new, agent_type: @agent_type })
                end

                redirect_to({ controller: :agents, action: :edit, id: id, agent_type: @agent_type })
              })
end

#current_record ⇒ Object

# File 'frontend/app/controllers/agents_controller.rb', line 29

def current_record
  @agent
end

#defaults ⇒ Object

# File 'frontend/app/controllers/agents_controller.rb', line 155

def defaults
  defaults = DefaultValues.get params['agent_type']

  @agent = JSONModel(@agent_type).new({ agent_type: @agent_type })._always_valid!

  @agent.update(defaults.form_values) if defaults

  render 'defaults'
end

#delete ⇒ Object

# File 'frontend/app/controllers/agents_controller.rb', line 120

def delete
  agent = JSONModel(@agent_type).find(params[:id])

  if agent.key?('is_repo_agent')
    flash[:error] = t('errors.cannot_delete_repository_agent')
    redirect_to(controller: :agents, action: :show, id: params[:id])
    return
  end

  begin
    agent.delete
  rescue ConflictException => e
    flash[:error] = t('agent._frontend.messages.delete_conflict', error: t("errors.#{e.conflicts}", default: e.message))
    redirect_to(controller: :agents, action: :show, id: params[:id])
    return
  end

  flash[:success] = t('agent._frontend.messages.deleted')
  redirect_to(controller: :agents, action: :index, deleted_uri: agent.uri)
end

#edit ⇒ Object

# File 'frontend/app/controllers/agents_controller.rb', line 59

def edit
  @agent = JSONModel(@agent_type).find(params[:id], find_opts)
end

#index ⇒ Object

# File 'frontend/app/controllers/agents_controller.rb', line 15

def index
  respond_to do |format|
    format.html do
      @search_data = Search.for_type(session[:repo_id], 'agent', params_for_backend_search.merge({ 'facet[]' => SearchResultData.AGENT_FACETS }))
    end
    format.csv do
      search_params = params_for_backend_search.merge({ 'facet[]' => SearchResultData.AGENT_FACETS })
      search_params['type[]'] = 'agent'
      uri = "/repositories/#{session[:repo_id]}/search"
      csv_response(uri, Search.build_filters(search_params), "#{t('agent._plural').downcase}.")
    end
  end
end

#merge ⇒ Object

# File 'frontend/app/controllers/agents_controller.rb', line 218

def merge
  merge_list = params[:record_uris]
  merge_destination = merge_list[0]
  merge_list.shift
  merge_candidates = merge_list
  merge_destination_type = JSONModel.parse_reference(merge_destination)[:type]
  handle_merge(merge_candidates,
               merge_destination,
               'agent',
               { agent_type: merge_destination_type })
end

#merge_detail ⇒ Object

# File 'frontend/app/controllers/agents_controller.rb', line 270

def merge_detail
  merge_destination_uri = JSONModel(@agent_type).uri_for(params[:id])
  merge_candidate_uri = params['merge_candidate_uri']
  request = JSONModel(:merge_request_detail).new
  request.merge_destination = { 'ref' => merge_destination_uri }
  request.merge_candidates = Array.wrap({ 'ref' => merge_candidate_uri })

  # the backend is expecting to know how the user may have re-ordered subrecords in the merge interface. This information is encoded in the params, but will be stripped out when we clean them up unless we add them as a pseudo schema attribute.
  # add_position_to_agents_merge does exactly this.
  agent_params_with_position = add_position_to_agents_merge_params(params['agent'])
  request.selections = cleanup_params_for_schema(agent_params_with_position, JSONModel(@agent_type).schema)

  uri = "#{JSONModel::HTTP.backend_url}/merge_requests/agent_detail"
  if params['dry_run']
    uri += '?dry_run=true'
    response = JSONModel::HTTP.post_json(URI(uri), request.to_json)
    merge_response = ASUtils.json_parse(response.body)

    @agent = JSONModel(@agent_type).from_hash(merge_response['result'], find_opts)
    render_aspace_partial partial: 'agents/merge_preview', locals: { object: @agent }
  else
    begin
      response = JSONModel::HTTP.post_json(URI(uri), request.to_json)

      flash[:success] = t('agent._frontend.messages.merged')
      resolver = Resolver.new(request.merge_destination['ref'])
      redirect_to(resolver.view_uri)
    rescue ValidationException => e
      flash[:error] = e.errors.to_s
      redirect_to({ action: :show, id: params[:id] }.merge(extra_params))
    rescue ConflictException => e
      flash[:error] = t('errors.merge_conflict', message: e.conflicts)
      redirect_to({ action: :show, id: params[:id] }.merge(extra_params))
    rescue RecordNotFound => e
      flash[:error] = t('errors.error_404')
      redirect_to({ action: :show, id: params[:id] }.merge(extra_params))
    end
  end
end

#merge_selector ⇒ Object

# File 'frontend/app/controllers/agents_controller.rb', line 230

def merge_selector
  @agent = JSONModel(@agent_type).find(params[:id], find_opts)

  if params[:refs].is_a?(Array)
    flash[:error] = t('errors.merge_too_many_merge_candidates')
    redirect_to({ action: :show, id: params[:id] })
    return
  end

  merge_candidate_details = JSONModel.parse_reference(params[:refs])
  @merge_candidate_type = merge_candidate_details[:type].to_sym
  if @merge_candidate_type != @agent_type
    flash[:error] = t('errors.merge_different_types')
    redirect_to({ action: :show, id: params[:id] })
    return
  end

  @merge_candidate = JSONModel(@merge_candidate_type).find(merge_candidate_details[:id], find_opts)
  if @agent.key?('is_user') || @merge_candidate.key?('is_user')
    flash[:error] = t('errors.merge_denied_for_system_user')
    redirect_to({ action: :show, id: params[:id] })
    return
  end

  relationship_uris = @merge_candidate['related_agents'] ? @merge_candidate['related_agents'].map {|ra| ra['ref']} : []
  if relationship_uris.include?(@agent['uri'])
    flash[:error] = t('errors.merge_denied_relationship')
    redirect_to({ action: :show, id: params[:id] })
    return
  end

  if !user_can?('view_agent_contact_record') && (@agent.agent_contacts.any? || @merge_candidate.agent_contacts.any?)
    flash[:error] = t('errors.merge_restricted_contact_details')
    redirect_to({ action: :show, id: params[:id] })
    return
  end

  render '_merge_selector'
end

#new ⇒ Object

# File 'frontend/app/controllers/agents_controller.rb', line 37

def new
  @agent = JSONModel(@agent_type).new({ agent_type: @agent_type })._always_valid!
  if user_prefs['default_values']
    defaults = DefaultValues.get @agent_type.to_s
    @agent.update(defaults.values) if defaults
  end

  @required_fields.each_required_subrecord do |property, stub_record|
    @agent[property] << stub_record if @agent[property].empty?
  end

  if @agent.names.empty?
    @agent.names = [@name_type.new({ authorized: true, is_display_name: true })._always_valid!]
  end

  ensure_auth_and_display

  set_sort_name_default

  render_aspace_partial partial: 'agents/new' if inline?
end

#publish ⇒ Object

# File 'frontend/app/controllers/agents_controller.rb', line 141

def publish
  agent = JSONModel(@agent_type).find(params[:id])

  response = JSONModel::HTTP.post_form("#{agent.uri}/publish")

  if response.code == '200'
    flash[:success] = t('agent._frontend.messages.published', agent_title: clean_mixed_content(agent.display_name['sort_name']))
  else
    flash[:error] = ASUtils.json_parse(response.body)['error'].to_s
  end

  redirect_to request.referer
end

#required ⇒ Object

# File 'frontend/app/controllers/agents_controller.rb', line 182

def required
  @agent = JSONModel(@agent_type).new({ agent_type: @agent_type })._always_valid!
  # we are pretending this is an agent form but it's really a RequiredFields form
  @agent.lock_version = @required_fields.lock_version
  render 'required'
end

#search ⇒ Object

# File 'public/app/controllers/agents_controller.rb', line 69

def search
  # need at least q[]=WHATEVER&op[]=OR&field[]=title&from_year[]=&to_year[]=&limit=pui_agent
  @base_search = '/agents/search?'
  page = Integer(params.fetch(:page, "1"))
  begin
    set_up_and_run_search( DEFAULT_AG_TYPES, DEFAULT_AG_FACET_TYPES, DEFAULT_AG_SEARCH_OPTS, params)
  rescue NoResultsError
    flash[:error] = I18n.t('search_results.no_results')
    redirect_back(fallback_location: '/') and return
  rescue Exception => error
    flash[:error] = I18n.t('errors.unexpected_error')
    redirect_back(fallback_location: '/agents') and return
  end
  @page_title = I18n.t('agent._plural')
  @results_type = @page_title
  @search_title = I18n.t('search_results.search_for', {:type => I18n.t('agent._plural'), :term => params.fetch(:q)[0]})
  render 'search/search_results'
end

#show ⇒ Object

# File 'frontend/app/controllers/agents_controller.rb', line 33

def show
  @agent = JSONModel(@agent_type).find(params[:id], find_opts)
end

#update ⇒ Object

# File 'frontend/app/controllers/agents_controller.rb', line 94

def update
  handle_crud(instance: :agent,
              model: JSONModel(@agent_type),
              obj: JSONModel(@agent_type).find(params[:id], find_opts),
              before_hooks: [method(:set_structured_date_type)],
              on_invalid: lambda {
                if @agent.names.empty?
                  @agent.names = [@name_type.new._always_valid!]
                end

                return render action: :edit
              },
              on_valid: lambda  { |id|
                flash[:success] = t('agent._frontend.messages.updated')
                if @agent['is_slug_auto'] == false &&
                   @agent['slug'].nil? &&
                   params['agent'] &&
                   params['agent']['is_slug_auto'] == '1'

                  flash[:warning] = t('slug.autogen_disabled')
                end

                redirect_to controller: :agents, action: :edit, id: id, agent_type: @agent_type
              })
end

#update_defaults ⇒ Object

# File 'frontend/app/controllers/agents_controller.rb', line 165

def update_defaults
  DefaultValues.from_hash({
                            'record_type' => @agent_type.to_s,
                            'lock_version' => params['agent'].delete('lock_version'),
                            'defaults' => cleanup_params_for_schema(
                              params['agent'],
                              JSONModel(@agent_type).schema
                            )
                          }).save

  flash[:success] = t('default_values.messages.defaults_updated')
  redirect_to controller: :agents, action: :defaults
rescue Exception => e
  flash[:error] = e.message
  redirect_to controller: :agents, action: :defaults
end

#update_required ⇒ Object

# File 'frontend/app/controllers/agents_controller.rb', line 189

def update_required
  processed_params = cleanup_params_for_schema(
    params['agent'],
    JSONModel(@agent_type).schema
  )
  subrecord_requirements = []

  processed_params.each do |key, defn|
    next unless defn.is_a?(Array) && defn.size == 1
    # we aren't interested in booleans
    defn[0].reject! {|k, v| [false, true].include? (v) }
    subrecord_requirements << {
      property: key,
      record_type: defn[0]['jsonmodel_type'],
      required: (defn[0]['required'] == 'true'),
      required_fields: defn[0].keys.reject { |k| ['jsonmodel_type', 'required'].include?(k) }
    }
  end
  RequiredFields.from_hash({
                             'lock_version' => processed_params['lock_version'],
                             'record_type' => @agent_type.to_s,
                             'subrecord_requirements' => subrecord_requirements}).save
  flash[:success] = t('required_fields.messages.required_fields_updated')
  redirect_to controller: :agents, action: :required
rescue Exception => e
  flash[:error] = e.message
  redirect_to controller: :agents, action: :required
end