Diffusion Nietzsche-Beta-App (master) Browse

editor-resources.ts
ca2d5d21f796master

editor-resources.ts
View Options


			// The main super class for every thing which has to be added/edited or deleted in the triple store
			import {StatementHandler, ChangeMgmntDef, TlnStatementCollection, OnDelete, StatementOperations} from './statement-handler';
			import {QueryService} from '../services/query.service';
			import {RdfData, RdfEditorData, RdfStoredData} from './rdf-editor-DataSets';
			import * as N3 from "node_modules/n3/src";

			export class TlnResource {
			iri: string;
			label: string;
			_rdfDatasetFromStore: RdfStoredData; // the data from store if there is such a thing
			_rdfDatasetToEdit: RdfEditorData; // the data which is edited or created
			_deprecatedVersions: DeprecatedVersion[]; // all previous depricated versions of the resource
			parentIri: string;
			parentLabel: string;
			private _inStore: boolean; // exists in Store or in memory/JS only
			private _deprecated: boolean; // states that a resource has either been edited or deleted.
			private _edited: boolean; // whether an existing thing has been edited or not
			private _deleted: boolean; // whether a thing has been deleted in the frontend


			constructor(iri: string,
			label?: string,
			rdfsType?: string,
			parentIri?: string,
			parentLabel?: string) {

			this.iri = iri;
			this._inStore = false;
			this._deleted = false;
			this._edited = false;
			this._deprecated = false;
			this._rdfDatasetToEdit = new RdfEditorData(this.iri, rdfsType);
			this.parentIri = parentIri;
			this.parentLabel = parentLabel;
			}

			// loads an existing resource (or a predicate) from strore
			static async buildFromStoreAsync( queryService: QueryService,
			existingIri: string,
			label?:string,
			editorDef?: ChangeMgmntDef ){
			let resource = new TlnResource(existingIri, label);
			resource._rdfDatasetFromStore = await RdfStoredData.buildAsync(queryService, existingIri, editorDef);
			resource._inStore = await resource._rdfDatasetFromStore.askIfInStore(existingIri);
			resource._rdfDatasetToEdit = await resource._rdfDatasetFromStore.exportAsEditorData(editorDef);
			if (resource._rdfDatasetFromStore.statements() === resource._rdfDatasetToEdit.statements()) {console.log('shiiiit not be the same')}
			return resource;
			}

			// returns the iri's of all children depending on a given childsPredicate
			async getChildIris(childsPredicate: string): Promise<string[]> {
			let childIris = [];
			// guard if childspredicate is not available or there are no statements for the thing
			if (!this._rdfDatasetToEdit.isPredicateAvailable(childsPredicate)) { return childIris }
			// else we get the childIris
			if (this._rdfDatasetToEdit.availablePredicates().get(childsPredicate).takesListAsObject()) { // get children out of a list as object
			if (this._rdfDatasetToEdit.listsAsStatements().size === 0) { return childIris } // another guard
			childIris = this._rdfDatasetToEdit.listsAsStatements().get(childsPredicate).getNodes().map(node => node.value);
			} else { // get children from statements
			if (this._rdfDatasetToEdit.agentStatements().size === 0) { return childIris } // another guard
			childIris = this._rdfDatasetToEdit.agentStatements().get(childsPredicate).getNodes().map(node => node.value);
			}
			return childIris;
			}

			isInStore() {
			return this._inStore;
			}

			isEdited() {
			return this._edited;
			}

			ignore() { // if the resource is not in the store and is set to deleted it must not be processed
			return (!this._inStore && this._deleted);
			}

			isDeleted() {
			return this._deleted;
			}

			rdfDatasetFromStore() {
			return this._rdfDatasetFromStore;
			}

			// creates a deprecated data set from the original dataset - we only deprecate existing things in store
			public async deprecate(timestamp: string, def: ChangeMgmntDef): Promise<TlnDeprecation> {
			if (!this._inStore) { return null } // guard
			if (!this._deleted) { // if it is not deleted, we have to deprecate the thing against the new one
			return await TlnDeprecation.buildAsync(this._rdfDatasetFromStore, timestamp, def, this._rdfDatasetToEdit) } else {
			// it has been deleted, so we just depricate the whole thing without passing a new version
			return await TlnDeprecation.buildAsync(this._rdfDatasetFromStore, timestamp, def)
			}
			}

			// Marks the TlnResource as deleted and starts deprecation of that resource with all its properties
			public setDeleted() {
			this._deleted = true;
			}

			public setUndeleted() {
			this._deleted = false;
			}



			// returns all statements of a thing as n3.Quad[];
			// First getting all outgoing/agent statements. patientStatements are not needed, hence they are in the parent and handled by deprecation:
			// if
			// (properties with object) as n3 quad array in which there are both: the usual spo as well as a list containing all o's
			// public getAllAgentStatementQuads(): N3.Quad[] {
			// let quads: N3.Quad[] = this._rdfDatasetToEdit.statements().agentStmAsQuads(this._rdfDatasetToEdit.iri()) // getting all outgoing statements as quads
			// console.log(quads);
			// return quads;
			// }
			//
			// // returns the new thing with all its poperties & objects as N3-quads/lists
			// async buildRdfTransaction(): Promise<N3.Quad[]> {
			// // get all agent statements
			// let quads: N3.Quads[] = [].concat(this.getAllAgentStatementQuads()); // concadinating with [] so never undefined
			// // Sometimes there is none e.g. an existing page is part of identifiesAsVersion so we don't have to create iris & properties
			// // TODO get selfStatement from statementHandler - and get rid of the variable this.selfstatement
			// if (this._rdfDatasetToEdit.selfStatement() !== undefined && this._rdfDatasetToEdit.selfStatement() !== null) {
			// quads.splice(0,0, this._rdfDatasetToEdit.selfStatement());
			// }
			// return quads;
			// }

			// get all deprecated versionsof a given resource iri
			async getDeprecations(queryService: QueryService, iri: string): Promise<DeprecatedVersion[]> {
			let deprecations: DeprecatedVersion[];
			let iris: string[] = []; // the versions iri's
			// Todo: get versions by query
			for (const iri of iris) {
			let formerVeersion: DeprecatedVersion = await DeprecatedVersion.buildFromStoreAsync(queryService, iri);
			deprecations.push(formerVeersion)
			}
			return deprecations;
			}

			async getDeprecatedResources(resourceIri: string) {

			}


			undeprecate(iri: string) {
			// Todo: pass resource iri or verion iri? -> gui decision
			let resource = this._deprecatedVersions[this._deprecatedVersions.findIndex(version => version.version.iri === iri)];
			// map resource (a tln resource) to what it is, i.e.
			// populate all edcitorData with the data needed
			// populate cascading! so if a Version is populated, also its textUnits must be restored/undeprecated!
			// => get child from deprecatedChild???
			// if someOne saves it
			// ...
			}
			}


			// for undeprecating
			export class DeprecatedVersion {
			version: TlnResource;
			resource: TlnResource;

			constructor() {
			}

			static async buildFromStoreAsync(queryService, iri) {
			let version = new DeprecatedVersion();
			version.version = await TlnResource.buildFromStoreAsync(queryService,iri, 'Version');
			const resourceIri = version.version._rdfDatasetFromStore.getFirstObject('http://www.nie.org/ontology/nietzsche#deprecates');
			version.resource = await TlnResource.buildFromStoreAsync(queryService,resourceIri, 'Resource');
			return version;
			}
			}


			// a canvas for a resource with basic funcionality/features, i.e. only an rdf represenation of a resource with its agent statements.
			// Used for not yet existing things which have to be added to the store when a deprecation takes place.
			export class TlnShortHandResource {
			protected _iri: string;
			protected _rdfType: string;
			protected _statements: N3.Quad[] = []; // all the statements of a given thing as agent, e.g. subject

			constructor() {
			}

			// puts a deprecated statement
			putNamedNodeStatement(predicate: string, o: string ) {
			this._statements.push(RdfData.createNamedNodeQuad(this._iri, predicate, o))
			}

			// puts a deprecated statement
			putLiteralStatement(predicate: string, o: string, standOffType?: string ) {
			let quad = RdfData.createLiteralStatement(this._iri, predicate, o, standOffType);
			this._statements.push(quad);
			}

			iri() {
			return this._iri;
			}

			public statements() {
			return this._statements;
			}
			}

			// The dep:classes

			export class TlnDeprecatedAgentStatement extends TlnShortHandResource{

			constructor(predicate: string, node: N3.Literal\|N3.NamedNode) {
			super();
			// always put basic props
			this._rdfType = 'https://nietzsche.philhist.unibas.ch/ontology/deprecation#AgentStatement';
			this._iri = RdfData.createIri('DepAgentStm');
			this.putNamedNodeStatement('http://www.w3.org/1999/02/22-rdf-syntax-ns#type', this._rdfType);
			this.putLiteralStatement('https://nietzsche.philhist.unibas.ch/ontology/deprecation#hasProperty',
			predicate, '^^http://www.w3.org/2001/XMLSchema#anyURI');
			// the node itsel will be written as ...
			if ( node instanceof N3.Literal){ // a anyUri if the thing "was" a namednode ...
			this.putLiteralStatement('https://nietzsche.philhist.unibas.ch/ontology/deprecation#hasObject', node.value, `^^${node.datatypeString}`);
			}
			if (node instanceof N3.NamedNode) { // ... or it will be writte as a literal with its standofftype
			this.putLiteralStatement('https://nietzsche.philhist.unibas.ch/ontology/deprecation#hasObject', node.value,
			'^^http://www.w3.org/2001/XMLSchema#anyURI');
			}

			}
			}

			// the deprecated patient class: All deprecated statements/triples where the thing acted as a patient, i.e. an object
			export class TlnDeprecatedPatientStatement extends TlnShortHandResource{

			constructor(predicate: string, subject: string) {
			super();
			this._rdfType = 'https://nietzsche.philhist.unibas.ch/ontology/deprecation#PatientStatement';
			this._iri = RdfData.createIri('DepPatientStm');
			this.putNamedNodeStatement('http://www.w3.org/1999/02/22-rdf-syntax-ns#type', this._rdfType);
			this.putLiteralStatement('https://nietzsche.philhist.unibas.ch/ontology/deprecation#hasProperty', predicate,
			'^^http://www.w3.org/2001/XMLSchema#anyURI');
			this.putLiteralStatement('https://nietzsche.philhist.unibas.ch/ontology/deprecation#hasSubject', subject,
			'^^http://www.w3.org/2001/XMLSchema#anyURI');
			}
			}

			// The deprecated resource with all its properties
			export class TlnDeprecatedResource extends TlnShortHandResource { // creates a new instance of dep:Deprecation to be imported
			private _deprecatedStatements: any[] = []; // all statements that were valid before deprecation
			protected _rdfType = 'https://nietzsche.philhist.unibas.ch/ontology/deprecation#DeprecatedResource'; // the class of any deprecated Resource
			private _depTypePredicate = 'https://nietzsche.philhist.unibas.ch/ontology/deprecation#wasOfType'; // the predicate stating the former class
			private _linkToDerivate = 'https://nietzsche.philhist.unibas.ch/ontology/deprecation#hasDerivate'; // predicate to link to the derivate

			//use only builder
			constructor() {
			super();
			}

			//
			static async buildAsync(ancestor: RdfStoredData, timeStamp: string, derivate?: RdfEditorData): Promise<TlnDeprecatedResource> {
			let build = new TlnDeprecatedResource();
			if (derivate !== null && derivate !== undefined) {
			build.deprecateResourceWith(ancestor, derivate, timeStamp) } else {
			// the resource has no derivate, so it was "deleted" completely
			build.buildForDeletion(ancestor);
			}
			// Changing the type of the resource, but storing its old type
			build.putNamedNodeStatement('http://www.w3.org/1999/02/22-rdf-syntax-ns#type', build._rdfType);
			build.putNamedNodeStatement(build._depTypePredicate, ancestor.rdfType());
			return build;
			}


			// deprecates a resource completely without any newer state, i.e. a deletion
			private buildForDeletion(ancestor: RdfStoredData) {
			this._iri = ancestor.iri(); // if we delete a resource, its iri is still kept/valid and used for the deprecatedResource
			// get stuff to delete: simply delete all!

			// todo: add patientstatements ...
			this._deprecatedStatements = this.createDeprecatedStatements(ancestor.statements());
			}

			// deprecates a resource (ancestor) with its updated version (derivate)
			private async deprecateResourceWith(ancestor: RdfStoredData, derivate: RdfEditorData, timeStamp: string) {
			this._iri = `${ancestor.iri()}_deprecated_${timeStamp}`; // setting new deprecated iri
			this.putNamedNodeStatement(this._linkToDerivate, derivate.iri()); // put a link to the derivate/the latest valid version
			// Finally deprecating all statements which changed or got deleted
			}


			// gets all the triples which need to be created in order to deprecate, i.e. the deprecations of the resources statements
			createDeprecatedStatements(ancestorStatements: StatementHandler): any[]{
			const agentStatements: TlnDeprecatedAgentStatement[] = this.createDeprecatedAgentStatements(ancestorStatements.agentStatements());
			const patientStatements: TlnDeprecatedPatientStatement[] = this.createDeprecatedPatientStatements(ancestorStatements.patientStatements());
			// Todo: get deprecatedAgentlistStatements & patientlistStatements, deletion and change mgm will be outside this method
			return [... agentStatements, ... patientStatements];
			}

			createDeprecatedAgentStatements(statements: Map<string, TlnStatementCollection>): TlnDeprecatedAgentStatement[] {
			let depAgentStatements: TlnDeprecatedAgentStatement[] = [];
			for (let [key, value] of statements) {
			value.getNodes().forEach( node => {
			depAgentStatements.push(new TlnDeprecatedAgentStatement(key, node))
			});
			}
			return depAgentStatements;
			}

			// only needed if resource gets deleted
			createDeprecatedPatientStatements(statements: Map<string, TlnStatementCollection>): TlnDeprecatedPatientStatement[] {
			let depAgentStatements: TlnDeprecatedPatientStatement[] = [];
			for (let [key, value] of statements) {
			value.getNodes().forEach( node => {
			depAgentStatements.push(new TlnDeprecatedPatientStatement(key, node.id));
			})
			}
			return depAgentStatements;
			}

			createDeprecatedAgentListAsStatements(statements: Map<string, TlnStatementCollection>): TlnDeprecatedAgentStatement[] {
			let depAgentStatements: TlnDeprecatedAgentStatement[] = [];
			for (let [key, value] of statements) {
			value.getNodes().forEach( node => {
			depAgentStatements.push(new TlnDeprecatedAgentStatement(key, node))
			});
			}
			return depAgentStatements;
			}

			// returns all statements of the deprecated thing as an n3.Quad array, including the own statements of the dep:DeprecatedResource
			// as well as the deprecatedStatements, i.e. its statements
			quads(): N3.Quad[] {
			let deprStatements: N3.Quad[] = [];
			this._deprecatedStatements.forEach( stm => {
			deprStatements.push(...stm.statements())
			});
			return [].concat(this._statements, deprStatements)
			}
			}


			// contains all the triples/meta data of one transaction.
			export class TlnTransaction extends TlnShortHandResource{
			_rdfType = 'https://nietzsche.philhist.unibas.ch/ontology/deprecation#Transaction';
			committedAdditions: string; // the final ttl file
			committedDeletions: string; // the final written ttl file
			_additions: N3.Quad[] = []; // all the additions including additions, changes & lists to write
			_deletions: N3.Quad[] = []; // all the deletions including changes
			_listsToDelete: string[] = []; // all sparql queries for deleting lists
			public committed = false;

			constructor() {
			super();
			}

			private addTimeStampStm(ts: string) {
			this.putLiteralStatement('https://nietzsche.philhist.unibas.ch/ontology/deprecation#hasTime',
			ts, 'http://www.w3.org/2001/XMLSchema#dateTimeStamp');
			}

			private addUserStm(user: string) {
			if (!user \|\| user !== '') { return } // guard
			this.putLiteralStatement('https://nietzsche.philhist.unibas.ch/ontology/deprecation#hasResponsible', user);
			}

			private addCommentStm(comment: string) {
			if (!comment \|\| comment !== '') { return } // guard
			this.putLiteralStatement( 'https://nietzsche.philhist.unibas.ch/ontology/deprecation#hasComment', comment, '@de');
			}

			private addOperationType(resources: TlnResource[]) {
			let oType = 'multi';
			let delCount = resources.map(res => res.isDeleted()).filter(del => del === true).length;
			let edCount = resources.map(res => res.isEdited()).filter(ed => ed === true).length;
			console.log('resources deleted :', delCount, ' resources edites: ', edCount, ' total resources: ', resources.length)
			let inStore = resources.map(res => res.isInStore()).filter(st => st === true).length; // amount of resources in store
			if (!inStore) { // nothing was in store means creation only
			oType = 'creation' }
			if (edCount === inStore && edCount === resources.length && delCount === 0) { // if all edited are in store & nothing has been edited
			oType = 'edition' }
			if (delCount === resources.length) { // all have been deleted
			oType = 'deletion' }
			this.putLiteralStatement( 'https://nietzsche.philhist.unibas.ch/ontology/deprecation#transactionHasOperationType', oType, '@en');
			}

			// writes out all transaction triples as ttl
			public writeOut() {
			this.writeOutAdditions();
			this.writeOutDeletions();
			}

			writeOutAdditions() {
			let addWriter = new N3.Writer();
			// writing statements of the Transaction
			for (const statement of this._statements) {
			addWriter.addQuad(statement)
			}
			// writing statements for the resources/deprecated resources
			for (const addition of this._additions) {
			addWriter.addQuad(addition) }
			addWriter.end((error, result) => {
			if (error) {console.error(error); return}
			this.committedAdditions = result;
			})
			}

			writeOutDeletions() {
			let delWriter = new N3.Writer();
			for (const deletion of this._deletions) {
			delWriter.addQuad(deletion) }
			delWriter.end((error, result) => {
			if (error) {console.error(error); return}
			this.committedDeletions = result;
			})
			}

			// creates the commitment from any given array of TlnResources, runs all deprecation needed
			public async commit(resources: TlnResource[], user: string, comment: string, def: ChangeMgmntDef): Promise<boolean> {
			const ts = Date.now().valueOf().toString(); // timeStamp as string
			if (def.metaData) {
			// creating metadata about the transaction to perform
			this._iri = RdfData.createIri('transaction');
			this.putNamedNodeStatement('http://www.w3.org/1999/02/22-rdf-syntax-ns#type', this._rdfType);
			this.addTimeStampStm(ts);
			this.addUserStm(user);
			this.addCommentStm(comment);
			this.addOperationType(resources);
			}

			for (let resource of resources) {
			if (resource.ignore() === false) {
			if (resource.isInStore()) {
			let deprecation = await resource.deprecate(ts, def);
			this._additions.push(...deprecation.quadsToCreate());
			this._deletions.push(...deprecation.quadsToDelete());
			this._listsToDelete.push(...deprecation.listDeletionQueries());

			} else {
			// nothing to deprecate, only add new resource/statements so
			// we simply add all quads directly to the transactions additions. We only handle statements top down, i.e. agentStatements only,
			// hence patient statements are handled by their agents && a new resource to be created does not have any patientStatements
			this._additions.push(...resource._rdfDatasetToEdit.getAllAgentStatementQuads());
			}
			}
			}

			console.log('additions: ', this._additions);
			console.log('deletions: ', this._deletions);
			if (this._additions.length + this._deletions.length === 0) {
			return false } else { return true }
			}

			preview() {
			this.writeOut();
			}

			push(queryServeice: QueryService) {
			if (!this.committed) {
			console.warn('nothing to push. Commit before pushing');
			return; }
			this.writeOut();
			//todo: import
			}
			}



			// creates/contains all rdf data needed if a resource gets deleted or deprecated due to changes
			export class TlnDeprecation {
			private _iri: string;
			private deprecatedResource: TlnDeprecatedResource; // the deprecated thing dep:DeprecatedRescource with its props to be imported
			private _productiveOperations: StatementOperations; // the operations needed to perform for the new valid resouce, e.g.creating, updating, deleting, ...
			private _predecessor: RdfStoredData; // the original thing which needs to be depricated/deleted
			private _additions: N3.Quad[] = []; // new statements of the dep:deprecation
			private _depTreeDeletions: N3.Quad[] = []; // MetaData only: former statements of the deprecation tree which have to be deleted in order to update the tree
			// Todo: lists???

			constructor(predecessor: RdfStoredData) {
			this._iri = RdfData.createIri('Deprecation_');
			this._predecessor = predecessor;
			this._productiveOperations = new StatementOperations();
			}

			// asnc builder for the deprecation
			public static async buildAsync(predecessor: RdfStoredData, timestamp: string, def: ChangeMgmntDef, derivate?: RdfEditorData): Promise<TlnDeprecation> {
			let deprecation = new TlnDeprecation(predecessor);
			if (derivate && derivate !== undefined) { // If there is a newer version of the resource we make the diff
			deprecation._productiveOperations = await StatementOperations.getProductiveOperationsAsync(predecessor,
			derivate,
			def.updateLists);
			}
			if (!derivate \|\| derivate === undefined) { // if there is no derivate at all, the resource and its statements got deleted in the gui
			deprecation._productiveOperations = await deprecation.getOpsOnDelete(def.onDelete);
			console.log('deprecation._productiveOperations', deprecation._productiveOperations)
			}
			if (def.metaData && deprecation._productiveOperations.hasChanges()) {
			deprecation.addSelfStatement();
			deprecation.addOperationTypeStm(!!derivate);
			// if metaData should be written and if there are any changes made, we build a deprecated resource && update the derivation tree
			deprecation.deprecatedResource = await TlnDeprecatedResource.buildAsync(deprecation._predecessor, timestamp, derivate);
			if (derivate && derivate !== undefined) {
			deprecation.updateDerivationTree(derivate.iri());
			}
			}
			return deprecation;
			}


			private async getOpsOnDelete(onDelete: OnDelete): Promise<StatementOperations> {
			let ops = new StatementOperations();
			if (!onDelete.keepAgentStatements) {
			ops.deletions.push(... this._predecessor.statements().getAgentStmQuads(this._predecessor.iri()));
			}
			if (!onDelete.keepAgentLists) {
			ops.setListUpdates(this._predecessor)
			}
			if (!onDelete.keepPatientStatements) { // deleting also all patient statements
			ops.deletions.push(... this._predecessor.statements().getPatientStmAsQuads(this._predecessor.iri()));
			}

			// /Todo: pATIENT Lists???!

			return ops;
			}


			// Statements for the dep:deprecation

			// adds the statement with the rdf:type of the dep:Deprecation
			private addSelfStatement() {
			const selfStatement = RdfData.selfStatement(this._iri, 'https://nietzsche.philhist.unibas.ch/ontology/deprecation#Deprecation');
			this._additions.push(selfStatement);
			}

			private addOperationTypeStm(edited: boolean) {
			if (edited) {
			this._additions.push(RdfData.createLiteralStatement(this._iri,
			'https://nietzsche.philhist.unibas.ch/ontology/deprecation#deprecationHasOperationType',
			'edition', '@en')); } else {
			this._additions.push(RdfData.createLiteralStatement(this._iri,
			'https://nietzsche.philhist.unibas.ch/ontology/deprecation#deprecationHasOperationType',
			'deletion', '@en'));
			}
			}

			// Updates the derivation tree with the latest changes: Changes the link from the latest Version to this depretaion and takes over the link to the former deprecation
			private updateDerivationTree(derivateIri: string) {
			if (!derivateIri \|\| derivateIri === '') { return } // guard
			const formerDerivation = this._predecessor.getFirstObject('https://nietzsche.philhist.unibas.ch/ontology/deprecation#derivesFrom');
			if ( formerDerivation !== '') {
			// deleting the "dep:derivesFrom" statement from the valid resource to the latest predecessor/deprecation
			this._depTreeDeletions.push(RdfData.createNamedNodeQuad(derivateIri,'https://nietzsche.philhist.unibas.ch/ontology/deprecation#derivesFrom',
			formerDerivation));
			// adding the "dep:derivesFrom" statement from this deprecation to the former one, i.e. its predecessor
			this._additions.push(RdfData.createNamedNodeQuad(this._iri,
			'https://nietzsche.philhist.unibas.ch/ontology/deprecation#derivesFrom',
			formerDerivation));
			}
			// Add the link between the new valid version/ the derivate to this deprecation which is the latest predecessor
			this._additions.push(RdfData.createNamedNodeQuad(derivateIri,
			'https://nietzsche.philhist.unibas.ch/ontology/deprecation#derivesFrom',
			this._iri));
			}

			// public methods/accessors

			public iri() {
			return this._iri;
			}

			// returns all the quads which have to be added/created as an N3.Quad array, so all the new additions as well as all
			// the quads of the Dep:deprecatedResource we like to add to the store
			public quadsToCreate(): N3.Quad[] {
			if (this.deprecatedResource) {
			return this._additions.concat(this._productiveOperations.additions, this._productiveOperations.listsToWrite, this.deprecatedResource.quads());
			} else {
			return this._additions.concat(this._productiveOperations.additions, this._productiveOperations.listsToWrite)
			}
			}

			public quadsToDelete(): N3.Quad[] {
			return [].concat(this._depTreeDeletions, this._productiveOperations.deletions);
			}

			public listDeletionQueries(): string[] {
			return this._productiveOperations.delListQueries;
			}
			}

NietzscheBeta/nietzsche-beta-app/src/app/rdf-editor-module/editor-resources.tsca2d5d21f796master

editor-resources.tsView Options

NietzscheBeta/nietzsche-beta-app/src/app/rdf-editor-module/editor-resources.ts
ca2d5d21f796master

editor-resources.ts
View Options