cityworks 0.0.25 → 0.0.29

package/src/workorder.ts

@@ -1,6 +1,7 @@
 import { CWError } from './error'
 const _ = require('lodash')
 import { WorkOrderAdmin } from './workorder_admin'
+import { Comments } from './comments'
 
 export class WorkOrder {
   /**
@@ -11,7 +12,12 @@ export class WorkOrder {
   /**
    * WorkOrder Administration methods
    */
-  admin?: Object
+  admin: Object
+
+  /**
+   * WorkOrder Comments methods
+   */
+  comment: Object
 
   /**
    * @hidden
@@ -19,114 +25,115 @@ export class WorkOrder {
   constructor(cw) {
     this.cw = cw
     this.admin = new WorkOrderAdmin(cw)
+    this.comment = new Comments(cw, 'WorkOrder')
   }
 
-    /**
-     * Create new workorders, including linkin to Requests & Inspections (optionally)
-     *
-     * @category WorkOrders
-     * @param {Object} wo_data - See /{subdirectory}/apidocs/#/data-type-infodataType=WorkOrder on the Cityworks instance
-     * @param {Array<number>} [inspectionIds] - The inspection IDs which the workorder should be linked to.
-     * @param {Array<number>} [requestIds] - The inspection IDs which the workorder should be linked to.
-     * @return {Object} Returns Promise that represents an object describing the newly-created workorder
-     */
-    create(wo_data: Object, inspectionIds?: Array<number>, requestIds?: Array<number>) {
-      return new Promise((resolve, reject) => {
-        if(!_.has(wo_data, 'WOTemplateId') || !_.has(wo_data, 'EntityType')) {
-          reject(new CWError(2, 'WOTemplateId & EntityType must be provided.', {'provided': wo_data}))
-        } else {
-          var data = wo_data;
-          if(typeof inspectionIds != 'undefined' && inspectionIds != null && !_.has(data, 'InspectionIds')) {
-            _.set(data, 'InspectionIds', inspectionIds);
-          }
-          if(typeof requestIds != 'undefined' && requestIds != null && !_.has(data, 'RequestIds')) {
-            _.set(data, 'RequestIds', requestIds);
-          }
-          this.cw.runRequest('Ams/WorkOrder/Create', data).then(r => {
-            resolve(r.Value)
-          }).catch(e => {
-            reject(e)
-          })
+  /**
+   * Create new workorders, including linkin to Requests & Inspections (optionally)
+   *
+   * @category WorkOrders
+   * @param {Object} wo_data - See /{subdirectory}/apidocs/#/data-type-infodataType=WorkOrder on the Cityworks instance
+   * @param {Array<number>} [inspectionIds] - The inspection IDs which the workorder should be linked to.
+   * @param {Array<number>} [requestIds] - The inspection IDs which the workorder should be linked to.
+   * @return {Object} Returns Promise that represents an object describing the newly-created workorder
+   */
+  create(wo_data: Object, inspectionIds?: Array<number>, requestIds?: Array<number>) {
+    return new Promise((resolve, reject) => {
+      if(!_.has(wo_data, 'WOTemplateId') || !_.has(wo_data, 'EntityType')) {
+        reject(new CWError(2, 'WOTemplateId & EntityType must be provided.', {'provided': wo_data}))
+      } else {
+        var data = wo_data;
+        if(typeof inspectionIds != 'undefined' && inspectionIds != null && !_.has(data, 'InspectionIds')) {
+          _.set(data, 'InspectionIds', inspectionIds);
         }
-      })
-    }
-
-    /**
-     * Create new workorder linked to parent workorder
-     *
-     * @category WorkOrders
-     * @param {Object} wo_data - See /{subdirectory}/apidocs/#/data-type-infodataType=WorkOrder on the Cityworks instance
-     * @param {string|number} workOrderSId - The workorder S/ID which the entities should be added to. # for SID, string for ID.
-     * @return {Object} Returns Promise that represents an object describing the newly-created workorder
-     */
-    createFromParent(wo_data: Object, workOrderSId: string|number, s: boolean = true) {
-      return new Promise((resolve, reject) => {
-        if(!_.has(wo_data, 'WOTemplateId') || !_.has(wo_data, 'EntityType')) {
-          reject(new CWError(2, 'WOTemplateId & EntityType must be provided.', {'provided': wo_data}))
-        } else {
-          var data = wo_data;
-          if(_.isString(workOrderSId)) {
-            _.set(data, 'WorkOrderId', workOrderSId)
-          } else {
-            _.set(data, 'WorkOrderSid', workOrderSId)
-          }
-          this.cw.runRequest('Ams/WorkOrder/Create', data).then(r => {
-            resolve(r.Value)
-          }).catch(e => {
-            reject(e)
-          })
+        if(typeof requestIds != 'undefined' && requestIds != null && !_.has(data, 'RequestIds')) {
+          _.set(data, 'RequestIds', requestIds);
         }
-      })
-    }
+        this.cw.runRequest('Ams/WorkOrder/Create', data).then(r => {
+          resolve(r.Value)
+        }).catch(e => {
+          reject(e)
+        })
+      }
+    })
+  }
 
-    /**
-     * Update a WorkOrder
-     *
-     * @category WorkOrders
-     * @param {object} wo_data - See /{subdirectory}/apidocs/#/data-type-infodataType=WorkOrder on the Cityworks instance
-     * @return {Object} Returns Promise that represents an object describing the updated workorder
-     */
-    update(wo_data: Object) {
-      return new Promise((resolve, reject) => {
-        if(!_.has(wo_data, 'WorkOrderSid') && !_.has(wo_data, 'WorkOrderId')) {
-          reject(new CWError(3, 'WorkOrderId or WorkOrderSid must be provided.', {'provided': wo_data}))
+  /**
+   * Create new workorder linked to parent workorder
+   *
+   * @category WorkOrders
+   * @param {Object} wo_data - See /{subdirectory}/apidocs/#/data-type-infodataType=WorkOrder on the Cityworks instance
+   * @param {string|number} workOrderSId - The workorder S/ID which the entities should be added to. # for SID, string for ID.
+   * @return {Object} Returns Promise that represents an object describing the newly-created workorder
+   */
+  createFromParent(wo_data: Object, workOrderSId: string|number, s: boolean = true) {
+    return new Promise((resolve, reject) => {
+      if(!_.has(wo_data, 'WOTemplateId') || !_.has(wo_data, 'EntityType')) {
+        reject(new CWError(2, 'WOTemplateId & EntityType must be provided.', {'provided': wo_data}))
+      } else {
+        var data = wo_data;
+        if(_.isString(workOrderSId)) {
+          _.set(data, 'WorkOrderId', workOrderSId)
         } else {
-          this.cw.runRequest('Ams/WorkOrder/Update', wo_data).then(r => {
-            resolve(r.Value)
-          }).catch(e => {
-            reject(e)
-          })
+          _.set(data, 'WorkOrderSid', workOrderSId)
         }
-      })
-    }
+        this.cw.runRequest('Ams/WorkOrder/Create', data).then(r => {
+          resolve(r.Value)
+        }).catch(e => {
+          reject(e)
+        })
+      }
+    })
+  }
 
-    /**
-     * Combine WorkOrders
-     *
-     * @category WorkOrders
-     * @param {Array<string>} fromWorkOrderIds - The workorder IDs which should be combined.
-     * @param {string} toWorkOrderId - The work order ID for the single work order that should contain the info/entities from the other work orders
-     * @param {boolean} cancelCombinedWorkOrders - If the work orders combined into the single should then be canceled, default is true.
-     * @return {Object} Returns object that represents a collection of WorkOrders
-     */
-     combine(fromWorkOrderIds: Array<string>, toWorkOrderId: string, cancelCombinedWorkOrders: boolean = true) {
-       return new Promise((resolve, reject) => {
-         var data = {
-           CancelCombinedWorkOrders: cancelCombinedWorkOrders,
-           ToWorkOrderId: toWorkOrderId,
-           FromWorkOrderIds: fromWorkOrderIds
+  /**
+   * Update a WorkOrder
+   *
+   * @category WorkOrders
+   * @param {object} wo_data - See /{subdirectory}/apidocs/#/data-type-infodataType=WorkOrder on the Cityworks instance
+   * @return {Object} Returns Promise that represents an object describing the updated workorder
+   */
+  update(wo_data: Object) {
+    return new Promise((resolve, reject) => {
+      if(!_.has(wo_data, 'WorkOrderSid') && !_.has(wo_data, 'WorkOrderId')) {
+        reject(new CWError(3, 'WorkOrderId or WorkOrderSid must be provided.', {'provided': wo_data}))
+      } else {
+        this.cw.runRequest('Ams/WorkOrder/Update', wo_data).then(r => {
+          resolve(r.Value)
+        }).catch(e => {
+          reject(e)
+        })
+      }
+    })
+  }
+
+  /**
+   * Combine WorkOrders
+   *
+   * @category WorkOrders
+   * @param {Array<string>} fromWorkOrderIds - The workorder IDs which should be combined.
+   * @param {string} toWorkOrderId - The work order ID for the single work order that should contain the info/entities from the other work orders
+   * @param {boolean} cancelCombinedWorkOrders - If the work orders combined into the single should then be canceled, default is true.
+   * @return {Object} Returns object that represents a collection of WorkOrders
+   */
+   combine(fromWorkOrderIds: Array<string>, toWorkOrderId: string, cancelCombinedWorkOrders: boolean = true) {
+     return new Promise((resolve, reject) => {
+       var data = {
+         CancelCombinedWorkOrders: cancelCombinedWorkOrders,
+         ToWorkOrderId: toWorkOrderId,
+         FromWorkOrderIds: fromWorkOrderIds
+       }
+       this.cw.runRequest('Ams/WorkOrder/Combine', data).then(r => {
+         if(r.Status>0) {
+           reject(new CWError(4, r.Message, {'response': r}))
+         } else {
+           resolve(r.Value)
          }
-         this.cw.runRequest('Ams/WorkOrder/Combine', data).then(r => {
-           if(r.Status>0) {
-             reject(new CWError(4, r.Message, {'response': r}))
-           } else {
-             resolve(r.Value)
-           }
-         }).catch(e => {
-           reject(e)
-         })
+       }).catch(e => {
+         reject(e)
        })
-     }
+     })
+   }
 
 
   /**
@@ -312,36 +319,6 @@ export class WorkOrder {
     })
   }
 
-
-  /**
-   * Add a comment to a workorder
-   *
-   * @category WorkOrders
-   * @param {number} workOrderSId - The S/ID of the workorder to retrieve. SID is default.
-   * @param {string} comment - The comment text to add.
-   * @return {Object} Returns Promise that represents an object describing the comment added
-   */
-  comment(workOrderSId: string|number, comment: string) {
-    return new Promise((resolve, reject) => {
-      var data = {
-        Comments: comment
-      }
-      if(_.isString(workOrderSId)) {
-        _.set(data, 'WorkOrderId', workOrderSId)
-      } else if(_.isNumber(workOrderSId)) {
-        _.set(data, 'WorkOrderSid', workOrderSId)
-      } else {
-        // throw error - was not number or string
-        reject(new CWError(9, 'Workorder S/IDs was not provided.', {'workorderSId': workOrderSId}))
-      }
-      this.cw.runRequest('Ams/WorkOrder/AddComments', data).then(r => {
-        resolve(r.Value)
-      }).catch(e => {
-        reject(e)
-      })
-    })
-  }
-
   /**
    * Get entities on an existing WorkOrder
    *

package/test/03.generalTest.js

@@ -0,0 +1,87 @@
+'use strict';
+ require('dotenv').config();
+ var chai = require('chai');
+ var expect = require('chai').expect;
+ var assert = require('chai').assert;
+ var chaiAsPromised = require("chai-as-promised");
+ chai.use(chaiAsPromised);
+ var Cityworks = require('../dist/index.js');
+ var cw3 = new Cityworks(process.env.domain, {path: process.env.path});
+
+ before(function(done) {
+   this.timeout(20000000);
+   cw3.authenticate(process.env.login, process.env.password).then(resp => {
+     done();
+   }).catch(e => {
+     console.log(e, 'unexpected error')
+     done();
+   });
+ });
+
+ describe('[General::notifications] function test', () => {
+   it('should resolve a collection', (done) => {
+     cw3.general.notifications().then(resp => {
+       assert.isArray(resp);
+       done();
+     });
+   });
+ });
+
+ describe('[General::amIWatching] function test', () => {
+   it('should reject with an error if the activity type is not available or does not exist', (done) => {
+     cw3.general.amIWatching('request', 42015).then(r => {
+     }).catch(e => {
+       assert.equal(e.message, 'Activity type provided does not exist.');
+       done();
+     });
+   });
+   it('should resolve a boolean', (done) => {
+     cw3.general.amIWatching('case', 42015).then(r => {
+       assert.isBoolean(r);
+       done();
+     });
+   });
+   it('should resolve with false if id does not exist', (done) => {
+     cw3.general.amIWatching('case', 200042015).then(r => {
+       assert.isFalse(r);
+       done();
+     }).catch(e => {
+       done();
+     });
+   });
+   it('should reject with an error if the activity id is too large', (done) => {
+     cw3.general.amIWatching('case', 10000000000).then(response => {
+     }).catch(e => {
+       assert.equal(e.message, 'Unknown error.');
+       done();
+     });
+   });
+ });
+
+ describe('[General::quickSearch] function test', () => {
+   it('should resolve results', (done) => {
+     cw3.general.quickSearch('256460').then(r => {
+       assert.property(r, 'Permits');
+       done();
+     });
+   });
+
+   it('should resolve (empty) results even when the string is not found', (done) => {
+     cw3.general.quickSearch('SomethingSidewalk').then(r => {
+       assert.property(r, 'Permits');
+       done();
+     });
+   });
+ });
+
+ describe('[General::getActivityMetadataByIds] function test', () => {
+   it('should resolve an activity based on the metadata ids');
+ });
+
+ describe('[General::getWOEntityCostSummary] function test', () => {
+   it('should get an Entity\'s cost summary');
+ });
+
+ describe('[General::searchWOEntityCostSummary] function test', () => {
+   it('should resolve reults of a search for cost summary of an entity');
+ });

package/test/04.requestTest.js

@@ -193,10 +193,69 @@ describe('[Request::reopen] function test', () => {
   });
 });
 
-describe('[Request::comment] function test', () => {
+describe('[Request::comment.add] function test', () => {
+  it('should return the reopened request(s)', (done) => {
+    var ID = 1520675;
+    var comment = 'New comment on ' + Date().toString() + '.';
+    cw4.request.comment.add(ID, comment).then(resp => {
+      assert.equal(resp.Comments, comment);
+      done();
+    }).catch(e => {
+      console.log(e);
+    });
+  });
+});
 
+describe('[Request::comment.update] function test', () => {
+  it('should return the reopened request(s)', (done) => {
+    var ID = 1636877;
+    var comment = 'Updated this comment on ' + Date().toString() + '.';
+    cw4.request.comment.update(ID, comment).then(resp => {
+      assert.equal(resp.Comments, comment);
+      done();
+    }).catch(e => {
+      console.log(e);
+    });
+  });
 });
 
+describe('[Request::comment.get] function test', () => {
+  it('should return the comments for the request', (done) => {
+    var ID = 1520675;
+    cw4.request.comment.get([ID]).then(resp => {
+      console.log(resp[ID]);
+      assert.isArray(resp);
+      done();
+    }).catch(e => {
+      console.log(e);
+    });
+  });
+});
+
+
+describe('[Request::comment.getPredefined] function test', () => {
+  it('should return the comments for the activity type', (done) => {
+    cw4.request.comment.getPredefined(738).then(resp => {
+      assert.isArray(resp);
+      done();
+    }).catch(e => {
+      console.log(e);
+    });
+  });
+});
+
+// describe('[Request::comment.getForActivityList] function test', () => {
+//   it('should return the comments for the activity type', (done) => {
+//     cw4.request.comment.getForActivityList().then(resp => {
+//       console.log(resp);
+//       // assert.isArray(resp);
+//       done();
+//     }).catch(e => {
+//       console.log(e);
+//     });
+//   });
+// });
+
 describe('[Request::changeProblem] function test', () => {
 
 });

package/test/05.caseTest.js

@@ -18,7 +18,27 @@ before(function(done) {
 
 describe('[Case (construct)] function test', () => {
   it('should be a defined object', (done) => {
-    assert.isObject(cw5.case, 'Request is an object');
+    assert.isObject(cw5.case, 'Case is an object');
+    done();
+  });
+  it('should have an financial property which is a defined object', (done) => {
+    assert.isObject(cw5.case.financial, 'Financial is an object');
+    done();
+  });
+  it('should have an data property which is a defined object', (done) => {
+    assert.isObject(cw5.case.data, 'Financial is an object');
+    done();
+  });
+  it('should have an workflow property which is a defined object', (done) => {
+    assert.isObject(cw5.case.workflow, 'Financial is an object');
+    done();
+  });
+  it('should have an comment property which is a defined object', (done) => {
+    assert.isObject(cw5.case.comment, 'Financial is an object');
+    done();
+  });
+  it('should have an admin property which is a defined object', (done) => {
+    assert.isObject(cw5.case.admin, 'Financial is an object');
     done();
   });
 });

package/test/06.caseFinancialTest.js

@@ -23,9 +23,9 @@ describe('[CaseFinancial (construct)] function test', () => {
   });
 });
 
-describe('[CaseFinancial::getCaseFees] function test', () => {
+describe('[CaseFinancial::getFees] function test', () => {
   it('should resolve a collection of case fees', (done) => {
-    cw6.case.financial.getCaseFees(16086).then(r => { // TODO: find case, then get fees
+    cw6.case.financial.getFees(16086).then(r => { // TODO: find case, then get fees
       assert.isArray(r);
       done();
     });
@@ -73,11 +73,11 @@ describe('[CaseFinancial::getAllFeeTemplates] function test', () => {
 
 describe('[CaseFinancial::searchFeeTemplates] function test', () => {
   it('should resolve a collection of case fees with interest in the name', (done) => {
-    cw6.case.financial.searchFeeTemplates(null, null, null, 'interest').then(r => { // TODO: find case, then get fees
+    cw6.case.financial.searchFeeTemplates({FeeDesc: 'interest'}).then(r => { // TODO: find case, then get fees
       assert.isArray(r);
       done();
     }).catch(e => {
-      console.log(e, e)
+      console.log(e, 'e')
     })
   });
 });

package/test/07.search.js

@@ -0,0 +1,192 @@
+'use strict';
+require('dotenv').config();
+var chai = require('chai');
+var expect = require('chai').expect;
+var assert = require('chai').assert;
+var chaiAsPromised = require("chai-as-promised");
+chai.use(chaiAsPromised);
+var Cityworks = require('../dist/index.js');
+var cw7 = new Cityworks(process.env.domain, {path: process.env.path});
+
+before(function(done) {
+  this.timeout(20000000);
+  cw7.authenticate(process.env.login, process.env.password).then(resp => {
+    done();
+  }).catch(e => {
+    console.log(e, 'unexpected error')
+    done();
+  });
+});
+
+describe('[Search::quick] function test', () => {
+  it('should resolve results', (done) => {
+    cw7.search.quick('256460').then(r => {
+      assert.property(r, 'ServiceRequests');
+      done();
+    });
+  });
+
+  it('should resolve (empty) results even when the string is not found', (done) => {
+    cw7.search.quick('SomethingSidewalk').then(r => {
+      assert.property(r, 'Permits');
+      done();
+    });
+  });
+});
+
+describe('[Search::execute] function test', () => {
+  it('should resolve a collection of search results', (done) => {
+    cw7.search.execute(3897).then(r => {
+      assert.isArray(r);
+      done();
+    });
+  });
+
+  it('should resolve an empty array if search ID is not found', (done) => {
+    cw7.search.execute(999999999).then(r => {
+      assert.isEmpty(r);
+      done();
+    });
+  });
+});
+
+describe('[Search::getSaved] function test', () => {
+  it('should resolve a collection of saved searches', (done) => {
+    cw7.search.getSaved('Request').then(r => {
+      assert.isArray(r);
+      done();
+    });
+  });
+
+  it('should reject with an error if the search type does not exist', (done) => {
+    cw7.search.getSaved('ServiceRequest').then(r => {
+    }).catch(e => {
+      // console.log(e)
+      assert.equal(e.message, 'SearchType provided does not exist or is mispelled.')
+      done();
+    });
+  });
+
+  it('should reject with an error if the applyToEntities and employeeSid/domainId are all set at the same time', (done) => {
+    cw7.search.getSaved('Request', ['EASEMENT_TREES'], 127, 1).then(r => {
+    }).catch(e => {
+      assert.equal(e.message, 'You cannot specify both applyToEntities AND employeeSid/domainId')
+      done();
+    });
+  });
+});
+
+describe('[Search::displayFields] function test', () => {
+  it('should resolve a collection of display fields', (done) => {
+    cw7.search.displayFields('WorkOrder').then(r => {
+      assert.isArray(r);
+      done();
+    });
+  });
+
+  it('should reject with an error if the searchType is not found', (done) => {
+    cw7.search.displayFields('ServiceRequest').then(r => {
+    }).catch(e => {
+      assert.equal(e.message, 'SearchType provided does not exist or is mispelled.')
+      done();
+    });
+  });
+});
+
+describe('[Search::types] function test', () => {
+  it('should resolve a collection of types', (done) => {
+    cw7.search.types().then(r => {
+      assert.isArray(r);
+      done();
+    });
+  });
+});
+
+describe('[Search::disableServices] function test', () => {
+  it('should resolve dictionary of searchIDs and boolean', (done) => {
+    cw7.search.disableServices([4338]).then(r => {
+      assert.propertyVal(r, 4338, true);
+      done();
+    });
+  });
+  it('should always be "False" if search ID does not exist', (done) => {
+    cw7.search.disableServices([9999999]).then(r => {
+      assert.propertyVal(r, 9999999, false);
+      done();
+    });
+  });
+});
+
+describe('[Search::enableServices] function test', () => {
+  it('should resolve dictionary of searchIDs and boolean', (done) => {
+    cw7.search.enableServices([4338]).then(r => {
+      assert.propertyVal(r, 4338, true);
+      done();
+    });
+  });
+  it('should always be "False" if search ID does not exist', (done) => {
+    cw7.search.enableServices([9999999]).then(r => {
+      assert.propertyVal(r, 9999999, false);
+      done();
+    });
+  });
+});
+
+describe('[Search::getDefinition] function test', () => {
+  it('should resolve the definition of the search', (done) => {
+    cw7.search.getDefinition(4338).then(r => {
+      assert.isObject(r);
+      done();
+    });
+  });
+  it('should be blanked search definition if the definition doesn\'t exist', (done) => {
+    cw7.search.getDefinition(9999999).then(r => {
+      assert.isEmpty(r.SearchFields);
+      done();
+    });
+  });
+});
+
+describe('[Search::getDefinitions] function test', () => {
+  it('should resolve the definition of the search', (done) => {
+    cw7.search.getDefinitions([4338,4337,4336]).then(r => {
+      assert.isArray(r);
+      done();
+    });
+  });
+  it('should be blanked search definition(s) if the definitions don\'t exist', (done) => {
+    cw7.search.getDefinitions([9999999,99999999,999999999]).then(r => {
+      assert.isEmpty(r[0].SearchFields);
+      done();
+    });
+  });
+});
+
+describe('[Search::getDefinitionNames] function test', () => {
+  it('should resolve a collection', (done) => {
+    cw7.search.getDefinitionNames([1,2,3,4,5]).then(r => {
+      assert.isArray(r);
+      done();
+    });
+  });
+});
+
+describe('[Search::saveDefinition] function test', () => {
+  it('should resolve a collection', (done) => {
+    cw7.search.saveDefinition('Request').then(r => {
+      assert.isNumber(r.SearchId);
+      done();
+    });
+  });
+});
+
+describe('[Search::deleteDefinitions] function test', () => {
+  it('should resolve a list of success or failure to delete per id', (done) => {
+    cw7.search.saveDefinition('Request').then(r => {
+      cw7.search.deleteDefinitions([r.SearchId]).then(rez => {
+        assert.isBoolean(rez[r.SearchId]);
+        done();
+      });
+    });
+  });
+});