Diffusion Nietzsche-Beta-App (master) Browse

crossref-editor-data-service.service.ts
7f5c885769c2master

crossref-editor-data-service.service.ts
View Options

			import {EventEmitter, Injectable} from '@angular/core';
			import {ActivatedRoute} from '@angular/router';
			import { RQ_CROSSREF_TREE_LINES } from '../../constants';
			import {QueryService} from '../../services/query.service';
			import {moveItemInArray} from '@angular/cdk/drag-drop';
			import {NavigationEntity} from '../../navigation-list-component/models';
			import {TlnLine} from '../../tln-edition/datatypes/line';
			import {PageViewService} from '../../page-view/page-view.service';
			import {TlnQueryServiceInterface} from '../../tln-edition/models';
			import {SafeUrl} from '@angular/platform-browser';
			import {ChangeMgmntDef, TlnPredicate} from '../statement-handler';
			import {RdfData, RdfStoredData} from '../rdf-editor-DataSets';
			import {TlnResource, TlnTransaction} from '../editor-resources';

			@Injectable({
			providedIn: 'root'
			})
			export class CrossrefEditorDataServiceService {

			textGenesis: TextGenesis; // the one textGenesis used by all components
			textGenesisEmitter: EventEmitter<TextGenesis>;
			transaction = TlnTransaction;
			def: ChangeMgmntDef;


			queryService: TlnQueryServiceInterface;
			queryServiceEmitter: EventEmitter<TlnQueryServiceInterface>;


			constructor(private activatedRoute: ActivatedRoute,
			private qService: QueryService,
			private pageViewService: PageViewService) {
			this.queryServiceEmitter = new EventEmitter<TlnQueryServiceInterface>();
			this.textGenesisEmitter = new EventEmitter<TextGenesis>();
			// creating a def: keep the patient statements as they got deleted by their agents anyway
			this.def = new ChangeMgmntDef(
			true,
			true,
			false,
			false,
			true,
			[],
			[],
			[],
			[],
			false,
			{keepAgentLists: false, keepAgentStatements: false, keepPatientLists: true, keepPatientStatements: true}
			);
			// subcsribing at clicked lines to set them as selection
			this.pageViewService.onClickedLine.subscribe((clickedLine: TlnLine) => {
			if (clickedLine.page === this.textGenesis.checkedOutChild().internalTextVersion.checkedOutChild().textUnit.pageData.pageIri) {
			this.setLine(clickedLine);
			this.updateAll(this.textGenesis);
			}
			});
			}

			readInTextGenesis(textGenesisIri: string) {
			textGenesisIri = 'http://rdfh.ch/projects/0068#_Mp_XIV_TextGenesis0'; // Todo: make generic
			TextGenesis.buildAsyncFromStore(this.qService, textGenesisIri).then(textGenesis =>
			this.updateAll(textGenesis));
			}

			createNewTextGenesis(manuscriptIri: string) {
			this.textGenesis = new TextGenesis('TextGenesis', '', manuscriptIri, true);
			// also adding new text version
			const version = GuiTextVersion.createNew(this.textGenesis.iri(), 0);
			this.textGenesis.addNewChild(version, this.textGenesis.childResources().length);
			this.updateAll(this.textGenesis);
			}

			resetFromStore() {
			TextGenesis.buildAsyncFromStore(this.qService, this.textGenesis.iri()).then(textGenesis =>
			this.updateAll(textGenesis));
			}

			// sets the lines: if start and end are existing it resets the startline else sets the endline
			setLine(line: TlnLine) {
			// get the active page ...
			if (!this.textGenesis.checkedOutChild().internalTextVersion.checkedOutChild().textUnit.hasStartLine() \|\| (
			this.textGenesis.checkedOutChild().internalTextVersion.checkedOutChild().textUnit.hasStartLine() &&
			this.textGenesis.checkedOutChild().internalTextVersion.checkedOutChild().textUnit.hasEndLine())
			) {
			this.textGenesis.checkedOutChild().internalTextVersion.checkedOutChild().textUnit.setStartLine(line.id, line.number);
			} else { // endLine must be set
			this.textGenesis.checkedOutChild().internalTextVersion.checkedOutChild().textUnit.setEndLine(line.id, line.number);
			}
			}

			updateAll(textGenesis: TextGenesis) {
			this.textGenesis = textGenesis;
			this.textGenesisEmitter.emit(textGenesis);
			}

			// sets the textVersion to external/internal and checksout/unchecks the active one.
			setExternalityOfTextVersion(setToExternal: boolean) {
			this.textGenesis.checkedOutChild().changeExternity(setToExternal);
			this.updateAll(this.textGenesis);
			}

			public deleteGuiTextVersion(iri) {
			this.textGenesis.deleteChild(iri);
			this.updateAll(this.textGenesis);
			}

			public unDeleteGuiTextVersion(iri) {
			this.textGenesis.undeleteChild(iri);
			this.updateAll(this.textGenesis);
			}


			// builds a GuiTextUnit with the added and queried pages data and adds it to the textVersion
			onAddingPage(navItem: NavigationEntity, index: number) {
			GuiTextUnit.createNewGuiTextUnit(this.qService, navItem.tlnEntity.iri, 'Texteinheit', this.textGenesis.checkedOutChild().iri(), true, navItem.parentLabel)
			.then(guiTextUnit => {
			if (this.wholePageHandlingDisAllowed(guiTextUnit.iri())) { // guard if page is already as wholePage in the textversion
			return;
			}
			// if the given guitextUnit (its iri) is not yet in the guitextUnits array of the textVersion we add it
			this.textGenesis.checkedOutChild().internalTextVersion.addNewChild(guiTextUnit, index);
			this.updateAll(this.textGenesis);
			});
			}

			onMovePage(previousIndex: number, index: number) {
			this.textGenesis.checkedOutChild().internalTextVersion.moveChildInChildren(previousIndex, index);
			this.updateAll(this.textGenesis);
			}

			onRemovePage(iri: string) {
			this.textGenesis.checkedOutChild().internalTextVersion.deleteChild(iri);
			this.updateAll(this.textGenesis);
			}

			undeleteGuiTextUnit(iri: string) {
			// guard if there is already a guiTextUnit with the same page and wholepage === true
			if (this.wholePageHandlingDisAllowed(iri)) { return; }
			this.textGenesis.checkedOutChild().internalTextVersion.undeleteChild(iri);
			this.updateAll(this.textGenesis);
			}

			// resets wholepage: boolean to the desired truthVal
			changeWholePage(guiTextUnit: GuiTextUnit, truthVal) {
			if (this.textGenesis.checkedOutChild().internalTextVersion.checkedOutChild().wholePage === truthVal) {
			return;
			} // guard if truthval is already set accordingly
			if (truthVal) {
			// If we like to change to wholePage === true we impose a guard in case the page is already present
			// as wholePage via check if wholePageHandlingDisAllowed()
			if (this.wholePageHandlingDisAllowed(guiTextUnit.textUnit._belongsToPage)) {
			return;
			}
			}
			this.textGenesis.checkedOutChild().changeWholePage(guiTextUnit.textUnit, truthVal);
			this.updateAll(this.textGenesis);
			}

			// checks whether a given guiTextUnits is already as whole page in the checked out list and if that guiTextUnit is
			// wholePage === true && not
			// deleted (if it is present but deleted, it is allowed)
			wholePageHandlingDisAllowed(pageIri: string): boolean {
			let disAllowed = false;
			const guiTextUnits = this.textGenesis.checkedOutChild().internalTextVersion.childResources();
			// in case of undeleting the passed guiTextVersion it is already in the array - but deleted - which is allowed.
			// Therefore we need to check via some if there are any other guiTextUnits which the same iri having
			// wholePage == true and which are not deleted. In that case the handling is disallowed.
			if (guiTextUnits.some(u => u.iri() === pageIri && u.wholePage && !u.deleted())) {
			disAllowed = true;
			const errMsg = `Seite ${pageIri} (ganze Seite) befindet sich bereits in der Textversion.`;
			console.warn(errMsg);
			window.alert(errMsg);
			}
			return disAllowed;
			}

			// collects all tlnResources which have to be added, changed, deleted into one array
			getPayLoad(): TlnResource[] {
			const resources: TlnResource[] = [];
			resources.push(this.textGenesis.resource);
			this.textGenesis.childResources().forEach(child => {
			resources.push(child.externalTextVersion.resource); // add ext resource
			resources.push(child.internalTextVersion.resource); // int resource
			child.internalTextVersion.childResources().forEach(iChild => {
			resources.push(iChild.textUnit.resource);
			});
			});
			return resources;
			}
			}

			// main super class with basic functionality inherited by all gui classes
			export class CrossRefEditorElement {
			protected _iri: string;
			private _checkedOut: boolean; // wether the thing is checked out for editing atm or not.
			protected _paerentIri: string;
			protected _label: string;
			protected _parentLabel: string;
			resource: TlnResource; // the equivalent rdf resource from store and for editing
			childsPredicate: TlnPredicate;
			protected _childResources: CrossRefEditorElement[] = []; // Other CrossrefEditorElements or a subclass/extension
			protected _deleted = false;
			public displayedPredicates: string[];
			public mutablePredicates: string[];

			// Todo: refactor: set label inside subclasses - not via passing a parameter?
			constructor(iri?: string, label?: string, parentIri?: string, checkOut = false, parentLabel?: string){
			if (iri !== '') {
			this._iri = iri;
			} else {// any random iri - does not matter
			this._iri = RdfData.createIri(label); }
			this._label = label;
			this._paerentIri = parentIri;
			this._checkedOut = checkOut;
			this._parentLabel = parentLabel;
			this.resource = new TlnResource(this._iri, label);
			}

			checkOut(val: boolean) {
			this._checkedOut = val;
			}

			isCheckedOut() {
			return this._checkedOut;
			}

			iri() {
			return this._iri;
			}

			public rdfTypeInStore(): string {
			return this.resource._rdfDatasetFromStore.rdfType();
			}

			deleted() {
			return this._deleted;
			}

			// sets itself to deleted and runs deletion for each child
			setDeleted() {
			this._deleted = true;
			this.resource.setDeleted(); // set the whole resource to deleted = true
			this.checkOut(false);
			if (!this._childResources \|\| !this._childResources.length) { return; } // guard; else deletes also all children recursively
			this._childResources.forEach(child => {
			child.setDeleted(); // run deletion also for children
			child.checkOut(false);
			});
			}

			// sets itself to undeleted and undeletes each child of childresources
			setUndeleted() {
			this._deleted = false;
			this.resource.setUndeleted();
			if (!this._childResources \|\| !this._childResources.length) {return} // guard; else deletes also all children recursively
			this._childResources.forEach(child => {
			child.setUndeleted(); // run also for children
			});
			}

			// adds a child to the childresources array and puts a statement accordingly
			addNewChild(child: any, index: number = this._childResources.length - 1 ) {
			this._childResources.splice(index, 0, child);
			this.resource._rdfDatasetToEdit.putStatementInListAsStatement(this.childsPredicate, child.iri(), index);
			}

			childResources(): any[] {
			return this._childResources;
			}

			hasChildren(): boolean {
			return this._childResources.length > 0;
			}

			// sets/updates the childresources array with the passed child if it is checkedOut. Sets also the statements accordingly.
			setChild(child: any) {
			const idx = this.getChildIndex(child.iri());
			if (!this._childResources[idx].isCheckedOut()) { // guard
			console.warn('Child not checked out. Cannot update the child ', child.iri());
			return;
			}
			this._childResources[idx] = child;
			this.resource._rdfDatasetToEdit.setStatementInListAsStatement(this.childsPredicate, child.iri(), idx);
			}

			deleteChild(iri: string) {
			const idx = this._childResources.findIndex(c => c.iri() === iri);
			// setting both to deleted - no matter whats the type
			this._childResources[idx].setDeleted();
			this.resource._rdfDatasetToEdit.deleteAllStatementsWithObject(iri);
			}

			// undeletes a child and checks it out for editing
			undeleteChild(iri: string) {
			const idx = this.getChildIndex(iri);
			this._childResources[idx].setUndeleted();
			this.resource._rdfDatasetToEdit.putStatementInListAsStatement(this.childsPredicate, iri, idx);
			this.checkOutChildByIndex(idx);
			}

			// returns the index of the child with the given iri
			getChildIndex(iri: string): number {
			return this._childResources.findIndex(c => c.iri() === iri);
			}

			getChild(iri: string) {
			return this._childResources[this.getChildIndex(iri)]
			}

			// Checks out the child with the given iri.
			checkoutChild(iri: string) {
			const idx = this.getChildIndex(iri);
			this.checkOutChildByIndex(idx);
			}

			// Checks out the child with the given index and unchecks all others.
			checkOutChildByIndex(idx: number) {
			for (let i = 0; i <= this._childResources.length - 1; i++) {
			if (i === idx) { this._childResources[i].checkOut(true); } else {
			this._childResources[i].checkOut(false);
			}
			}
			}

			checkedOutChild(): any {
			return this._childResources[this.checkedOutChildIdx()];
			}

			// returns the idx of the child which is checked out
			checkedOutChildIdx(): number {
			return this._childResources.findIndex(c => c.isCheckedOut());
			}

			moveChildInChildren(previousIndex: number, newIndex: number) {
			moveItemInArray(this._childResources, previousIndex, newIndex);
			this.resource._rdfDatasetToEdit.moveObjectInListAsStatement(this.childsPredicate.iri(), previousIndex, newIndex);
			}

			// check for completeness
			isComplete() {
			return this._childResources.every(c => c.isComplete());
			}
			}

			// Instances of this class can be injected into data and query services
			@Injectable()
			export class ConnectionConfig {
			endPoint: string;
			accessToken: string;
			}


			export class TextGenesis extends CrossRefEditorElement {
			_childResources: GuiTextVersion[] = []; // redefining the childrens type

			constructor(iri: string, label?: string, parentIri?: string, checkOut = false) {
			super(iri, label, parentIri, checkOut);
			this.setChildsPredicate();
			}

			public static async buildAsyncFromStore(qService: QueryService, iri: string): Promise<TextGenesis> {
			const textGenesis = new TextGenesis(iri, 'Textgenese');
			textGenesis.resource = await TlnResource.buildFromStoreAsync(qService, iri, 'TextGenesis');
			const children = await textGenesis.resource.getChildIris(textGenesis.childsPredicate.iri());
			if (!children) {return textGenesis} // guard; else we create children
			children.forEach((child, index) => {
			GuiTextVersion.buildAsyncFromStore(qService, child, index, iri).then(guiTV => {
			textGenesis._childResources.push(guiTV);
			// sorting in acc. to the index
			textGenesis._childResources = textGenesis._childResources.sort(({index: a}, {index: b}) => a - b); });
			});
			return textGenesis;
			}

			setChildsPredicate() {
			const ranges = new Set<string>().add('http://www.w3.org/1999/02/22-rdf-syntax-ns#List');
			this.childsPredicate = new TlnPredicate('http://www.nie.org/ontology/nietzsche#hasGeneticOrder', ranges);
			}

			// accessor method returning GuiTextVersion "typed" children
			childResources(): GuiTextVersion[] {
			return super.childResources();
			}

			isComplete(): boolean {
			return this._childResources.every(c => c.isComplete());
			}
			}

			export class GuiTextVersion extends CrossRefEditorElement {
			public isExternalResource: boolean;
			private changedExternity: boolean;
			internalTextVersion: InternalTextVersion; // the internal TextVersion Resource with its properties from RDF
			externalTextVersion: ExternalTextVersion; // the internal TextVersion Resource with its properties from RDF
			index: number; // for sorting

			private constructor(iri: string, // iri of internal or external resource
			label: string,
			parentIri: string,
			checkOut = false,
			isExternalResource = false,
			parentLabel?) {
			super(iri, label, parentIri, checkOut, parentLabel);

			this.isExternalResource = isExternalResource;
			this.changedExternity = false;
			}

			// async builder from data in the triple store
			public static async buildAsyncFromStore(qService: QueryService, iri: string, index: number, parentIri?: string, parentLabel?: string): Promise<GuiTextVersion> {
			const guiTextVersion = new GuiTextVersion(iri, 'TextVersion', parentIri, false, false, parentLabel);
			guiTextVersion.index = index;
			guiTextVersion.isExternalResource = await guiTextVersion.isExternalAsync(qService, iri);

			if (guiTextVersion.isExternalResource) {
			guiTextVersion.externalTextVersion = await ExternalTextVersion.buildAsyncFromStore(qService, iri, parentIri);
			// creating also an internal one, but set it to deleted for switching easily
			guiTextVersion.internalTextVersion = new InternalTextVersion('', 'Textversion', parentIri);
			// set the resource to deleted because it should be ignored if not switched to internal
			guiTextVersion.internalTextVersion.setDeleted();
			} else {
			guiTextVersion.internalTextVersion = await InternalTextVersion.buildAsyncFromStore(qService, iri, parentIri);
			// building also a new external one and set it to deleted
			guiTextVersion.externalTextVersion = new ExternalTextVersion('', 'TextVersion', parentIri);
			guiTextVersion.externalTextVersion.setDeleted(); // set to deleted because we like to ignore it unless switched to external
			}
			return guiTextVersion;
			}

			// custom builder
			public static createNew(parentIri: string, index: number, parentLabel?: string) {
			const guiTextVersion = new GuiTextVersion('', 'Textversion', parentIri, true, false, parentLabel);
			guiTextVersion.index = index;
			guiTextVersion.externalTextVersion = new ExternalTextVersion(guiTextVersion.iri(), 'TextVersion', parentIri);
			guiTextVersion.internalTextVersion = new InternalTextVersion(guiTextVersion.iri(), 'Textversion', parentIri );
			return guiTextVersion;
			}

			public async isExternalAsync(qService, iri) {
			const type = await RdfStoredData.getRdfTypeFromStore(qService, iri);
			return type === 'http://www.nie.org/ontology/nietzsche#ExternalTextUnit';
			}

			isComplete() {
			if (this.isExternalResource) { return this.externalTextVersion.isComplete(); } else {
			return this.internalTextVersion.isComplete();
			}
			}

			changeExternity(isExternal: boolean) {
			this.isExternalResource = isExternal;
			if (isExternal) { // changed to external
			// change deletions
			this.internalTextVersion.setDeleted();
			if (this.externalTextVersion.resource.isInStore()) {
			this.externalTextVersion.setUndeleted();
			}
			this.externalTextVersion.checkOut(true);
			this.internalTextVersion.checkOut(false);
			} else { // chenged to internal
			this.externalTextVersion.setDeleted();
			if (this.internalTextVersion.resource.isInStore()) {
			this.internalTextVersion.setUndeleted()
			}
			this.internalTextVersion.checkOut(true);
			this.externalTextVersion.checkOut(false);
			}
			this.changedExternity = !this.changedExternity;
			}

			changeWholePage(textUnit: TextUnit, truthVal: boolean) {
			this.internalTextVersion.checkedOutChild().setWholePage(truthVal);
			const idx = this.internalTextVersion.getChildIndex(textUnit.iri());
			const predicate = this.internalTextVersion.childsPredicate;
			// If wholePage Changes we have to change the the list statements because of the ontology:
			if (truthVal) { // If wholePage = true, there is the page iri to store in the list
			// resetting link to child
			this.internalTextVersion.resource._rdfDatasetToEdit.setStatementInListAsStatement(predicate, textUnit._belongsToPage, idx);
			// setting wholePage of child
			} else {
			// resetting link to child
			this.internalTextVersion.resource._rdfDatasetToEdit.setStatementInListAsStatement(predicate, textUnit.iri(), idx); }
			}

			checkedOutChild(): GuiTextUnit {
			return super.checkedOutChild();
			}

			// simply set everything to deleted - no matter if in use or not
			setDeleted() {
			super.setDeleted(); // do standard deletion
			// and also delete the custom children of a GuiTextVersion
			this.internalTextVersion.setDeleted();
			this.externalTextVersion.setDeleted();
			}

			setUndeleted() {
			super.setUndeleted();
			if (this.isExternalResource) {
			this.externalTextVersion.setUndeleted();
			} else {
			this.internalTextVersion.setUndeleted();
			}
			}

			hasChangedExternity(): boolean {
			return this.changedExternity;
			}
			}

			export class InternalTextVersion extends CrossRefEditorElement{

			_childResources: GuiTextUnit[] = []; // resetting the type of the cildren
			constructor(iri: string,
			label?: string,
			parentIri?: string,
			checkOut = false) { // iri?: string, label?: string, parentIri?: string, checkOut = false
			super(iri, label, parentIri, checkOut);
			this.setChildsPredicate();
			}

			// builds an internalTextVersion
			public static async buildAsyncFromStore(qService: QueryService, iri: string, parentIri?: string): Promise<InternalTextVersion> {
			const intVersion = new InternalTextVersion(iri, 'Interne TextVersion', parentIri);
			intVersion.resource = await TlnResource.buildFromStoreAsync(qService, iri, 'TextVersion');
			const children = await intVersion.resource.getChildIris(intVersion.childsPredicate.iri());
			if (!children \|\| children.length === 0 ) {return intVersion} // guard
			children.forEach((child, index) => {
			GuiTextUnit.buildAsyncFromStore(qService, child, 'Texteinheit', parentIri).then( guiTextUnit => {
			intVersion._childResources.splice(index, 0, guiTextUnit);
			});
			}
			);
			return intVersion;
			}

			private setChildsPredicate() {
			const ranges = new Set<string>();
			ranges.add('http://www.w3.org/1999/02/22-rdf-syntax-ns#List');
			this.childsPredicate = new TlnPredicate('http://www.nie.org/ontology/nietzsche#identifiesAsVersion', ranges);
			}

			// accessor method returning GuiTextUnit "typed" children
			childResources(): GuiTextUnit[] {
			return super.childResources();
			}

			checkedOutChild(): GuiTextUnit {
			return super.checkedOutChild();
			}

			pagesCollection() {
			return this._childResources.map(guiTextUnit => guiTextUnit.textUnit.pageData);
			}

			// simple check for completeness
			isComplete() {
			return true;
			//return (this.textUnits().length && this.textUnits().every(u =>
			// u.startLine() !== undefined && u.endLine() !== undefined \|\| u.wholePage ));
			}
			}


			export class ExternalTextVersion extends CrossRefEditorElement {
			hasUrl: string;
			hasTitle: string;
			hasTitleP: TlnPredicate;
			hasUrlP: TlnPredicate;

			constructor(iri?: string,
			label?: string,
			parentIri?: string,
			checkOut = false ) {
			super(iri, label, parentIri, checkOut);
			this.hasTitleP = new TlnPredicate('http://www.nie.org/ontology/nietzsche#textUnitHasTitle', new Set(['http://www.w3.org/2001/XMLSchema#string']));
			this.hasUrlP = new TlnPredicate('http://www.nie.org/ontology/nietzsche#textUnitHasUrl', new Set(['http://www.w3.org/2001/XMLSchema#string']));

			}

			public static async buildAsyncFromStore(qService: QueryService, iri: string, parentIri): Promise<ExternalTextVersion> {
			const extVersion = new ExternalTextVersion(iri, 'TextVersion', parentIri);
			extVersion.resource = await TlnResource.buildFromStoreAsync(qService, iri, 'Externe Textversion');
			extVersion.hasTitle = extVersion.resource.rdfDatasetFromStore().getFirstObject('http://www.nie.org/ontology/nietzsche#textUnitHasTitle');
			extVersion.hasUrl = extVersion.resource.rdfDatasetFromStore().getFirstObject('http://www.nie.org/ontology/nietzsche#textUnitHasUrl');
			return extVersion;
			}

			// Checks whether the passed string starts either with http:// or https://
			static isValidHttpUrl(str): boolean {
			let url;
			try {
			url = new URL(str);
			} catch (_) {
			return false;
			}
			return url.protocol === "http:" \|\| url.protocol === "https:";
			}

			// simple check for basic completeness
			isComplete() {
			return this.hasUrl && this.hasTitle && ExternalTextVersion.isValidHttpUrl(this.hasUrl);
			}

			setTitle(title: string) {
			this.hasTitle = title;
			this.resource._rdfDatasetToEdit.setStatement(this.hasTitleP, title, 0);
			}

			setUrl(url: string) {
			this.hasUrl = url;
			this.resource._rdfDatasetToEdit.setStatement(this.hasUrlP, url, 0);
			}
			}

			// wrapper class
			export class GuiTextUnit extends CrossRefEditorElement {
			textUnit: TextUnit;
			wholePage: boolean;

			constructor(iri, label: string, parentIri?: string, checkOut = true, wholePage = true, parentLabel?: string) {
			super(iri, label, parentIri, checkOut);
			this.wholePage = wholePage;
			this._parentLabel = parentLabel;
			this.displayedPredicates = ['http://www.nie.org/ontology/nietzsche#belongsToPage']; //
			}

			// async builder
			static async buildAsyncFromStore(qService: QueryService, iri: string, label, parentIri?: string, parentLabel?: string) {
			const guiTextUnit: GuiTextUnit = new GuiTextUnit(iri, label, parentIri, false, true, parentLabel);
			if (!await GuiTextUnit.isPageAysnc(qService, iri)) { // if the thing is a textUnit
			guiTextUnit.textUnit = await TextUnit.buildFromStoreAsync(qService, iri);
			guiTextUnit.wholePage = false; // default is true, so we have to set it here
			}
			if (await GuiTextUnit.isPageAysnc(qService, iri)) { // if the thing is a page
			// the thing is a page, the iri passed a pages iri, but we already add a new textUnit
			// in every case so it can be switched easily to that created one
			const pageData = await TlnCrossrefPage.buildFromStoreAsync(qService, iri, parentLabel);
			guiTextUnit.textUnit = TextUnit.createNewTextUnit(pageData.pageIri, pageData, parentIri, parentLabel);
			guiTextUnit.textUnit.setDeleted(); // set the textUnit to deleted hence there is no textUnit if it is wholepage
			}
			return guiTextUnit;
			}

			static async createNewGuiTextUnit(qService, pageIri, label, parentIri, checkOut = true, parentLabel?: string) {
			const guiTextUnit: GuiTextUnit = new GuiTextUnit(pageIri, label, parentIri, checkOut);
			const pageData = await TlnCrossrefPage.buildFromStoreAsync(qService, pageIri, parentIri);
			guiTextUnit.textUnit = TextUnit.createNewTextUnit(pageIri, pageData, parentIri, parentLabel);
			guiTextUnit.textUnit.setDeleted(); // set the textUnit to deleted hence there is no textUnit if it is wholepage
			return guiTextUnit;
			}

			static async isPageAysnc(qService, iri) {
			const type = await RdfStoredData.getRdfTypeFromStore(qService, iri);
			return type === 'http://www.nie.org/ontology/nietzsche#Page';
			}

			// resets the wholePage boolean and changes the iri according to the chosen state (wholepage means that there is not a textUnit -
			// it is a page)
			setWholePage(truthVal: boolean) {
			this.wholePage = truthVal;
			if (truthVal) {
			// if wholePage === true then there is only a link to the page and no textUnit at all. So we set the iri to the pages Iri and the
			// textUnit to deleted
			this._iri = this.textUnit.pageData.pageIri;
			this.textUnit.setDeleted();
			} else {
			this._iri = this.textUnit.iri();
			this.textUnit.setUndeleted();
			}
			}

			// Overrides the setDeleted method by running also deletion of this.textUnit
			setDeleted() {
			super.setDeleted();
			this.textUnit.setDeleted();
			}

			// Overrides the setUnDeleted method by running also unDeletion of this.textUnit
			setUndeleted() {
			super.setUndeleted();
			this.textUnit.setUndeleted();
			}
			}

			export class TextUnit extends CrossRefEditorElement {
			_belongsToPage: string;
			private _startLine?: string;
			private _endLine?: string;
			pageData: TlnCrossrefPage;
			displayedLabel: string;
			displayedStartLine: number;
			displayedEndLine: number;
			selectedLines: string[];
			startLinePredicate: TlnPredicate;
			endLinePredicate: TlnPredicate;
			belongsToPagePredicate: TlnPredicate;


			constructor(iri: string,
			label: string,
			pageData?: TlnCrossrefPage,
			parentIri: string = '',
			checkOut = false,
			parentLabel?: string,
			startLine?: string,
			endLine?: string,
			startLineNumber?: number,
			endLineNumber?: number) {
			super(iri, label, parentIri, checkOut, parentLabel);
			// this.rdfsType= 'http://www.nie.org/ontology/nietzsche#PartOfPageTextUnit';
			this.startLinePredicate = new TlnPredicate('http://www.nie.org/ontology/nietzsche#startLine',
			new Set(['http://www.w3.org/2001/XMLSchema#string']));
			this.endLinePredicate = new TlnPredicate('http://www.nie.org/ontology/nietzsche#endLine',
			new Set(['http://www.w3.org/2001/XMLSchema#string']));
			this.belongsToPagePredicate = new TlnPredicate('http://www.nie.org/ontology/nietzsche#belongsToPage',
			new Set(['http://www.w3.org/2001/XMLSchema#string']));
			this.pageData = pageData;
			this._startLine = startLine;
			this._endLine = endLine;
			this.selectedLines = [];
			this.setLines(startLine, startLineNumber, endLine, endLineNumber);
			}

			static async buildFromStoreAsync(qService: QueryService, iri) {
			const textUnit = new TextUnit(iri, 'Texteinheit' );
			textUnit.resource = await TlnResource.buildFromStoreAsync(qService, iri);
			textUnit._belongsToPage = textUnit.resource.rdfDatasetFromStore().getFirstObject(textUnit.belongsToPagePredicate.iri());
			textUnit.pageData = await TlnCrossrefPage.buildFromStoreAsync(qService, textUnit._belongsToPage);
			textUnit._startLine = textUnit.resource.rdfDatasetFromStore().getFirstObject(textUnit.startLinePredicate.iri());
			textUnit.displayedStartLine = textUnit.getLineNumber(textUnit._startLine);
			textUnit._endLine = textUnit.resource.rdfDatasetFromStore().getFirstObject(textUnit.endLinePredicate.iri());
			textUnit.displayedEndLine = textUnit.getLineNumber(textUnit._endLine);
			textUnit.setSelectedLines(textUnit._startLine, textUnit._endLine);
			return textUnit;
			}

			// creates a new TextUnit which is not yet in store
			static createNewTextUnit(pageIri: string, pageData: TlnCrossrefPage, parentIri: string, parentLabel: string) {
			const textUnit = new TextUnit('', 'Texteinheit', pageData, parentIri, false, parentLabel);
			textUnit._belongsToPage = pageIri;
			const a = new TlnPredicate('http://www.w3.org/1999/02/22-rdf-syntax-ns#type');
			textUnit.resource._rdfDatasetToEdit.statements().putAgentStatement(a, 'http://www.nie.org/ontology/nietzsche#PartOfPageTextUnit');
			textUnit.resource._rdfDatasetToEdit.statements().putAgentStatement(textUnit.belongsToPagePredicate, pageIri);
			return textUnit;
			}

			// returns the lineNumber for a given lineIri
			getLineNumber(lineIri: string) {
			return this.pageData.lineData[this.pageData.lineData.findIndex(l => l.line === lineIri)].lNumber;
			}

			setLines(sLine: string, sLineNo: number, eLine: string, eLineNo: number){
			if (sLine && sLineNo && eLine && eLineNo) {
			this.setStartLine(sLine, sLineNo);
			this.setEndLine(eLine, eLineNo);
			this.setSelectedLines(sLine, eLine);
			}
			}

			startLine() {
			return this._startLine
			}

			hasStartLine() {
			return this._startLine !== undefined && this._startLine !== null
			}

			endLine() {
			return this._endLine
			}

			hasEndLine() {
			return this._endLine !== undefined && this._endLine !== null
			}

			// sets the selected lines for highlighting/passing to tln-page-view only
			public setSelectedLines(startLine: string, endLine?: string) {
			if (!endLine) {
			this.selectedLines = [this.startLine()]
			} else {
			let started = false;
			let ended = false;
			this.pageData.lineData.forEach(line => {
			if (line.line === startLine) {
			started = true; }
			if (line.line === endLine) {
			this.selectedLines.push(line.line);
			ended = true; }
			if (started && !ended) {
			this.selectedLines.push(line.line);
			}
			});

			}
			}

			// sets or resets the startLine depending on its existance
			setStartLine(startLine: string, lineNumber: number) {
			this._startLine = startLine;
			this.displayedStartLine = lineNumber;
			this.setSelectedLines(this.startLine());
			if (this.endLine()) {this.deleteEndLine();}// resetting the startline must delete the selected endline
			if (this.resource._rdfDatasetToEdit.hasStatementEntriesForPredicate(this.startLinePredicate.iri())) {
			this.resource._rdfDatasetToEdit.setStatement(this.startLinePredicate, startLine, 0);
			} else {this.resource._rdfDatasetToEdit.putStatement(this.startLinePredicate, startLine);}
			}

			setEndLine(endLine: string, lineNumber: number) {
			this._endLine = endLine;
			this.displayedEndLine = lineNumber;
			this.setSelectedLines(this.startLine(), endLine);
			if (this.resource._rdfDatasetToEdit.hasStatementEntriesForPredicate(this.endLinePredicate.iri())) {
			this.resource._rdfDatasetToEdit.setStatement(this.endLinePredicate, endLine, 0);
			} else {this.resource._rdfDatasetToEdit.putStatement(this.endLinePredicate, endLine);}
			}

			deleteEndLine() {
			this._endLine = null;
			this.displayedEndLine = null;
			}
			}

			export interface Line {
			line: string;
			lNumber: number;
			}

			export class TlnCrossrefPage {
			lineData: Line[];
			deleted = false;
			constructor(public pageIri: string,
			public pageNumber?: number,
			public thumb?: SafeUrl,
			public svg?: SafeUrl,
			public manuscript?: string) {
			}

			// async builder
			public static async buildFromStoreAsync(qService: QueryService, pageIri: string, manuscript?: string): Promise<TlnCrossrefPage> {
			const query = QueryService.bindVariableWithIri(PAGE_PREVIEW_RQ, 'page', pageIri);
			const crossRefPage = await qService.editingEndPoint.getData(query,'SELECT')
			.then( pageData => {
			if (!qService.hasContent(pageData)) {
			console.warn('empty response for ', query); return; }
			const page = pageData['results']['bindings'][0];
			const pageNumber = page['pageNumber'] && page['pageNumber']['value']? page['pageNumber']['value']: '';
			const thumb = page['thumb'] && page['thumb']['value']? page['thumb']['value']: '';
			const svg = page['svgUrl'] && page['svgUrl']['value']? page['svgUrl']['value']: '';
			return new TlnCrossrefPage(pageIri, pageNumber, thumb, svg, manuscript);
			});
			crossRefPage.lineData = await TlnCrossrefPage.getLineData(pageIri, qService);
			return crossRefPage;
			}
			// sets the lineData available for the checked out textUnit
			public static async getLineData(pageIri: string, qService: QueryService) {
			const lines = await TlnCrossrefPage.getLinesFromStore(pageIri, qService);
			return lines.map(line => {
			return {line: line['line']['value'], lNumber: line['lNumber']['value']}
			});
			}

			public static async getLinesFromStore(pageIri: string, qService: QueryService): Promise<string[]> {
			const query = qService.parametrizeWhereClauseWithItems(RQ_CROSSREF_TREE_LINES, pageIri, '', '');
			return await qService.editingEndPoint.getData(query, 'SELECT').then(res => {
			return res['results']['bindings'];
			});
			}
			}

			export const PAGE_PREVIEW_RQ = `
			PREFIX tln: <http://www.nie.org/ontology/nietzsche#>
			PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
			PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
			SELECT DISTINCT ?page ?pageNumber ?image ?svgUrl ?thumb WHERE {
			?page ?p ?o.
			OPTIONAL {
			?page tln:hasNumber ?pageNumber.
			?page tln:hasSvgImage ?svg.
			?svg tln:hasPrimaryurl ?svgUrl.
			?page tln:hasFaksimileImage ?image.
			?image tln:hasFileName ?imgLabel;
			tln:hasPrimaryurl ?primaryUrl;
			tln:hasThumburl ?thumb;
			}
			}`;

NietzscheBeta/nietzsche-beta-app/src/app/rdf-editor-module/crossref-editor-component/crossref-editor-data-service.service.ts7f5c885769c2master

crossref-editor-data-service.service.tsView Options

NietzscheBeta/nietzsche-beta-app/src/app/rdf-editor-module/crossref-editor-component/crossref-editor-data-service.service.ts
7f5c885769c2master

crossref-editor-data-service.service.ts
View Options