rdf-editor-DataSets.ts
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sat, Oct 12, 04:29

rdf-editor-DataSets.ts
View Options

	import { EDITINGURL } from '../constants';
	import {StatementHandler, ChangeMgmntDef, TlnPredicate, TlnStatementCollection} from './statement-handler';
	import {QueryService} from '../services/query.service';
	import * as N3 from "node_modules/n3/src";
	import {RQ_ASK_EXISTS_IN_STORE, RQ_ASK_IF_CLASS_INSTANCE, RQ_ASK_IF_PROPERTY, RQ_AVAILABLE_PROPERTIES, RQ_GET_DOMAIN, RQ_GET_RANGE,
	RQ_RDF_Type} from './constants';

	export class RdfData {
	protected _iri: string; // the subjects iri
	protected _rdfType: string; // rdfs type uf the subject
	protected _availablePredicates: Map<string,TlnPredicate>; // All the predicates available in the store for that resource
	protected _statements: StatementHandler;

	constructor() {
	}
	static selfStatement(s: string, o:string): N3.Quad {
	return RdfData.createNamedNodeQuad(s, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type', o);
	}

	// standOffType can be dataType like "http://www.w3.org/2001/XMLSchema#anyURI" or a lang tag like "@en" in the resulting literal
	// [literal]^^[standoffType]. Default is a literal in german
	static createLiteralStatement(s: string, p: string, value: string, standOffType = '@de'): N3.Quad {
	let lang, dataType = '';
	const { DataFactory } = N3;
	const { namedNode, defaultGraph, quad } = DataFactory;
	let literal = new N3.Literal(`"${value}"${standOffType}`);
	return quad( namedNode(s), namedNode(p), literal, defaultGraph());
	}

	static createNamedNodeQuad(s: string, p: string, o: string): N3.Quad {
	const { DataFactory } = N3;
	const { namedNode, quad } = DataFactory;
	return quad( namedNode(s), namedNode(p), namedNode(o))
	}


	// creates a unique iri with the given optional label, its optional parent and a generated hash built with timestamp and an additional random hash
	public static createIri(label?: string, parentIri?: string) {
	// unique hash: timestamp & random combined
	const hash = `${Date.now().valueOf().toString(36)}-${(Math.random()).toString(36).replace('.', '')}`;
	return parentIri !== undefined ? `${parentIri}${label}${hash}` : `${label}${hash}`;
	}

	// public methods

	public iri() {
	return this._iri;
	}

	public rdfType() {
	return this._rdfType;
	}

	public selfStatement() {
	return RdfData.createNamedNodeQuad(this.iri(), 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type', this.getFirstObject('http://www.w3.org/1999/02/22-rdf-syntax-ns#type'));
	}

	public availablePredicates(): Map<string, TlnPredicate> {
	return this._availablePredicates;
	}

	// returns whether a given predicate is available or not acc. to the ontology
	public isPredicateAvailable(predicate: string): boolean{
	return this._availablePredicates.has(predicate);
	}

	public agentStatements(): Map<string,TlnStatementCollection> {
	return this._statements.agentStatements();
	}

	public listStatements() {
	return this._statements.agentListStatements();
	}

	public listsAsStatements() {
	return this._statements.agentListsAsStatements();
	}

	public statements() {
	return this._statements;
	}

	// returns the first object iri for a given predicate for the resource
	public getFirstObject(predicateIri: string) {
	if (this.agentStatements().has(predicateIri) && this.agentStatements().get(predicateIri).getNodes().length > 0) {
	return this.agentStatements().get(predicateIri).getNodes()[0].value;
	} else return '';
	}

	// gets all agentstatements, i.e. also the agent list statements as quads
	public getAllAgentStatementQuads(): N3.Quad[] {
	let quads: N3.Quad[] = this._statements.getAllAgentStmAsQuads(this._iri); // getting all outgoing statements as quads
	return quads;
	}
	}


	// RdfStoredData represents the data which is stored in the triple store. It gets/contains all necessary data for any given iri
	// from the triple store. All properties are immutable.
	export class RdfStoredData extends RdfData {

	constructor(private qService: QueryService, iri: string) {
	super();
	this._iri = iri;
	}

	// async rdfDataFactory
	static async buildAsync(queryService: QueryService, iri, editorDef: ChangeMgmntDef) {
	const build = await new RdfStoredData(queryService, iri);
	if (!await RdfStoredData.askIfInStore(queryService, iri)) {// guard if iri not living in store
	console.warn(`Resource ${iri} not existing in store`);
	return build; }
	build._rdfType = await RdfStoredData.getRdfTypeFromStore(queryService, iri);
	build._availablePredicates = await build.getAvailablePredicatesFromStore(build._rdfType);
	// building all statements
	build._statements = await StatementHandler.buildFromStoreAsync(queryService, iri, build._availablePredicates, editorDef);
	// adding "a"
	const a = await TlnPredicate.buildFromStoreAsync(queryService, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type', true, false );
	build._statements.putAgentStatement(a, build._rdfType);
	return build;
	}

	// public functions

	public static async askIfInStore(qService: QueryService, iri: string): Promise<boolean> {
	const query = qService.parametrizeWhereClauseWithItems(RQ_ASK_EXISTS_IN_STORE, iri);
	return await qService.getData(EDITINGURL, query, 'ASK')
	.then(exists => (exists['boolean']));
	}

	public static async getRdfTypeFromStore(qService: QueryService, iri: string) {
	const query = qService.parametrizeWhereClauseWithItems(RQ_RDF_Type, iri);
	return await qService.getData(EDITINGURL, query, 'SELECT')
	.then( result => result['results']['bindings'].map(p => p['rdf_type'].value)[0])
	}


	// asks whether an iri is an instance of a Class
	private async askIfResource(iri: string): Promise<boolean> {
	const query = this.qService.parametrizeWhereClauseWithItems(RQ_ASK_IF_CLASS_INSTANCE, iri);
	return await this.qService.getData(EDITINGURL, query, 'ASK')
	.then(isResource => (isResource['boolean']));
	}

	// displayableList: whiteList
	private async getAvailablePredicatesFromStore(rdfType: string, displayableList?: string[], mutableList?: string[] ): Promise<Map<string, TlnPredicate>> {
	let avPreds = new Map<string, TlnPredicate>();
	let preds: string[];
	const query = this.qService.parametrizeWhereClauseWithItems(RQ_AVAILABLE_PROPERTIES,
	'' , '', rdfType);
	preds = await this.qService.getData(EDITINGURL, query, 'SELECT').then(
	result => result['results']['bindings'].map(p => p['prop'].value) );
	// adding the rdfType as well as predicate
	for (const p of preds) {
	// todo: add disp/mutable: function displayable ()
	let tlnPredicate = await TlnPredicate.buildFromStoreAsync(this.qService, p);
	avPreds.set(p, tlnPredicate);
	}
	return avPreds;
	}

	public async exportAsEditorData(statementDef?: ChangeMgmntDef): Promise<RdfEditorData> {
	return await RdfEditorData.rdfEditorDataFactory(this, statementDef); // creating the rdfEditorData
	}
	}

	// RdfEditorData contains the rdf data to edit. To construct use either rdfEditorDataFactory() to edit an existing thing or build()
	export class RdfEditorData extends RdfData {
	protected _displayedPredicates: Map<string,TlnPredicate>; // All the predicates available for display
	protected _mutablePredicates: Map<string,TlnPredicate>; // All the predicates available for editing
	protected _editorDef: ChangeMgmntDef;
	public constructor(iri: string,
	rdfType: string) {
	super();
	this._iri = iri;
	this._rdfType = rdfType;
	this._statements = new StatementHandler();
	}

	// async rdfEditorDataFactory, creates the RDFEditorData from a given rdfStoreData by cloning it and all properties/subproperties
	static async rdfEditorDataFactory(rdfStoredData: RdfStoredData, editorDef?: ChangeMgmntDef ) {
	// Todo: statementDefs: overwrite TlnPredicates? Filter them?
	let rdfEditorData = new RdfEditorData(rdfStoredData.iri(), rdfStoredData.rdfType());
	rdfEditorData._editorDef = editorDef;
	rdfEditorData.setAvailablePredicates(rdfStoredData.availablePredicates());
	rdfEditorData._statements = await rdfStoredData.statements().selfCloneAsync();
	return rdfEditorData;
	}

	// public methods

	public setStatement(predicate: TlnPredicate, object:string, index) {
	this._statements.setAgentStatement(predicate, object, index)
	}

	public putStatement(predicate: TlnPredicate, object:string, index?) {
	this._statements.putAgentStatement(predicate, object, index)
	}

	protected setListStatement(predicate: TlnPredicate, list: string) {
	this._statements.setListStatement(predicate, list);
	}

	// accessor for RdfEditorData Instances
	public putStatementInListAsStatement(predicate: TlnPredicate, objectIri:string, index?: number) {
	this._statements.putListAsStmStatement(predicate, objectIri, index);
	}

	// accessor for RdfEditorData Instances
	public setStatementInListAsStatement(predicate: TlnPredicate, objectIri:string, index: number) {
	this._statements.setListAsStmStatement(predicate, objectIri, index);
	}

	public deleteAllAgentStatements() {
	this._statements.deleteAllAgentStatements();
	}

	// accessor method RdfEditorData Instances
	public deleteAllStatementsForPredicate(predicateIri: string) {
	this._statements.deleteAllStatementsForPredicate(predicateIri)
	}
	// accessor method RdfEditorData Instances
	public deleteAllStatementsWithObject(objectIri: string) {
	this._statements.deleteAllObjectPresence(objectIri);
	}

	// accessor method
	public moveObjectInStatement(predicate: string, previousIndex: number, newIndex: number) {
	this._statements.moveObjectInAgentStatement(predicate, previousIndex, newIndex);
	}

	// accessor method
	public moveObjectInListAsStatement(predicate: string, previousIndex: number, newIndex: number) {
	console.log('moving ', predicate, previousIndex, newIndex);
	this._statements.moveObjectInListAsStatement(predicate, previousIndex, newIndex);
	}

	// sets or resets all _availablePredicates
	public setAvailablePredicates(predicates: Map<string, TlnPredicate> = new Map<string, TlnPredicate>()) {
	this._availablePredicates = predicates;
	}

	// sets or resets all _statements
	public resetListStatements(listStatements: Map<string, string> = new Map<string, string>()) {
	this._statements.resetListStatements(listStatements);
	}

	public resetListAsStatements(listAsStatements: Map<string, TlnStatementCollection>) {
	this._statements.resetListAsStatements(listAsStatements);
	}

	public createListFromStatements() {
	}

	public createListsFromStatements() {
	}

	public hasStatementEntriesForPredicate(predicateIri: string) {
	return this._statements.hasStatementEntriesForPredicate(predicateIri);
	}
	}

rdf-editor-DataSets.tsNo OneTemporaryActions

File Metadata

rdf-editor-DataSets.tsView Options

Event Timeline

rdf-editor-DataSets.ts
No OneTemporary
Actions

rdf-editor-DataSets.ts
View Options