Context.js

  1. import GraphResource from './Graph.js';
  2. import Pipeline from './Pipeline.js';
  3. import PrototypeEntry from './PrototypeEntry.js';
  4. import Resource from './Resource.js';
  5. import StringResource from './String.js';
  6. import types from './types.js';
  8. /**
  9.  * Methods for interacting with the EntryStore repository scoped to a specific context.
  10.  *
  11.  * @exports store/Context
  12.  */
  13. export default class Context extends Resource {
  14.   /**
  15.    * @param {string} entryURI - URI to an entry where this resource is contained.
  16.    * @param {string} resourceURI - URI to the resource.
  17.    * @param {EntryStore} entryStore - the API's repository instance.
  18.    */
  19.   // eslint-disable-next-line no-useless-constructor
  20.   constructor(entryURI, resourceURI, entryStore) {
  21.     super(entryURI, resourceURI, entryStore);
  22.   }
  24.   /**
  25.    * Retrieves a list of entries in the context.
  26.    *
  27.    * @param {Object} sort - same sort object as provided in the optionalLoadParams to
  28.    * @link EntryStore#getEntry getEntry method.
  29.    * @param {Object} limit - same limit as provided in the optionalLoadParams to
  30.    * {@see EntryStore#getEntry getEntry} method.
  31.    * @param {integer} page - unless limit is set to -1 (no pagination) we need to specify
  32.    * which page to load, first page is 0.
  33.    * @returns {Promise.<Entry[]>} upon success the promise returns an array of entries.
  34.    * @see EntryStore#getListEntries
  35.    */
  36.   listEntries(sort, limit, page) {
  37.     return this.getEntryStore().getListEntries(`${this._resourceURI}/entry/_all`, sort, limit, page);
  38.   }
  40.   /**
  41.    * Convenience method, to retrieve an entry from this context.
  42.    *
  43.    * @param {string} entryId
  44.    * @param {object} optionalLoadParams same parameter as in {@see EntryStore#getEntry}
  45.    * @returns {Promise.<Entry>}
  46.    * @see EntryStore#getEntry
  47.    */
  48.   getEntryById(entryId, optionalLoadParams = {}) {
  49.     return this.getEntryStore().getEntry(this.getEntryURIbyId(entryId), optionalLoadParams);
  50.   }
  52.   /**
  53.    * Expands the given entry id into a full URI.
  54.    *
  55.    * @param {string} entryId
  56.    * @returns {string} the URI for an entry in this context with the given id.
  57.    */
  58.   getEntryURIbyId(entryId) {
  59.     return this.getEntryStore().getEntryURI(this.getId(), entryId);
  60.   }
  62.   /**
  63.    * Factory method to create a PrototypeEntry that has the current context as container.
  64.    * Call {@link PrototypeEntry#commit commit} on the PrototypeEntry to actually create it
  65.    * (returns a promise).
  66.    *
  67.    * @param {string=} id - id for the entry, fails after commit if an entry exists already with
  68.    * this id.
  69.    * @returns {PrototypeEntry}
  70.    */
  71.   newEntry(id) {
  72.     return new PrototypeEntry(this, id);
  73.   }
  75.   /**
  76.    * Factory method to create a PrototypeEntry that corresponds to a local named resource that
  77.    * has the current context as container.
  78.    * Call {@link PrototypeEntry#commit commit} on the PrototypeEntry to actually create it
  79.    * (returns a promise).
  80.    *
  81.    * @param {string=} id - id for the entry, fails after commit if an entry exists already
  82.    * with this id.
  83.    * @returns {PrototypeEntry}
  84.    */
  85.   newNamedEntry(id) {
  86.     return new PrototypeEntry(this, id).setResourceType(types.RT_NAMEDRESOURCE);
  87.   }
  89.   /**
  90.    * Factory method to create a PrototypeEntry that corresponds to a link that has the
  91.    * current context as container.
  92.    * Call {@link PrototypeEntry#commit commit} on the PrototypeEntry to actually create
  93.    * it (returns a promise).
  94.    *
  95.    * @param {string} link - the URI for the resource we are making a link to, mandatory.
  96.    * @param {string=} id - id for the entry, fails after commit if an entry exists already
  97.    * with this id.
  98.    * @returns {PrototypeEntry}
  99.    */
  100.   newLink(link, id) {
  101.     return new PrototypeEntry(this, id).setResourceURI(link).setEntryType(types.ET_LINK);
  102.   }
  104.   /**
  105.    * Factory method to create a PrototypeEntry that is a linkref that has the current context
  106.    * as container. Call {@link PrototypeEntry#commit commit} on the PrototypeEntry to
  107.    * actually create it (returns a promise).
  108.    *
  109.    * @param {string} link - is the URI for the resource we are making a link to, mandatory.
  110.    * @param {string} metadataLink - is the URI for the metadata are referring to, mandatory.
  111.    * @param {string=} id - id for the entry, fails after commit if an entry exists already
  112.    * with this id.
  113.    * @returns {PrototypeEntry}
  114.    */
  115.   newLinkRef(link, metadataLink, id) {
  116.     return new PrototypeEntry(this, id)
  117.       .setResourceURI(link)
  118.       .setExternalMetadataURI(metadataLink)
  119.       .setEntryType(types.ET_LINKREF);
  120.   }
  122.   /**
  123.    * Factory method to create a PrototypeEntry that is a reference and has the current
  124.    * context as container. Call {@link PrototypeEntry#commit commit} on the
  125.    * PrototypeEntry to actually create it (returns a promise).
  126.    * The only difference to the newLinkRef method is that the EntryType is Reference instead
  127.    * of LinkReference which implies that there is no local metadata.
  128.    *
  129.    * @param {string} link - the URI for the resource we are making a link to, mandatory.
  130.    * @param {string} metadataLink - the URI for the metadata are referring to, mandatory.
  131.    * @param {string=} id for the entry, fails after commit if an entry exists already with
  132.    * this id.
  133.    * @returns {PrototypeEntry}
  134.    */
  135.   newRef(link, metadataLink, id) {
  136.     return new PrototypeEntry(this, id)
  137.       .setResourceURI(link)
  138.       .setExternalMetadataURI(metadataLink)
  139.       .setEntryType(types.ET_REF);
  140.   }
  142.   /**
  143.    * Factory method to create a PrototypeEntry whose resource is a {@link List List)
  144.    * and has the current context as container.
  145.    * Call {@link PrototypeEntry#commit commit} on the PrototypeEntry to actually create
  146.    * it (returns a promise).
  147.    *
  148.    * @param {string} id an optional id for the entry, fails on commit if an entry exists already
  149.    * with this id.
  150.    * @returns {PrototypeEntry}
  151.    */
  152.   newList(id) {
  153.     return new PrototypeEntry(this, id).setGraphType(types.GT_LIST);
  154.   }
  156.   /**
  157.    * Factory method to create a PrototypeEntry whose resource is a {@link Graph Graph}
  158.    * and has the current context as container.
  159.    * Call {@link PrototypeEntry#commit commit} on the PrototypeEntry to actually create it
  160.    * (returns a promise).
  161.    *
  162.    * @param {rdfjson/Graph|{}} graph - graph to store as a resource.
  163.    * @param {string=} id - id for the entry, fails upon commit if an entry exists already
  164.    * with this id.
  165.    * @returns {PrototypeEntry}
  166.    */
  167.   newGraph(graph = {}, id) {
  168.     const prototypeEntry = new PrototypeEntry(this, id).setGraphType(types.GT_GRAPH);
  169.     const entryInfo = prototypeEntry.getEntryInfo();
  170.     prototypeEntry._resource = new GraphResource(entryInfo.getEntryURI(), entryInfo.getResourceURI(),
  171.       this.getEntryStore(), graph);
  173.     return prototypeEntry;
  174.   }
  176.   /**
  177.    * Factory method to create a PrototypeEntry whose resource is a {@link String String}
  178.    * that has the current context as container.
  179.    * Call {@link PrototypeEntry#commit commit} on the PrototypeEntry to actually create
  180.    * it (returns a promise).
  181.    *
  182.    * @param {string=} str an optional string for the String Resource.
  183.    * @param {String} id an optional id for the entry, fails upon commit if an entry exists
  184.    * already with this id.
  185.    * @returns {PrototypeEntry}
  186.    */
  187.   newString(str, id) {
  188.     const prototypeEntry = new PrototypeEntry(this, id).setGraphType(types.GT_STRING);
  189.     const entryInfo = prototypeEntry.getEntryInfo();
  190.     prototypeEntry._resource = new StringResource(entryInfo.getEntryURI(),
  191.       entryInfo.getResourceURI(), this.getEntryStore(), str);
  193.     return prototypeEntry;
  194.   }
  196.   /**
  197.    * Factory method to create a PrototypeEntry whose resource is a
  198.    * {@link Pipeline pipeline} that has the current context as container.
  199.    * Call {@link PrototypeEntry#commit commit} on the PrototypeEntry to actually create it
  200.    * (returns a promise).
  201.    *
  202.    * @param {String} id an optional id for the entry, fails upon commit if an entry exists
  203.    * already with this id.
  204.    * @returns {PrototypeEntry}
  205.    */
  206.   newPipeline(id) {
  207.     const prototypeEntry = new PrototypeEntry(this, id).setGraphType(types.GT_PIPELINE);
  208.     const entryInfo = prototypeEntry.getEntryInfo();
  209.     prototypeEntry._resource = new Pipeline(entryInfo.getEntryURI(), entryInfo.getResourceURI(), this.getEntryStore(), {});
  211.     return prototypeEntry;
  212.   }
  214.   /**
  215.    * The name for this context.
  216.    *
  217.    * @returns {string}
  218.    */
  219.   getName() {
  220.     return this._name;
  221.   }
  223.   /**
  224.    * Change of context name, succeeds if name is not in use already by another context.
  225.    * @param {string} name
  226.    * @returns {Promise.<string>}
  227.    */
  228.   async setName(name) {
  229.     const oldName = this._name;
  230.     this._name = name;
  231.     try {
  232.       const promise = this.getEntryStore().getREST().put(`${this.getEntryURI()}/name`, JSON.stringify({ name }));
  233.       this.getEntryStore().handleAsync(promise, 'setContextName');
  234.       await promise;
  235.       const entry = this.getEntry(true);
  236.       if (entry) {
  237.         entry.getEntryInfo()._name = name;
  238.       }
  239.       return name;
  240.     } catch (e) {
  241.       this._name = oldName;
  242.       throw e;
  243.     }
  244.   }
  245.   /**
  246.    * Finds the user or group that has this context as homecontext if any.
  247.    *
  248.    * @returns {Promise.<Entry>} if succeeds if context a homecontext of some user or group.
  249.    * @async
  250.    */
  251.   async getHomeContextOf() {
  252.     const contextEntry = await this.getEntry();
  253.     const es = contextEntry.getEntryStore();
  254.     const groupResourceArr = contextEntry.getReferrers('store:homeContext');
  255.     if (groupResourceArr.length > 0) {
  256.       return es.getEntry(es.getEntryURIFromURI(groupResourceArr[0]));
  257.     }
  258.     throw new Error('No user or group that has this context as home context');
  259.   }
  261.   /**
  262.    *
  263.    * @param data
  264.    * @private
  265.    */
  266.   _update(data) {
  267.     this._name = data.alias || data.name; // TODO, change to only name after clean-up
  268.   }
  269. };