@openhps/core/dist/esm/service/TrajectoryService.js

Open Hybrid Positioning System - Core component

import { __awaiter } from "tslib";
import { DataObject } from '../data/object/DataObject';
import { DataService } from './DataService';
/**
 * A trajectory service stores the position of a data object
 * in a continuous trajectory.
 */
export class TrajectoryService extends DataService {
  constructor(dataServiceDriver, options) {
    var _a;
    super(dataServiceDriver);
    this.options = options || {};
    this.options.autoBind = this.options.autoBind === undefined ? true : this.options.autoBind;
    this.options.dataService = this.options.dataService || DataObject;
    this.options.defaultUID = (_a = this.options.defaultUID) !== null && _a !== void 0 ? _a : object => object.uid;
    if (this.options.autoBind) {
      this.once('build', this._bindService.bind(this));
    }
  }
  _bindService() {
    return new Promise((resolve, reject) => {
      if (!this.model) {
        // No model
        return resolve();
      }
      const dataObjectService = this.model.findDataService(this.options.dataService);
      if (dataObjectService) {
        dataObjectService.on('insert', (_, object) => __awaiter(this, void 0, void 0, function* () {
          yield this.appendPosition(object);
        }));
        resolve();
      } else {
        reject(new Error(`Data object service not found for '${this.options.dataService}'`));
      }
    });
  }
  /**
   * Find the latest trajectory
   * @param {DataObject | string} object Data object to get trajectories for
   * @returns {Promise<Trajectory>} Trajectory promise if found
   */
  findCurrentTrajectory(object) {
    return new Promise((resolve, reject) => {
      this.findOne({
        objectUID: object instanceof DataObject ? object.uid : object
      }, {
        sort: [['createdTimestamp', -1]]
      }).then(resolve).catch(reject);
    });
  }
  /**
   * Find the trajectory of an object from start to end date
   * @param {DataObject | string} object Data object to get trajectory for
   * @param {Date | number} start Start time or date
   * @param {Date | number} end End time or date
   * @returns {Trajectory} Trajectory match
   */
  findTrajectoryByRange(object, start, end) {
    return new Promise((resolve, reject) => {
      this.findOne({
        objectUID: object instanceof DataObject ? object.uid : object,
        positions: {
          $elemMatch: {
            timestamp: {
              $lte: end ? end instanceof Date ? end.getTime() : end : Number.MAX_VALUE,
              $gte: start ? start instanceof Date ? start.getTime() : start : -1
            }
          }
        }
      }).then(trajectory => {
        resolve(trajectory);
      }).catch(reject);
    });
  }
  /**
   * Find all trajectories of an object
   * @param {DataObject | string} object Data object to get trajectories for
   * @returns {Promise<string[]>} List of trajectory UIDs
   */
  findTrajectories(object) {
    return new Promise(resolve => {
      this.findAll({
        objectUID: object instanceof DataObject ? object.uid : object
      }).then(trajectories => {
        resolve(trajectories.map(trajectory => trajectory.uid));
      });
    });
  }
  /**
   * Append a position to the trajectory service
   * @param {DataObject} object Data object to store
   * @param {string} uid Trajectory uid
   * @returns {Promise<Trajectory>} Stored trajectory
   */
  appendPosition(object, uid) {
    return new Promise((resolve, reject) => {
      const position = object.getPosition();
      if (position) {
        Promise.resolve(uid ? this.findOne({
          uid
        }) : this.findCurrentTrajectory(object)).then(trajectory => {
          if (!trajectory) {
            trajectory = new this.driver.dataType();
            trajectory.objectUID = object.uid;
            trajectory.uid = uid !== null && uid !== void 0 ? uid : this.options.defaultUID(object);
          }
          trajectory.positions.push(object.position);
          return this.insert(trajectory.uid, trajectory);
        }).then(resolve).catch(reject);
      } else {
        return reject();
      }
    });
  }
}