Arno Kaimbacher
2a7480d2ed
All checks were successful
CI Pipeline / japa-tests (push) Successful in 50s
- added relation 'collectionRole' to Collection.ts class - added 'ListSets' and =GetRecord request for OaiController.ts - npm updates - added utility-functions.ts
397 lines
16 KiB
TypeScript
397 lines
16 KiB
TypeScript
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
|
|
import { RequestContract } from '@ioc:Adonis/Core/Request';
|
|
import { XMLBuilder } from 'xmlbuilder2/lib/interfaces';
|
|
import { create } from 'xmlbuilder2';
|
|
import dayjs, { Dayjs } from 'dayjs';
|
|
import utc from 'dayjs/plugin/utc';
|
|
import timezone from 'dayjs/plugin/timezone';
|
|
import { readFileSync } from 'fs';
|
|
import { StatusCodes } from 'http-status-codes';
|
|
import { transform } from 'saxon-js';
|
|
// import { Xslt, xmlParse } from 'xslt-processor'
|
|
import { OaiErrorCodes, OaiModelError } from 'App/Exceptions/OaiErrorCodes';
|
|
import { OaiModelException, BadOaiModelException } from 'App/Exceptions/OaiModelException';
|
|
import Dataset from 'App/Models/Dataset';
|
|
import Collection from 'App/Models/Collection';
|
|
import { getDomain } from 'App/Utils/utility-functions';
|
|
import XmlModel from 'App/Library/XmlModel';
|
|
|
|
interface XslTParameter {
|
|
[key: string]: any;
|
|
}
|
|
|
|
interface Dictionary {
|
|
[index: string]: string;
|
|
}
|
|
|
|
export default class OaiController {
|
|
private deliveringDocumentStates = ['published', 'deleted'];
|
|
// private sampleRegEx = /^[A-Za-zäüÄÜß0-9\-_.!~]+$/;
|
|
private xsltParameter: XslTParameter;
|
|
// private configuration: Configuration;
|
|
// private tokenWorker: TokenWorker;
|
|
|
|
/**
|
|
* Holds xml representation of document information to be processed.
|
|
*
|
|
* @var xmlbuilder.XMLDocument | null Defaults to null.
|
|
*/
|
|
private xml: XMLBuilder;
|
|
private proc;
|
|
|
|
constructor() {
|
|
// Load the XSLT file
|
|
this.proc = readFileSync('public/assets2/datasetxml2oai.sef.json');
|
|
// tests
|
|
// const xslPath = 'assets/datasetxml2oai-pmh.xslt'; // Replace with the actual path to your XSLT file
|
|
// this.proc = readFileSync(xslPath, 'utf-8');
|
|
// this.configuration = new Configuration();
|
|
dayjs.extend(utc);
|
|
dayjs.extend(timezone);
|
|
}
|
|
|
|
public async index({ response, request }: HttpContextContract): Promise<void> {
|
|
this.xml = create({ version: '1.0', encoding: 'UTF-8', standalone: true }, '<root></root>');
|
|
|
|
// this.proc = new XSLTProcessor();
|
|
// const stylesheet = readFileSync(__dirname + "/datasetxml2oai.sef.json");
|
|
const xsltParameter = (this.xsltParameter = {});
|
|
|
|
let oaiRequest: Dictionary = {};
|
|
if (request.method() === 'POST') {
|
|
oaiRequest = request.body();
|
|
} else if (request.method() === 'GET') {
|
|
oaiRequest = request.qs();
|
|
} else {
|
|
xsltParameter['oai_error_code'] = 'unknown';
|
|
xsltParameter['oai_error_message'] = 'Only POST and GET methods are allowed for OAI-PMH.';
|
|
}
|
|
// const oaiRequest: OaiParameter = request.body;
|
|
try {
|
|
await this.handleRequest(oaiRequest, request);
|
|
} catch (error) {
|
|
if (error instanceof OaiModelException) {
|
|
const code = error.oaiCode;
|
|
let oaiErrorCode: string | undefined = 'Unknown oai error code ' + code;
|
|
if (OaiModelError.has(error.oaiCode) && OaiModelError.get(code) !== undefined) {
|
|
oaiErrorCode = OaiModelError.get(error.oaiCode);
|
|
}
|
|
this.xsltParameter['oai_error_code'] = oaiErrorCode;
|
|
this.xsltParameter['oai_error_message'] = error.message;
|
|
} else {
|
|
// // return next(error); // passing to default express middleware error handler
|
|
this.xsltParameter['oai_error_code'] = 'unknown';
|
|
this.xsltParameter['oai_error_message'] = 'An internal error occured.';
|
|
}
|
|
}
|
|
|
|
const xmlString = this.xml.end({ prettyPrint: true });
|
|
|
|
let xmlOutput;
|
|
try {
|
|
const result = await transform({
|
|
// stylesheetFileName: `${config.TMP_BASE_DIR}/data-quality/rules/iati.sef.json`,
|
|
stylesheetText: this.proc,
|
|
destination: 'serialized',
|
|
// sourceFileName: sourceFile,
|
|
sourceText: xmlString,
|
|
stylesheetParams: xsltParameter,
|
|
// logLevel: 10,
|
|
});
|
|
xmlOutput = result.principalResult;
|
|
} catch (error) {
|
|
return response.status(500).json({
|
|
message: 'An error occurred while creating the user',
|
|
error: error.message,
|
|
});
|
|
}
|
|
|
|
response
|
|
.header('Content-Type', 'application/xml; charset=utf-8')
|
|
.header('Access-Control-Allow-Origin', '*')
|
|
.header('Access-Control-Allow-Methods', 'GET,POST');
|
|
response.status(StatusCodes.OK).send(xmlOutput);
|
|
}
|
|
|
|
protected async handleRequest(oaiRequest: Dictionary, request: RequestContract) {
|
|
// Setup stylesheet
|
|
// $this->loadStyleSheet('datasetxml2oai-pmh.xslt');
|
|
|
|
// Set response time
|
|
const now: Dayjs = dayjs();
|
|
this.xsltParameter['responseDate'] = now.format('YYYY-MM-DDTHH:mm:ss[Z]');
|
|
this.xsltParameter['unixTimestamp'] = now.unix();
|
|
|
|
// set OAI base url
|
|
const baseDomain = process.env.BASE_DOMAIN || 'localhost';
|
|
this.xsltParameter['baseURL'] = baseDomain + '/oai';
|
|
this.xsltParameter['repURL'] = request.protocol() + '://' + request.hostname();
|
|
this.xsltParameter['downloadLink'] = request.protocol() + '://' + request.hostname() + '/file/download/';
|
|
this.xsltParameter['doiLink'] = 'https://doi.org/';
|
|
this.xsltParameter['doiPrefix'] = 'info:eu-repo/semantics/altIdentifier/doi/';
|
|
|
|
if (oaiRequest['verb']) {
|
|
const verb = oaiRequest['verb'];
|
|
this.xsltParameter['oai_verb'] = verb;
|
|
if (verb === 'Identify') {
|
|
this.handleIdentify();
|
|
} else if (verb === 'ListMetadataFormats') {
|
|
this.handleListMetadataFormats();
|
|
} else if (verb == 'GetRecord') {
|
|
await this.handleGetRecord(oaiRequest);
|
|
}
|
|
// else if (verb == "ListRecords") {
|
|
// await this.handleListRecords(oaiRequest);
|
|
// } else if (verb == "ListIdentifiers") {
|
|
// await this.handleListIdentifiers(oaiRequest);
|
|
// }
|
|
else if (verb == 'ListSets') {
|
|
await this.handleListSets();
|
|
} else {
|
|
this.handleIllegalVerb();
|
|
}
|
|
} else {
|
|
// // try {
|
|
// // console.log("Async code example.")
|
|
// const err = new PageNotFoundException("verb not found");
|
|
// throw err;
|
|
// // } catch (error) { // manually catching
|
|
// // next(error); // passing to default middleware error handler
|
|
// // }
|
|
throw new OaiModelException(
|
|
StatusCodes.INTERNAL_SERVER_ERROR,
|
|
'The verb provided in the request is illegal.',
|
|
OaiErrorCodes.BADVERB,
|
|
);
|
|
}
|
|
}
|
|
|
|
protected handleIdentify() {
|
|
const email = process.env.OAI_EMAIL || 'repository@geosphere.at';
|
|
const repositoryName = 'Tethys RDR';
|
|
const repIdentifier = 'tethys.at';
|
|
const sampleIdentifier = 'oai:' + repIdentifier + ':1'; //$this->_configuration->getSampleIdentifier();
|
|
|
|
// Dataset::earliestPublicationDate()->server_date_published->format('Y-m-d\TH:i:s\Z') : null;
|
|
// earliestDateFromDb!= null && (this.xsltParameter['earliestDatestamp'] = earliestDateFromDb?.server_date_published);
|
|
|
|
// set parameters for oai-pmh.xslt
|
|
this.xsltParameter['email'] = email;
|
|
this.xsltParameter['repositoryName'] = repositoryName;
|
|
this.xsltParameter['repIdentifier'] = repIdentifier;
|
|
this.xsltParameter['sampleIdentifier'] = sampleIdentifier;
|
|
// $this->proc->setParameter('', 'earliestDatestamp', $earliestDateFromDb);
|
|
|
|
this.xml.root().ele('Datasets');
|
|
}
|
|
|
|
protected handleListMetadataFormats() {
|
|
this.xml.root().ele('Datasets');
|
|
}
|
|
|
|
protected async handleListSets() {
|
|
const repIdentifier = 'tethys.at';
|
|
this.xsltParameter['repIdentifier'] = repIdentifier;
|
|
const datasetElement = this.xml.root().ele('Datasets');
|
|
|
|
const sets: { [key: string]: string } = {
|
|
'open_access': 'Set for open access licenses',
|
|
'doc-type:ResearchData': 'Set for document type ResearchData',
|
|
// ...(await this.getSetsForDatasetTypes()),
|
|
...(await this.getSetsForCollections()),
|
|
// ... await this.getSetsForProjects(),
|
|
} as Dictionary;
|
|
|
|
for (const [key, value] of Object.entries(sets)) {
|
|
const setElement = datasetElement.ele('Rdr_Sets');
|
|
setElement.att('Type', key);
|
|
setElement.att('TypeName', value);
|
|
}
|
|
}
|
|
|
|
protected async handleGetRecord(oaiRequest: Dictionary) {
|
|
const repIdentifier = 'tethys.at';
|
|
this.xsltParameter['repIdentifier'] = repIdentifier;
|
|
|
|
const dataId = this.validateAndGetIdentifier(oaiRequest);
|
|
const dataset = await Dataset.query().where('publish_id', dataId).preload('xmlCache').preload('collections').first();
|
|
|
|
if (!dataset || !dataset.publish_id) {
|
|
throw new OaiModelException(
|
|
StatusCodes.INTERNAL_SERVER_ERROR,
|
|
'The value of the identifier argument is unknown or illegal in this repository.',
|
|
OaiErrorCodes.IDDOESNOTEXIST,
|
|
);
|
|
}
|
|
|
|
const metadataPrefix = this.validateAndGetMetadataPrefix(oaiRequest);
|
|
this.xsltParameter['oai_metadataPrefix'] = metadataPrefix;
|
|
// do not deliver datasets which are restricted by document state defined in deliveringStates
|
|
this.validateDatasetState(dataset);
|
|
|
|
// add xml elements
|
|
const datasetNode = this.xml.root().ele('Datasets');
|
|
await this.createXmlRecord(dataset, datasetNode);
|
|
}
|
|
|
|
private validateAndGetIdentifier(oaiRequest: Dictionary): number {
|
|
// Identifier references metadata Urn, not plain Id!
|
|
// Currently implemented as 'oai:foo.bar.de:{docId}' or 'urn:nbn...-123'
|
|
if (!('identifier' in oaiRequest)) {
|
|
throw new BadOaiModelException('The prefix of the identifier argument is unknown.');
|
|
}
|
|
const dataId = Number(this.getDocumentIdByIdentifier(oaiRequest.identifier));
|
|
if (isNaN(dataId)) {
|
|
throw new OaiModelException(
|
|
StatusCodes.INTERNAL_SERVER_ERROR,
|
|
'The value of the identifier argument is illegal in this repository.',
|
|
OaiErrorCodes.BADARGUMENT,
|
|
);
|
|
}
|
|
return dataId;
|
|
}
|
|
|
|
private validateAndGetMetadataPrefix(oaiRequest: Dictionary): string {
|
|
let metadataPrefix = '';
|
|
if ('metadataPrefix' in oaiRequest) {
|
|
metadataPrefix = oaiRequest['metadataPrefix'];
|
|
} else {
|
|
throw new OaiModelException(
|
|
StatusCodes.INTERNAL_SERVER_ERROR,
|
|
'The prefix of the metadata argument is unknown.',
|
|
OaiErrorCodes.BADARGUMENT,
|
|
);
|
|
}
|
|
return metadataPrefix;
|
|
}
|
|
|
|
private validateDatasetState(dataset: Dataset): void {
|
|
if (dataset.server_state == null || !this.deliveringDocumentStates.includes(dataset.server_state)) {
|
|
throw new OaiModelException(
|
|
StatusCodes.INTERNAL_SERVER_ERROR,
|
|
'Document is not available for OAI export!',
|
|
OaiErrorCodes.NORECORDSMATCH,
|
|
);
|
|
}
|
|
}
|
|
|
|
private async createXmlRecord(dataset: Dataset, datasetNode: XMLBuilder) {
|
|
const domNode = await this.getDatasetXmlDomNode(dataset);
|
|
|
|
if (domNode) {
|
|
// add frontdoor url and data-type
|
|
dataset.publish_id && this.addLandingPageAttribute(domNode, dataset.publish_id.toString());
|
|
this.addSpecInformation(domNode, 'data-type:' + dataset.type);
|
|
|
|
// if (dataset.collections) {
|
|
// for (const coll of dataset.collections) {
|
|
// const collRole = await coll.getCollectionRole();
|
|
// this.addSpecInformation(domNode, collRole.oai_name + ':' + coll.number);
|
|
// }
|
|
// }
|
|
|
|
datasetNode.import(domNode);
|
|
}
|
|
}
|
|
|
|
private async getDatasetXmlDomNode(dataset: Dataset) {
|
|
const xmlModel = new XmlModel(dataset);
|
|
// xmlModel.setModel(dataset);
|
|
xmlModel.excludeEmptyFields();
|
|
xmlModel.caching = true;
|
|
// const cache = dataset.xmlCache ? dataset.xmlCache : null;
|
|
// dataset.load('xmlCache');
|
|
if (dataset.xmlCache) {
|
|
xmlModel.xmlCache = dataset.xmlCache;
|
|
}
|
|
|
|
// return cache.getDomDocument();
|
|
const domDocument: XMLBuilder | null = await xmlModel.getDomDocument();
|
|
return domDocument;
|
|
}
|
|
|
|
private addSpecInformation(domNode: XMLBuilder, information: string) {
|
|
domNode.ele('SetSpec').att('Value', information);
|
|
}
|
|
|
|
private addLandingPageAttribute(domNode: XMLBuilder, dataid: string) {
|
|
const baseDomain = process.env.BASE_DOMAIN || 'localhost';
|
|
const url = 'https://' + getDomain(baseDomain) + '/dataset/' + dataid;
|
|
// add attribute du dataset xml element
|
|
domNode.att('landingpage', url);
|
|
}
|
|
|
|
private getDocumentIdByIdentifier(oaiIdentifier: string): string {
|
|
const identifierParts: string[] = oaiIdentifier.split(':'); // explode(":", $oaiIdentifier);
|
|
const dataId: string = identifierParts[2];
|
|
// switch (identifierParts[0]) {
|
|
// case 'oai':
|
|
// if (isset($identifierParts[2])) {
|
|
// $dataId = $identifierParts[2];
|
|
// }
|
|
// break;
|
|
// default:
|
|
// throw new OaiModelException(
|
|
// 'The prefix of the identifier argument is unknown.',
|
|
// OaiModelError::BADARGUMENT
|
|
// );
|
|
// break;
|
|
// }
|
|
|
|
// if (empty($dataId) or !preg_match('/^\d+$/', $dataId)) {
|
|
// throw new OaiModelException(
|
|
// 'The value of the identifier argument is unknown or illegal in this repository.',
|
|
// OaiModelError::IDDOESNOTEXIST
|
|
// );
|
|
|
|
return dataId;
|
|
}
|
|
|
|
private async getSetsForCollections(): Promise<Dictionary> {
|
|
const sets: { [key: string]: string } = {} as Dictionary;
|
|
|
|
const collections = await Collection.query()
|
|
.select('name', 'number', 'role_id')
|
|
.whereHas('collectionRole', (query) => {
|
|
query.where('visible_oai', true);
|
|
})
|
|
.preload('collectionRole');
|
|
|
|
collections.forEach((collection) => {
|
|
// if collection has a collection role (classification like ddc):
|
|
if (collection.number) {
|
|
// collection.load('collectionRole');
|
|
const setSpec = collection.collectionRole?.oai_name + ':' + collection.number;
|
|
sets[setSpec] = `Set ${collection.number} '${collection.name}'`;
|
|
}
|
|
});
|
|
return sets;
|
|
}
|
|
|
|
// private async getSetsForDatasetTypes(): Promise<IDictionary> {
|
|
// const sets: { [key: string]: string } = {} as IDictionary;
|
|
|
|
// const datasets: Array<Dataset> = await Dataset.findAll({
|
|
// attributes: ["type"],
|
|
// where: { server_state: { [Sequelize.Op.eq]: "published" } },
|
|
// });
|
|
// datasets.forEach((dataset) => {
|
|
// if (dataset.type && false == preg_match(this.sampleRegEx, dataset.type)) {
|
|
// const msg = `Invalid SetSpec (data-type='${dataset.type}').
|
|
// Allowed characters are [${this.sampleRegEx}].`;
|
|
// Logger.err(`OAI: ${msg}`);
|
|
// // Log::error("OAI-PMH: $msg");
|
|
// return;
|
|
// }
|
|
// const setSpec = "data-type:" + dataset.type;
|
|
// sets[setSpec] = `Set for document type '${dataset.type}'`;
|
|
// });
|
|
// return sets;
|
|
// }
|
|
|
|
private handleIllegalVerb() {
|
|
this.xsltParameter['oai_error_code'] = 'badVerb';
|
|
this.xsltParameter['oai_error_message'] = 'The verb provided in the request is illegal.';
|
|
}
|
|
}
|