@blockv/sdk/lib/client/Discover.js

Allows web apps to display and interact with vatoms.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _Vatom = _interopRequireDefault(require("../model/Vatom"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

//
//  BlockV AG. Copyright (c) 2018, all rights reserved.
//
//  Licensed under the BlockV SDK License (the "License"); you may not use this file or
//  the BlockV SDK except in compliance with the License accompanying it. Unless
//  required by applicable law or agreed to in writing, the BlockV SDK distributed under
//  the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
//  ANY KIND, either express or implied. See the License for the specific language
//  governing permissions and limitations under the License.
//
class Discover {
  constructor(bv, customPayload) {
    this.bv = bv; // Setup default vars

    this.overridePayload = customPayload;
    this.filters = [];
    this.groupBy = [Discover.FieldTemplateVariation];
    this.scope = null; // The default scope returns vatoms that the user owns only

    this.setScopeToOwnedVatomsOnly();
    /** The number of samples to return. This is based on the groupBy property.
        0 will return all vatoms without sampling them. */

    this.samples = 0;
  }
  /** Appends a filter to the filters list. */


  appendFilter(field, value, compareOperation, combineOperation) {
    // Append filter
    this.filters.push({
      field,
      value,
      filter_op: compareOperation || Discover.FilterOperation.Equal,
      bool_op: combineOperation || Discover.CombineOperation.And
    });
  }
  /** Set the scope to only return vatoms with the specified publisher FQDN */


  setScopeToPublisherFQDN(fqdn) {
    // Set scope
    this.scope = {
      key: Discover.FieldPublisherFqdn,
      value: fqdn
    };
  }
  /** Set the scope to only return owned vatoms */


  setScopeToOwnedVatomsOnly() {
    // Set scope
    this.scope = {
      key: Discover.FieldOwner,
      value: '$currentuser'
    };
  }
  /** Set the scope to specified key and value */


  setScope(key, value) {
    // Set scope
    this.scope = {
      key,
      value
    };
  }
  /** @private Get the request payload to send to the Discovery API call */


  getPayload() {
    // Check for override
    if (this.overridePayload) {
      return this.overridePayload;
    } // Check scope


    if (!this.scope) {
      throw new Error('Vatomic SDK: No scope set for discover filter!');
    } // Create payload


    const payload = {};
    payload.scope = this.scope; // Set sampling

    if (this.samples > 0 && this.groupBy.length > 0) {
      payload.sample = this.samples;
      payload.group_by = this.groupBy;
    } // Set filters


    if (this.filters.length > 0) {
      payload.filters = [{
        filter_elems: this.filters
      }];
    } // Set return info


    payload.return = {
      type: '*',
      fields: [] // Done

    };
    return payload;
  }
  /** Execute the discover query, returning an array of Vatoms. @returns Promise<[Vatom]> */


  execute() {
    // Send request
    return this.bv.client.request('POST', '/v1/vatom/discover', this.getPayload(), true).then(data => {
      const {
        actions,
        faces,
        results
      } = data;
      const actionsArray = [];
      const facesArray = [];
      const vatomsArray = []; // eslint-disable-next-line

      for (let a of actions) {
        const aName = a.name.split('::Action::');
        const aKey = aName[0];
        actionsArray.push({
          template: aKey,
          action: aName[1],
          meta: a.meta,
          properties: a.properties
        });
      } // eslint-disable-next-line


      for (let f of faces) {
        facesArray.push({
          template: f.template,
          id: f.id,
          meta: f.meta,
          properties: f.properties
        });
      } // eslint-disable-next-line


      for (let v of results) {
        const {
          template
        } = v['vAtom::vAtomType'];
        const obj = new _Vatom.default(v, facesArray.filter(f => f.template === template), actionsArray.filter(a => a.template === template));
        vatomsArray.push(obj);
      }

      return vatomsArray;
    });
  }
  /** Execute the discover query, returning the count of vatoms. @returns Promise<Integer> */


  count() {
    // Inject "count only" into the payload
    const payload = this.getPayload();
    payload.return.type = 'count'; // Send request

    return this.bv.client.request('POST', '/v1/vatom/discover', payload, true).then(data => data.count || 0);
  }

}
/** Filter operations */


exports.default = Discover;
Discover.FilterOperation = {
  Equal: 'Eq',
  GreaterThan: 'Gt',
  GreaterOrEqual: 'Ge',
  LessThan: 'Lt',
  LessOrEqual: 'Le',
  NotEqual: 'Ne',
  Match: 'Match'
  /** Filter combine operations */

};
Discover.CombineOperation = {
  And: 'And',
  Or: 'Or'
  /** Predefined fields */

};
Discover.FieldAcquireable = 'vAtom::vAtomType.acquireable';
Discover.FieldPrivateName = 'private.name';
Discover.FieldID = 'id';
Discover.FieldPublisherFqdn = 'vAtom::vAtomType.publisher_fqdn';
Discover.FieldTemplate = 'vAtom::vAtomType.template';
Discover.FieldTemplateVariation = 'vAtom::vAtomType.template_variation';
Discover.FieldVisibilityType = 'vAtom::vAtomType.visibility.type';
Discover.FieldOwner = 'vAtom::vAtomType.owner';
Discover.FieldParentID = 'vAtom::vAtomType.parent_id';