Source: models/Depot.js

  1. var assign = require('object-assign');
  3. var Node = require('./Node');
  5. /**
  6.  * Initialize a new depot instance.
  7.  *
  8.  * @param {Object} obj Data from the server, which doesn't follow typical
  9.  *                     javaScript naming conventions.
  10.  * @constructor
  11.  * @memberof models
  12.  */
  13. function Depot(obj) {
  14.   this._data = obj || {};
  16.   /**
  17.    * The immediate directories and files under this depot.
  18.    *
  19.    * @type {Array<PathItem>}
  20.    */
  21.   this.children = [];
  23.   var self = this;
  25.   Object.defineProperties(this, {
  26.     /**
  27.      * The name of the Depot
  28.      *
  29.      * @type string
  30.      * @name models.Depot#depot
  31.      * @memberOf models.Depot
  32.      */
  33.     'depot': {
  34.       get: function() {
  35.         return self._data['Depot'];
  36.       },
  37.       set: function(x) {
  38.         self._data['Depot'] = x;
  39.         return x;
  40.       }
  41.     },
  42.     /**
  43.      * The created date of the depot
  44.      *
  45.      * @type Date
  46.      * @name models.Depot#date
  47.      * @memberOf models.Depot
  48.      * @readonly
  49.      */
  50.     'date': {
  51.       get: function() {
  52.         if (self._data['Date']) {
  53.           return new Date(self._data['Date']);
  54.         }
  55.       }
  56.     },
  57.     /**
  58.      * The Depot type, one of 'local', 'remote', 'spec', 'stream', 'unload', or
  59.      * 'archive'.
  60.      *
  61.      * @type string
  62.      * @name models.Depot#type
  63.      * @memberOf models.Depot
  64.      */
  65.     'type': {
  66.       get: function() {
  67.         return self._date['Type'];
  68.       },
  69.       set: function(x) {
  70.         // TODO validate x
  71.         self._date['Type'] = x;
  72.       }
  73.     },
  74.     /**
  75.      * If `type` is 'remote', this is the P4PORT address of the remote server.
  76.      *
  77.      * @type string
  78.      * @name models.Depot#address
  79.      * @memberOf models.Depot
  80.      */
  81.     'address': {
  82.       get: function() {
  83.         return self._date['Address'];
  84.       },
  85.       set: function(x) {
  86.         self._date['Type'] = x;
  87.       }
  88.     },
  89.     /**
  90.      * If `type` is 'local', 'spec', or 'archive', this points to the relative
  91.      * location of the depot subdirectory.
  92.      *
  93.      * @type string
  94.      * @name models.Depot#map
  95.      * @memberOf models.Depot
  96.      */
  97.     'map': {
  98.       get: function() {
  99.         return self._date['Map'];
  100.       },
  101.       set: function(x) {
  102.         self._date['Map'] = x;
  103.         return x;
  104.       }
  105.     },
  106.     /**
  107.      * A short description of the depot's purpose.
  108.      *
  109.      * @type string
  110.      * @name models.Depot#description
  111.      * @memberOf models.Depot
  112.      */
  113.     'description': {
  114.       get: function() {
  115.         return self._date['Description'];
  116.       },
  117.       set: function(x) {
  118.         self._date['Description'] = x;
  119.         return x;
  120.       }
  121.     },
  122.     /**
  123.      * The user login that owns the Depot.
  124.      *
  125.      * @type string
  126.      * @name models.Depot#owner
  127.      * @memberOf models.Depot
  128.      */
  129.     'owner': {
  130.       get: function() {
  131.         return self._data['Owner'];
  132.       },
  133.       set: function(x) {
  134.         self._data['Owner'] = x;
  135.         return x;
  136.       }
  137.     },
  138.     /**
  139.      * If the `type` is 'spec', this holds an optional suffix for generated
  140.      * paths to objects in the spec depot.
  141.      *
  142.      * @type string
  143.      * @name models.Depot#suffix
  144.      * @memberOf models.Depot
  145.      */
  146.     'suffix': {
  147.       get: function() {
  148.         return self._data['Suffix'];
  149.       },
  150.       set: function(x) {
  151.         self._data['Suffix'] = x;
  152.         return x;
  153.       }
  154.     },
  155.     /**
  156.      * When type is 'spec', this an optional description of what specs should
  157.      * be saved.
  158.      *
  159.      * @type string
  160.      * @name models.Depot#specMap
  161.      * @memberOf models.Depot
  162.      */
  163.     'specMap': {
  164.       get: function() {
  165.         return self._data['SpecMap'];
  166.       }
  167.     },
  168.     /**
  169.      * The representation of the depot suitable to POST back to the Helix
  170.      * Web Services Perforce API.
  171.      *
  172.      * @type object
  173.      * @name models.Depot#data
  174.      * @memberOf models.Depot
  175.      * @readonly
  176.      */
  177.     'data': {
  178.       get: function() {
  179.         return self._data;
  180.       }
  181.     },
  182.     /**
  183.      * Used by our underlying Node representation
  184.      *
  185.      * @type string
  186.      * @name models.Depot#name
  187.      * @memberOf models.Depot
  188.      * @readonly
  189.      */
  190.     'name': {
  191.       get: function() {
  192.         return self.depot;
  193.       }
  194.     },
  195.     /**
  196.      * Used by our underlying Node representation
  197.      *
  198.      * @type string
  199.      * @name models.Depot#pathId
  200.      * @memberOf models.Depot
  201.      * @readonly
  202.      */
  203.     'pathId': {
  204.       get: function() {
  205.         return [self.depot];
  206.       }
  207.     }
  208.   });
  209. }
  211. assign(Depot.prototype, Node);
  213. module.exports = Depot;