2018-08-29 20:44:35 +02:00
<!DOCTYPE html>
< html lang = "en" >
< head >
< meta charset = "utf-8" >
< title > JSDoc: Source: entities/note_short.js< / title >
< script src = "scripts/prettify/prettify.js" > < / script >
< script src = "scripts/prettify/lang-css.js" > < / script >
<!-- [if lt IE 9]>
< script src = "//html5shiv.googlecode.com/svn/trunk/html5.js" > < / script >
<![endif]-->
< link type = "text/css" rel = "stylesheet" href = "styles/prettify-tomorrow.css" >
< link type = "text/css" rel = "stylesheet" href = "styles/jsdoc-default.css" >
< / head >
< body >
< div id = "main" >
< h1 class = "page-title" > Source: entities/note_short.js< / h1 >
< section >
< article >
2018-12-22 22:28:49 +01:00
< pre class = "prettyprint source linenums" > < code > import server from '../services/server.js';
2019-08-20 21:40:47 +02:00
import Attribute from './attribute.js';
2019-10-26 10:00:26 +02:00
import branches from "../services/branches.js";
2018-12-22 22:28:49 +01:00
const LABEL = 'label';
const LABEL_DEFINITION = 'label-definition';
const RELATION = 'relation';
const RELATION_DEFINITION = 'relation-definition';
/**
2019-10-06 21:35:26 +02:00
* FIXME: rethink how attributes are cached in Note entities since they are long lived inside the cache.
* Attribute cache should be limited to "transaction".
*
2018-08-29 20:44:35 +02:00
* This note's representation is used in note tree and is kept in TreeCache.
*/
class NoteShort {
2019-10-26 10:00:26 +02:00
/**
* @param {TreeCache} treeCache
* @param {Object.< string, Object>} row
* @param {Branch[]} branches - all relevant branches, i.e. where this note is either child or parent
*/
constructor(treeCache, row, branches) {
2018-08-29 20:44:35 +02:00
this.treeCache = treeCache;
/** @param {string} */
this.noteId = row.noteId;
/** @param {string} */
this.title = row.title;
/** @param {boolean} */
this.isProtected = row.isProtected;
/** @param {string} one of 'text', 'code', 'file' or 'render' */
this.type = row.type;
/** @param {string} content-type, e.g. "application/json" */
this.mime = row.mime;
/** @param {boolean} */
this.archived = row.archived;
2019-09-07 22:03:08 +02:00
/** @param {string} */
2018-08-29 20:44:35 +02:00
this.cssClass = row.cssClass;
2019-10-26 10:00:26 +02:00
/** @type {string[]} */
this.parents = [];
/** @type {string[]} */
this.children = [];
/** @type {Object.< string, string>} */
this.parentToBranch = {};
/** @type {Object.< string, string>} */
this.childToBranch = {};
for (const branch of branches) {
if (this.noteId === branch.noteId) {
this.parents.push(branch.parentNoteId);
this.parentToBranch[branch.parentNoteId] = branch.branchId;
}
else if (this.noteId === branch.parentNoteId) {
this.children.push(branch.noteId);
this.childToBranch[branch.noteId] = branch.branchId;
}
else {
throw new Error(`Unknown branch ${branch.branchId} for note ${this.noteId}`);
}
}
}
addParent(parentNoteId, branchId) {
if (!this.parents.includes(parentNoteId)) {
this.parents.push(parentNoteId);
}
this.parentToBranch[parentNoteId] = branchId;
}
addChild(childNoteId, branchId) {
if (!this.children.includes(childNoteId)) {
this.children.push(childNoteId);
}
this.childToBranch[childNoteId] = branchId;
const branchIdPos = {};
for (const branchId of Object.values(this.childToBranch)) {
branchIdPos[branchId] = this.treeCache.branches[branchId].notePosition;
}
this.children.sort((a, b) => branchIdPos[this.childToBranch[a]] < branchIdPos[this.childToBranch[b]] ? -1 : 1);
2018-08-29 20:44:35 +02:00
}
/** @returns {boolean} */
isJson() {
return this.mime === "application/json";
}
2019-09-07 22:03:08 +02:00
async getContent() {
// we're not caching content since these objects are in treeCache and as such pretty long lived
const note = await server.get("notes/" + this.noteId);
return note.content;
}
async getJsonContent() {
const content = await this.getContent();
try {
return JSON.parse(content);
}
catch (e) {
console.log(`Cannot parse content of note ${this.noteId}: `, e.message);
return null;
}
}
2018-08-29 20:44:35 +02:00
/** @returns {Promise< Branch[]>} */
async getBranches() {
2019-10-26 10:00:26 +02:00
const branchIds = Object.values(this.parentToBranch);
2018-08-29 20:44:35 +02:00
return this.treeCache.getBranches(branchIds);
}
/** @returns {boolean} */
hasChildren() {
2019-10-26 10:00:26 +02:00
return this.children.length > 0;
2018-08-29 20:44:35 +02:00
}
/** @returns {Promise< Branch[]>} */
async getChildBranches() {
2019-10-26 10:00:26 +02:00
const branchIds = Object.values(this.childToBranch);
2018-08-29 20:44:35 +02:00
2019-10-26 10:00:26 +02:00
return this.treeCache.getBranches(branchIds);
2018-08-29 20:44:35 +02:00
}
/** @returns {string[]} */
getParentNoteIds() {
2019-10-26 10:00:26 +02:00
return this.parents;
2018-08-29 20:44:35 +02:00
}
/** @returns {Promise< NoteShort[]>} */
async getParentNotes() {
2019-10-26 10:00:26 +02:00
return await this.treeCache.getNotes(this.parents);
2018-08-29 20:44:35 +02:00
}
/** @returns {string[]} */
getChildNoteIds() {
2019-10-26 10:00:26 +02:00
return this.children;
2018-08-29 20:44:35 +02:00
}
/** @returns {Promise< NoteShort[]>} */
async getChildNotes() {
2019-10-26 10:00:26 +02:00
return await this.treeCache.getNotes(this.children);
2018-08-29 20:44:35 +02:00
}
2018-12-22 22:28:49 +01:00
/**
* @param {string} [name] - attribute name to filter
* @returns {Promise< Attribute[]>}
*/
async getAttributes(name) {
if (!this.attributeCache) {
2019-08-20 21:40:47 +02:00
this.attributeCache = (await server.get('notes/' + this.noteId + '/attributes'))
.map(attrRow => new Attribute(this.treeCache, attrRow));
2018-12-22 22:28:49 +01:00
}
if (name) {
return this.attributeCache.filter(attr => attr.name === name);
}
else {
return this.attributeCache;
}
}
/**
* @param {string} [name] - label name to filter
* @returns {Promise< Attribute[]>} all note's labels (attributes with type label), including inherited ones
*/
async getLabels(name) {
return (await this.getAttributes(name)).filter(attr => attr.type === LABEL);
}
/**
* @param {string} [name] - label name to filter
* @returns {Promise< Attribute[]>} all note's label definitions, including inherited ones
*/
async getLabelDefinitions(name) {
return (await this.getAttributes(name)).filter(attr => attr.type === LABEL_DEFINITION);
}
/**
* @param {string} [name] - relation name to filter
* @returns {Promise< Attribute[]>} all note's relations (attributes with type relation), including inherited ones
*/
async getRelations(name) {
return (await this.getAttributes(name)).filter(attr => attr.type === RELATION);
}
/**
* @param {string} [name] - relation name to filter
* @returns {Promise< Attribute[]>} all note's relation definitions including inherited ones
*/
async getRelationDefinitions(name) {
return (await this.getAttributes(name)).filter(attr => attr.type === RELATION_DEFINITION);
}
/**
* @param {string} type - attribute type (label, relation, etc.)
* @param {string} name - attribute name
* @returns {Promise< boolean>} true if note has an attribute with given type and name (including inherited)
*/
async hasAttribute(type, name) {
return !!await this.getAttribute(type, name);
}
/**
* @param {string} type - attribute type (label, relation, etc.)
* @param {string} name - attribute name
* @returns {Promise< Attribute>} attribute of given type and name. If there's more such attributes, first is returned. Returns null if there's no such attribute belonging to this note.
*/
async getAttribute(type, name) {
const attributes = await this.getAttributes();
return attributes.find(attr => attr.type === type & & attr.name === name);
}
/**
* @param {string} type - attribute type (label, relation, etc.)
* @param {string} name - attribute name
* @returns {Promise< string>} attribute value of given type and name or null if no such attribute exists.
*/
async getAttributeValue(type, name) {
const attr = await this.getAttribute(type, name);
return attr ? attr.value : null;
}
/**
* @param {string} name - label name
* @returns {Promise< boolean>} true if label exists (including inherited)
*/
async hasLabel(name) { return await this.hasAttribute(LABEL, name); }
/**
* @param {string} name - relation name
* @returns {Promise< boolean>} true if relation exists (including inherited)
*/
async hasRelation(name) { return await this.hasAttribute(RELATION, name); }
/**
* @param {string} name - label name
* @returns {Promise< Attribute>} label if it exists, null otherwise
*/
async getLabel(name) { return await this.getAttribute(LABEL, name); }
/**
* @param {string} name - relation name
* @returns {Promise< Attribute>} relation if it exists, null otherwise
*/
async getRelation(name) { return await this.getAttribute(RELATION, name); }
/**
* @param {string} name - label name
* @returns {Promise< string>} label value if label exists, null otherwise
*/
async getLabelValue(name) { return await this.getAttributeValue(LABEL, name); }
/**
* @param {string} name - relation name
* @returns {Promise< string>} relation value if relation exists, null otherwise
*/
async getRelationValue(name) { return await this.getAttributeValue(RELATION, name); }
/**
* @param {string} name
2019-08-20 21:40:47 +02:00
* @returns {Promise< NoteShort>|null} target note of the relation or null (if target is empty or note was not found)
2018-12-22 22:28:49 +01:00
*/
async getRelationTarget(name) {
2019-08-20 21:40:47 +02:00
const targets = await this.getRelationTargets(name);
2018-12-22 22:28:49 +01:00
2019-08-20 21:40:47 +02:00
return targets.length > 0 ? targets[0] : null;
}
/**
* @param {string} [name] - relation name to filter
* @returns {Promise< NoteShort[]>}
*/
async getRelationTargets(name) {
const relations = await this.getRelations(name);
const targets = [];
for (const relation of relations) {
targets.push(await this.treeCache.getNote(relation.value));
}
return targets;
2018-12-22 22:28:49 +01:00
}
/**
* Clear note's attributes cache to force fresh reload for next attribute request.
* Cache is note instance scoped.
*/
invalidateAttributeCache() {
this.attributeCache = null;
}
2019-08-20 21:40:47 +02:00
/**
* Get relations which target this note
*
* @returns {Promise< Attribute[]>}
*/
async getTargetRelations() {
return (await server.get('notes/' + this.noteId + '/target-relations'))
.map(attrRow => new Attribute(this.treeCache, attrRow));
}
2018-08-29 20:44:35 +02:00
get toString() {
return `Note(noteId=${this.noteId}, title=${this.title})`;
}
get dto() {
const dto = Object.assign({}, this);
delete dto.treeCache;
delete dto.archived;
2018-12-22 22:28:49 +01:00
delete dto.attributeCache;
2018-08-29 20:44:35 +02:00
return dto;
}
}
export default NoteShort;< / code > < / pre >
< / article >
< / section >
< / div >
< nav >
< h2 > < a href = "index.html" > Home< / a > < / h2 > < h3 > Classes< / h3 > < ul > < li > < a href = "Branch.html" > Branch< / a > < / li > < li > < a href = "FrontendScriptApi.html" > FrontendScriptApi< / a > < / li > < li > < a href = "NoteFull.html" > NoteFull< / a > < / li > < li > < a href = "NoteShort.html" > NoteShort< / a > < / li > < / ul > < h3 > < a href = "global.html" > Global< / a > < / h3 >
< / nav >
< br class = "clear" >
< footer >
2019-08-20 21:40:47 +02:00
Documentation generated by < a href = "https://github.com/jsdoc/jsdoc" > JSDoc 3.6.3< / a >
2018-08-29 20:44:35 +02:00
< / footer >
< script > prettyPrint ( ) ; < / script >
< script src = "scripts/linenumber.js" > < / script >
< / body >
< / html >
