class Libis::Ingester::CollectionCreator

Attributes

rosetta[RW]

Protected Instance Methods

process(item) click to toggle source
# File lib/libis/ingester/tasks/collection_creator.rb, line 45
def process(item)
  create_collection(item)
  stop_processing_subitems unless item.items.no_timeout.any? {|i| i.is_a?(Libis::Ingester::Collection)}
end

Private Instance Methods

create_collection(item, collection_list = nil) click to toggle source

noinspection RubyResolve

# File lib/libis/ingester/tasks/collection_creator.rb, line 55
def create_collection(item, collection_list = nil)

  unless collection_list
    collection_list = item.ancestors.select do |i|
      i.is_a? Libis::Ingester::Collection
    end.map do |collection|
      collection.label
    end
    collection_list += parameter(:collection).split('/').reverse if parameter(:collection)
    collection_list += parameter(:root_collection).split('/').reverse if parameter(:root_collection)
    collection_list = collection_list.reverse
  end

  unless @collection_service
    @collection_service = Libis::Services::Rosetta::CollectionHandler.new(
        Libis::Ingester::Config.base_url,
        logger: Libis::Ingester::Config.logger, log_level: :debug, log: false
    )
    #rosetta = Libis::Services::Rosetta::Service.new(
    #    Libis::Ingester::Config.base_url, Libis::Ingester::Config.pds_url,
    #    logger: Libis::Ingester::Config.logger, log_level: :debug, log: true
    #)
    producer_info = item.get_run.producer
    @collection_service.authenticate(producer_info[:agent], producer_info[:password], producer_info[:institution])
    #institution = producer_info[:institution]
    ## Temp fix: adapt institution code to code used in PDS. Need to remove when basic auth is fixed (case #00527632)
    #institution = case institution
    #              when 'KUL'
    #                'ROSETTA_KULEUVEN'
    #              when 'INS00'
    #                'ROSETTA'
    #              else
    #                "ROSETTA_#{institution}"
    #              end
    #handle = rosetta.login(producer_info[:agent], producer_info[:password], institution)
    #raise Libis::WorkflowAbort, 'Could not log in into Rosetta.' if handle.nil?
    #@collection_service = rosetta.collection_service
  end

  parent_id = item.parent.properties['collection_id'] if item.parent
  parent_id ||= create_collection_path(collection_list)

  collection_id = find_collection((collection_list + [item.label]).join('/'), item)
  if collection_id
    debug "Found collection '#{item.label}' with id #{collection_id} in Rosetta.", item
  else
    collection_id = create_collection_id(parent_id, collection_list, item.label, item.navigate, item.publish, item)
    debug "Created collection '#{item.label}' with id #{collection_id} in Rosetta.", item
    item.properties['new'] = true
  end
  item.properties['collection_id'] = collection_id
rescue Libis::Services::ServiceError => e
  raise Libis::WorkflowError, "Remote call to create collection failed: #{e.message}"
rescue Exception => e
  raise Libis::WorkflowError, "Create collection failed: #{e.message} @ #{e.backtrace.first}"
end
create_collection_id(parent_id, collection_list, collection_name, navigate = nil, publish = nil, item = nil) click to toggle source
# File lib/libis/ingester/tasks/collection_creator.rb, line 131
def create_collection_id(parent_id, collection_list, collection_name, navigate = nil, publish = nil, item = nil)

  # noinspection RubyResolve
  if item&.metadata_record
    dc_record = Libis::Metadata::DublinCoreRecord.new item.metadata_record.data
  else
    dc_record = Libis::Metadata::DublinCoreRecord.new
    dc_record.title = collection_name
  end

  # noinspection RubyResolve
  dc_record.isPartOf = collection_list.join('/') unless collection_list.empty?


  collection_data = {}
  collection_data[:name] = collection_name
  collection_data[:description] = 'Created by Ingester'
  collection_data[:parent_id] = parent_id if parent_id
  collection_data[:navigate] = navigate.nil? ? parameter(:navigate) : navigate
  collection_data[:publish] = publish.nil? ? parameter(:publish) : publish
  # noinspection RubyResolve
  if item
    collection_data[:external_system] = item.external_system
    collection_data[:external_id] = item.external_id
  end
  collection_data[:md_dc] = {
      type: 'descriptive',
      sub_type: 'dc',
      content: dc_record.to_xml,
  }
  collection_info = Libis::Services::Rosetta::CollectionInfo.new collection_data.cleanup

  @collection_service.create(collection_info)
end
create_collection_path(list) click to toggle source
# File lib/libis/ingester/tasks/collection_creator.rb, line 112
def create_collection_path(list)
  list = list.dup
  return nil if list.blank?
  collection_id = find_collection(list.join('/'))
  return collection_id if collection_id

  collection_name = list.pop
  parent_id = create_collection_path(list)
  return nil unless parent_id or list.empty?

  begin
    collection_id = create_collection_id(parent_id, list, collection_name)
    debug "Created collection '#{collection_name}' with id #{collection_id} in Rosetta."
    collection_id
  rescue Exception => e
    raise Libis::WorkflowError, "Could not create collection '#{collection_name}': #{e.message}"
  end
end
find_collection(path, item = nil) click to toggle source
# File lib/libis/ingester/tasks/collection_creator.rb, line 166
def find_collection(path, item = nil)
  return nil if path.blank?

  collection = @collection_service.find(path)
  return nil unless collection

  if item
    collection.description = item.description
    # noinspection RubyResolve
    collection.navigate = item.navigate
    # noinspection RubyResolve
    collection.publish = item.publish
    # noinspection RubyResolve
    collection.external_system = item.external_system
    # noinspection RubyResolve
    collection.external_id = item.external_id
    # noinspection RubyResolve
    if item.metadata_record
      dc_record = Libis::Metadata::DublinCoreRecord.new(item.metadata_record.data)
      collection.md_dc.type = 'descriptive'
      collection.md_dc.sub_type = 'dc'
      collection.md_dc.content = dc_record.to_xml
    end

    @collection_service.update(collection)
  end

  return collection.id

rescue Libis::Services::SoapError => e
  unless e.message =~ /no_collection_found_exception/
    error 'Collection lookup failed: %s', e.message
  end
  nil
end