cityworks 0.0.1 → 0.0.5

package/README.md

@@ -4,7 +4,7 @@ This API wrapper for Cityworks follows the Cityworks release schedule as closely
 
 Require the class:
 
-      var cityworks = require('../dist/index.js');
+      var cityworks = require('cityworks');
 
 Configure the instance that is then available:
 
@@ -19,7 +19,7 @@ Authenticate with the Cityworks install:
       });
 
 
-Get the currently valid toke in order to store it in a session or cookie:
+Get the currently valid token in order to store it in a session or cookie:
 
       cityworks.getToken();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cityworks",
-  "version": "0.0.1",
+  "version": "0.0.5",
   "description": "A Cityworks API wrapper",
   "main": "dist/index.js",
   "umd:main": "dist/index.umd.js",
@@ -20,21 +20,22 @@
     "url": "git+https://github.com/walker/cityworks.git"
   },
   "keywords": [
-    "usdot",
+    "cityworks",
     "api",
     "wrapper",
-    "qcmobile",
-    "transportation",
-    "united-states"
+    "government",
+    "local",
+    "asset"
   ],
   "author": "Walker",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/walker/cityworks/issues"
   },
-  "homepage": "https://github.com/walker/cityworks#readme",
+  "homepage": "https://walker.github.io/cityworks/",
   "devDependencies": {
     "chai": "*",
+    "chai-as-promised": "^7.1.1",
     "dotenv": "^10.0.0",
     "jsdoc-to-markdown": "^7.0.1",
     "microbundle": "^0.13.3",
@@ -44,7 +45,6 @@
     "winston": "^3.3.3"
   },
   "dependencies": {
-    "chai-as-promised": "^7.1.1",
     "lodash": "^4.17.21",
     "reversible-map": "^1.0.1"
   }

package/src/inspection.ts

@@ -7,43 +7,133 @@ export class Inspection {
   /**
    * Construct activity link object for Inspection functions
    *
-   * @param {object} cw - Feed in the cityworks object instance so that this instance has access to the runRequest from the recursively-linked Cityworks instance
+   * @param {Object} cw - Feed in the cityworks object instance so that this instance has access to the runRequest from the recursively-linked Cityworks instance
    * @return {Object} Returns object that is this module
    */
   constructor(cw) {
-    this.cw = cw;
+    this.cw = cw
   }
 
   /**
-   * Create new inspection with data
+   * Create new inspection
    *
-   * @param {object} insp_data - See /{subdirectory}/apidocs/#/data-type-info;dataType=InspectionBase on your Cityworks instance
-   * @return {Object} Returns object that represents an object describing the newly-created inspection
+   * @category Inspections
+   * @param {Object} insp_data - See /{subdirectory}/apidocs/#/data-type-info;dataType=InspectionBase on your Cityworks instance
+   * @return {Object} Returns Promise that represents an object describing the newly-created inspection
    */
   create(insp_data: Object) {
     return new Promise((resolve, reject) => {
-      if(typeof(insp_data.EntityType)=='undefined' || typeof(insp_data.InspTemplateId)=='undefined') {
-        reject(new CWError(1, 'EntityType and InspTemplateId properties must be provided.', {'provided': insp_data}));
+      if(!_.has(insp_data, 'EntityType') || !_.has(insp_data, 'InspTemplateId')) {
+        reject(new CWError(1, 'EntityType and InspTemplateId properties must be provided.', {'provided': insp_data}))
       } else {
         this.cw.runRequest('Ams/Inspection/Create', insp_data).then(r => {
-          resolve(r.Value);
+          resolve(r.Value)
         }).catch(e => {
-          reject(e);
+          reject(e)
         });
       }
     });
   }
 
   /**
-   * Update an inspection with data
+   * Create inspections from an array of entities
+   *
+   * @category Inspections
+   * @param {Object} insp_data - See /{subdirectory}/apidocs/#/data-type-info;dataType=InspectionBase on your Cityworks instance
+   * @return {Object} Returns Promise that represents a collection of objects describing the newly-created inspections
+   */
+   createFromEntities(insp_data: Object) {
+    return new Promise((resolve, reject) => {
+     if(!_.has(insp_data, 'EntityType') || !_.has(insp_data, 'InspTemplateId')) {
+       reject(new CWError(1, 'EntityType and InspTemplateId properties must be provided.', {'provided': insp_data}));
+     } else {
+       this.cw.runRequest('Ams/Inspection/CreateFromEntities', insp_data).then(r => {
+         resolve(r.Value);
+       }).catch(e => {
+         reject(e);
+       });
+     }
+    });
+  }
+
+  /**
+   * Create an inspection from a parent inspection (TODO: what parent!?)
+   *
+   * @category Inspections
+   * @param {object} insp_data - See /{subdirectory}/apidocs/#/data-type-info;dataType=InspectionBase on your Cityworks instance
+   * @return {Object} Returns object that represents an object describing the newly-created inspection
+   */
+   createFromParent(insp_data: Object) {
+    return new Promise((resolve, reject) => {
+      // see if it's just InspectionId
+     if(!_.has(insp_data, 'EntityType') || !_.has(insp_data, 'InspTemplateId') || !_.has(insp_data, 'InspectionId')) {
+       reject(new CWError(1, 'EntityType and InspTemplateId properties must be provided.', {'provided': insp_data}));
+     } else {
+       this.cw.runRequest('Ams/Inspection/CreateFromParent', insp_data).then(r => {
+         resolve(r.Value);
+       }).catch(e => {
+         reject(e);
+       });
+     }
+    });
+  }
+
+  /**
+   * Create an inspection from a service request
+   *
+   * @category Inspections
+   * @param {object} insp_data - See /{subdirectory}/apidocs/#/data-type-info;dataType=InspectionBase on your Cityworks instance
+   * @return {Object} Returns object that represents an object describing the newly-created inspection
+   */
+   createFromServiceRequest(insp_data: Object) {
+    return new Promise((resolve, reject) => {
+     if(!_.has(insp_data, 'EntityType') || !_.has(insp_data, 'InspTemplateId') || !_.has(insp_data, 'RequestId')) {
+       reject(new CWError(1, 'EntityType and InspTemplateId properties must be provided.', {'provided': insp_data}));
+     } else {
+       this.cw.runRequest('Ams/Inspection/CreateFromServiceRequest', insp_data).then(r => {
+         resolve(r.Value);
+       }).catch(e => {
+         reject(e);
+       });
+     }
+    });
+  }
+
+  /**
+   * Create an inspection from a work order
    *
+   * @category Inspections
    * @param {object} insp_data - See /{subdirectory}/apidocs/#/data-type-info;dataType=InspectionBase on your Cityworks instance
-   * @return {Object} Returns object that represents an object describing the updated inspection
+   * @return {Object} Returns object that represents an object describing the newly-created inspection
+   */
+   createFromWorkOrder(insp_data: Object) {
+    return new Promise((resolve, reject) => {
+      // Are they  both actually required?!?!
+      // WorkOrderId
+      // WorkOrderSid ...do with only SID first then check
+     if(!_.has(insp_data, 'EntityType') || !_.has(insp_data, 'InspTemplateId') || !_.has(insp_data, 'WorkOrderSid')) {
+       reject(new CWError(1, 'EntityType and InspTemplateId properties must be provided.', {'provided': insp_data}));
+     } else {
+       this.cw.runRequest('Ams/Inspection/CreateFromWorkOrder', insp_data).then(r => {
+         resolve(r.Value);
+       }).catch(e => {
+         reject(e);
+       });
+     }
+    });
+  }
+
+  /**
+   * Update an inspection
+   *
+   * @category Inspections
+   * @param {object} insp_data - See /{subdirectory}/apidocs/#/data-type-info;dataType=InspectionBase on the Cityworks instance
+   * @return {Object} Returns Promise that represents an object describing the updated inspection
    */
   update(insp_data: Object) {
     return new Promise((resolve, reject) => {
       return new Promise((resolve, reject) => {
-        if(typeof(insp_data.InspectionId)=='undefined') {
+        if(!_.has(insp_data, 'InspectionId')) {
           reject(new CWError(1, 'InspectionId must be provided.', {'provided': insp_data}));
         } else {
           this.cw.runRequest('Ams/Inspection/Update', insp_data).then(r => {
@@ -57,10 +147,11 @@ export class Inspection {
   }
 
   /**
-   * Get an inspection by id
+   * Get an inspection by ID
    *
+   * @category Inspections
    * @param {number} inspectionId - The inspection ID to retrieve
-   * @return {Object} Returns object that represents an object describing the inspection
+   * @return {Object} Returns Promise that represents an object describing the inspection
    */
   getById(inspectionId: number) {
     return new Promise((resolve, reject) => {
@@ -76,10 +167,11 @@ export class Inspection {
   }
 
   /**
-   * Get inspections by a list of ids
+   * Get inspections by array of IDs
    *
-   * @param {Array<number>} inspectionIds - An array of the IDs to retrieve the matched inspections
-   * @return {Object} Returns object that represents an object describing the inspection
+   * @category Inspections
+   * @param {Array<number>} inspectionIds - The inspection IDs to retrieve
+   * @return {Object} Returns Promise that represents a collection of Objects describing the inspections
    */
   getByIds(inspectionIds: Array<number>) {
     return new Promise((resolve, reject) => {
@@ -94,9 +186,117 @@ export class Inspection {
     });
   }
 
+  /**
+   * Cancel inspections
+   *
+   * @category Inspections
+   * @param {Array<number>} inspectionIds - An array of the IDs to cancel the matched inspections
+   * @param {string} [cancelReason] - A reason for cancelling the inspection(s)
+   * @param {datetime} [dateCancelled] - The date/time that it should be indicated the inspection was cancelled
+   * @return {Object} Returns object that represents a collection of inspections
+   */
+   cancel(inspectionIds: Array<number>, cancelReason?: string, dateCancelled?: Date) {
+     return new Promise((resolve, reject) => {
+       var m = new Date();
+       var data: {InspectionIds: Array<number>, CancelReason?: string, DateCancelled?: Date} = { InspectionIds: inspectionIds };
+       if(typeof(cancelReason)!=='undefined') {
+         data.CancelReason = cancelReason;
+       }
+       if(typeof(dateCancelled)!=='undefined') {
+         data.DateCancelled = dateCancelled;
+       }
+       this.cw.runRequest('Ams/Inspection/Cancel', data).then(r => {
+         resolve(r.Value);
+       }).catch(e => {
+         reject(e);
+       });
+     });
+   }
+
+   /**
+    * Uncancel inspections
+    *
+    * @category Requests
+    * @param {Array<number>} inspectionIds - An array of the IDs to uncancel the matched requests
+    * @return {Object} Returns object that represents a collection of requests
+    */
+    uncancel(inspectionIds: Array<number>) {
+      return new Promise((resolve, reject) => {
+        var data = {
+          InspectionIds: inspectionIds
+        };
+        this.cw.runRequest('Ams/Inspection/Uncancel', data).then(r => {
+          resolve(r.Value);
+        }).catch(e => {
+          reject(e);
+        });
+      });
+    }
+
+   /**
+    * Close inspections
+    *
+    * @category Inspections
+    * @param {Array<number>} inspectionIds - An array of the IDs to close the matched inspections
+    * @return {Object} Returns object that represents a collection of inspections
+    */
+    close(inspectionIds: Array<number>) {
+      return new Promise((resolve, reject) => {
+        var data = {
+          InspectionIds: inspectionIds
+        };
+        this.cw.runRequest('Ams/Inspection/Close', data).then(r => {
+          resolve(r.Value);
+        }).catch(e => {
+          reject(e);
+        });
+      });
+    }
+
+  /**
+   * Reopen closed inspections
+   *
+   * @category Inspections
+   * @param {Array<number>} inspectionIds - An array of the IDs to reopen the matched inspections
+   * @return {Object} Returns object that represents a collection of inspections
+   */
+   reopen(inspectionIds: Array<number>) {
+     return new Promise((resolve, reject) => {
+       var data = {
+         InspectionIds: inspectionIds
+       };
+       this.cw.runRequest('Ams/Inspection/Reopen', data).then(r => {
+         resolve(r.Value);
+       }).catch(e => {
+         reject(e);
+       });
+     });
+   }
+
+  /**
+   * Delete inspections
+   *
+   * @category Inspections
+   * @param {Array<number>} inspectionIds - An array of the IDs to delete the matched inspections
+   * @return {Object} Returns object that represents a collection of inspection Ids which have been deleted
+   */
+   delete(inspectionIds: Array<number>) {
+     return new Promise((resolve, reject) => {
+       var data = {
+         InspectionIds: inspectionIds
+       };
+       this.cw.runRequest('Ams/Inspection/Delete', data).then(r => {
+         resolve(r.Value);
+       }).catch(e => {
+         reject(e);
+       });
+     });
+   }
+
   /**
    * Search for inspections
    *
+   * @category Inspections
    * @param {Object} searchData - An array of the IDs to retrieve the matched inspections, see instance docs: /{subdirectory}/apidocs/#/service-info/Ams/Inspection
    * @return {Object} Returns object that represents an array of the matching inspection IDs
    */
@@ -114,6 +314,7 @@ export class Inspection {
   /**
    * Get list of statuses
    *
+   * @category Inspection Options
    * @return {Object} Returns object that represents an array of all possible statuses for an Inspection
    */
   statuses() {
@@ -126,6 +327,371 @@ export class Inspection {
     });
   }
 
+  /**
+   * Get inspection submit to list
+   *
+   * @category Inspection Options
+   * @param {boolean} [includeInactiveEmployees] - whether to include inactive employees in the return. Defaults to false.
+   * @param {boolean} [domainIds] - which domains to include in the return, default to All domains
+   * @return {Object} Returns object that represents a collection of all possible employees for an Inspection's SubmitTo
+   */
+  submitTos(includeInactiveEmployees: boolean = false, domainIds?: Array<number>) {
+    return new Promise((resolve, reject) => {
+      var data: {IncludeInactiveEmployees?: boolean, DomainIds?: Array<number>} = {};
+      if(includeInactiveEmployees) {
+        data.IncludeInactiveEmployees = true;
+      }
+      if(typeof(domainIds)!=='undefined') {
+        data.DomainIds = domainIds;
+      }
+      this.cw.runRequest('Ams/Inspection/SubmitTos', data).then(r => {
+        resolve(r.Value);
+      }).catch(e => {
+        reject(e);
+      });
+    });
+  }
+
+
+  /**
+   * Add an entity to an existing inspection
+   * This method requires an Entity/Asset to be specified. You can either specify the Entity Type and its UID or a WorkOrderEntityBase Object.
+   *
+   * @category Inspections
+   * @param {Object} entity - Either of two attribute combinations are valid: entityType & entityUid OR Entity as a fully-inflated WorkOrderEntity (WorkOrderEntityBase) object.
+   * @param {number} inspectionId - An Inspection ID to attach the entity/asset to.
+   * @param {boolean} updateXY - Provide a boolean to whether the inspection's X/Y coordinates should be updated. Default is true.
+   * @param {Object} facility - Add Facility_Id for the Facility Identifier and Level_id for the Facility Level Identifier. Defaults to empty so that no facility is specified.
+   * @return {Object} Returns object that represents an object which describes an Inspection Entity
+   */
+  connectAsset(entity: {EntityType?: string, EntityUid?: string, Entity?: Object}, inspectionId: number, updateXY: boolean = true, facility: {Facility_Id?: string, Level_Id?: string} = {}) {
+   return new Promise((resolve, reject) => {
+     var data: {InspectionId: number, EntityType?: string, EntityUid?: string, Entity?: Object, Facility_Id?: string, Level_Id?: string} = {
+       InspectionId: inspectionId
+     };
+     if(_.has(entity, 'EntityType') && _.has(entity, 'EntityUid')) {
+       data.EntityType = entity.EntityType;
+       data.EntityUid = entity.EntityUid;
+     } else if(_.has(entity, 'Entity')) {
+       data.Entity = entity.Entity;
+     } else {
+       // Throw error, no entity/asset provided
+     }
+     if(_.has(facility, 'Facility_Id')) {
+       data.Facility_Id = facility.Facility_Id;
+     }
+     if(_.has(facility, 'Level_Id')) {
+       data.Level_Id = facility.Level_Id;
+     }
+     this.cw.runRequest('Ams/Inspection/AddEntity', data).then(r => {
+       resolve(r.Value);
+     }).catch(e => {
+       // 4 NotAuthorizedToUpdateInspection
+       // 9 InvalidActivityMapLogicXY
+       // 21 ErrorUnknownEntityType
+       // 30 InvalidField
+       // 60 WarningItemNotFound
+       // 68 MoveInvalidCityworksWkid
+       reject(e);
+     });
+   });
+  }
+
+  /**
+   * Get the answers for inspections
+   *
+   * @category Inspections
+   * @param {Array<number>} inspections - An Array of one or more Inspection IDs
+   * @return {Object} Returns Promise that represents a collection of Inspection Answers
+   */
+  getAnswers(inspections: Array<number>) {
+    return new Promise((resolve, reject) => {
+      var data: {InspectionId?: number, InspectionIds?: Array<number>} = {}
+      if(inspections.length==0) {
+        data.InspectionId = inspections[0]
+      } else {
+        data.InspectionIds = inspections
+      }
+      this.cw.runRequest('Ams/Inspection/Answers', data).then(r => {
+        resolve(r.Value)
+      }).catch(e => {
+        reject(e)
+      })
+    })
+  }
+
+  /**
+   * Get the audit log for a specific Inspection
+   *
+   * @category Inspections
+   * @param {number} inspectionId - An Inspection ID to get the audit log for
+   * @return {Object} Returns Promise that represents a collection of Cityworks Metadata Objects
+   */
+  getAuditLog(inspectionId: number) {
+    return new Promise((resolve, reject) => {
+      var data = {InspectionId: inspectionId}
+      this.cw.runRequest('Ams/Inspection/AuditLog', data).then(r => {
+        resolve(r.Value)
+      }).catch(e => {
+        reject(e)
+      })
+    })
+  }
+
+  /**
+   * Create a search definition. Save the definition by setting SaveDefinition = true and supplying a SearchName.
+   *
+   * @category Inspections
+   * @param {Object} searchData - Search data variables. See /{subdirectory}/apidocs/#/service-info/Ams/Inspection
+   * @param {number} [searchName] - What to name your search (if it should be saved)
+   * @param {number} [sharedWithin] - What group or domain to share the search to.
+   * @param {boolean} saveDefinition - Whether or not to save the search definition. Defaults to true when a search name is specified.
+   * @param {boolean} enableEurl - Whether or not to enable EURL for the saved search. Defaults to true.
+   * @return {Object} Returns Promise that represents a collection of Cityworks Metadata Objects
+   */
+  createSearchDefinition(searchData: Object, searchName?: string, sharedWithin?: number, saveDefinition: boolean = true, enableEurl: boolean = true) {
+    return new Promise((resolve, reject) => {
+      var data = searchData
+      if(_.isString(searchName)) {
+        _.set(data, 'SearchName', searchName)
+        _.set(data, 'SaveDefinition', saveDefinition)
+        _.set(data, 'EnableEurl', enableEurl)
+        // not sure how to handle sharedWithin...
+        // _.set(data, 'SharedWithin', sharedWithin)
+      }
+      this.cw.runRequest('Ams/Inspection/CreateSearchDefinition', data).then(r => {
+        resolve(r.Value)
+      }).catch(e => {
+        reject(e)
+      })
+    })
+  }
+
+  /**
+   * Get cycle from
+   *
+   * @category Inspection Options
+   * @return {Object} Returns Promise that represents ... I have no idea what this endpoint does
+   */
+  getCycleFrom() {
+    return new Promise((resolve, reject) => {
+      this.cw.runRequest('Ams/Inspection/CycleFrom', {}).then(r => {
+        resolve(r.Value)
+      }).catch(e => {
+        reject(e)
+      })
+    })
+  }
+
+  /**
+   * Get cycle intervals
+   *
+   * @category Inspection Options
+   * @return {Object} Returns Promise that represents a Dictionary of the cycle intervals available
+   */
+  getCycleIntervals() {
+    return new Promise((resolve, reject) => {
+      this.cw.runRequest('Ams/Inspection/CycleIntervals', {}).then(r => {
+        resolve(r.Value)
+      }).catch(e => {
+        reject(e)
+      })
+    })
+  }
+
+  /**
+   * Get cycle types
+   *
+   * @category Inspection Options
+   * @return {Object} Returns Promise that represents a Dictionary of the cycle types available
+   */
+  getCycleTypes() {
+    return new Promise((resolve, reject) => {
+      this.cw.runRequest('Ams/Inspection/CycleTypes', {}).then(r => {
+        resolve(r.Value)
+      }).catch(e => {
+        reject(e)
+      })
+    })
+  }
+
+  /**
+   * Get districts
+   *
+   * @category Inspection Options
+   * @return {Object} Returns Promise that represents an Array of the districts
+   */
+  getDistricts() {
+    return new Promise((resolve, reject) => {
+      this.cw.runRequest('Ams/Inspection/Districts', {}).then(r => {
+        resolve(r.Value)
+      }).catch(e => {
+        reject(e)
+      })
+    })
+  }
+
+
+  /**
+   * Move inspection by InspectionId. Must provide well known id (WKID) or well known text (WKT)
+   *
+   * @category Inspections
+   * @param {number} inspectionId - The ID of the inspection that should be moved
+   * @param {number} x - The X coordinate for the move
+   * @param {number} y - The Y coordinate for the move
+   * @param {Object} projection_info - An object which must include either WKID: Int32 or WKT: String. Can also include VcsWKID.
+   * @param {number} [z] - the optional z coordinate for the move
+   * @return {Object} Returns Promise which represents a GISPoint object
+   */
+  move(inspectionId: number, x: number, y: number, projection_info?: Object, z?: number) {
+    return new Promise((resolve, reject) => {
+      var data = {
+        InspectionId: inspectionId,
+        x: x,
+        y: y
+      }
+      if(typeof z != 'undefined') {
+        _.set(data, 'z', z)
+      }
+      if(typeof projection_info != 'undefined') {
+        if(_.has(projection_info, 'WKID')) {
+          _.set(data, 'WKID', _.get(projection_info, 'WKID'))
+        } else if(_.has(projection_info, 'WKT')) {
+          _.set(data, 'WKT', _.get(projection_info, 'WKT'))
+        }
+
+        if(_.has(projection_info, 'VcsWKID')) {
+          _.set(data, 'VcsWKID', _.get(projection_info, 'VcsWKID'))
+        }
+      }
+      this.cw.runRequest('Ams/Inspection/Move', {}).then(r => {
+        resolve(r.Value)
+      }).catch(e => {
+        reject(e)
+      })
+    })
+  }
+
+  /////
+  // INSPECTION TEMPLATES
+  /////
+
+  /**
+   * Get inspection templates
+   *
+   * @category Inspection Templates
+   * @param {Array<string>} [entityTypes] - The Entity Type(s) to return potential inspections for
+   * @param {boolean} [canCreate] - If true, only return templates the user can create, ignored if false or null, default is true
+   * @param {Object} [options] - An object which can include: [IncludeInactive]: boolean, MaximumDateModified: Date, MinimumDateModified: Date, TemplateIds: Array<number>
+   * @return {Object} Returns Promise that represents a collection of all possible employees for an Inspection's SubmitTo
+   */
+  getTemplates(entityTypes?: Array<string>, canCreate?: boolean, options?: {IncludeInactive?: boolean, MaximumDateModified?: Date, MinimumDateModified?: Date, TemplateIds?: Array<number>}) {
+    return new Promise((resolve, reject) => {
+      var data: {EntityTypes?: Array<string>, CanCreate?: boolean, IncludeInactive?: boolean, MaximumDateModified?: Date, MinimumDateModified?: Date, TemplateIds?: Array<number>} = {};
+      if(typeof(entityTypes)!=='undefined') {
+        data.EntityTypes = entityTypes;
+      }
+      data.CanCreate = typeof(canCreate)!=='undefined' ? canCreate : true;
+      if(typeof(options)==='object') {
+        _.forIn(options, (v, k) => {
+          data[k] = v;
+        });
+      }
+      this.cw.runRequest('Ams/InspectionTemplate/Templates', data).then(r => {
+        resolve(r.Value);
+      }).catch(e => {
+        reject(e);
+      });
+    });
+  }
+
+  /**
+   * Get a list of templates by IDs
+   *
+   * @category Inspection Templates
+   * @param {Array<number>} inspectionIds - An array of the IDs to retrieve the matched inspections
+   * @param {Object} [options] - An object which can include: [IncludeInactive]: boolean, MaximumDateModified: Date, MinimumDateModified: Date, TemplateIds: Array<number>
+   * @return {Object} Returns object that represents an object describing the inspection
+   */
+  getTemplatesByIds(inspTemplateIds: Array<number>, options?: {MaximumDateModified?: Date, MinimumDateModified?: Date}) {
+    return new Promise((resolve, reject) => {
+      var data = {
+        InspTemplateIds: inspTemplateIds
+      }
+      if(typeof(options)==='object') {
+        _.forIn(options, (v, k) => {
+          data[k] = v;
+        });
+      }
+      this.cw.runRequest('Ams/InspectionTemplate/ByIds', data).then(r => {
+        resolve(r.Value);
+      }).catch(e => {
+        reject(e);
+      });
+    });
+  }
+
+  /**
+   * Get entity types for inspection template(s)
+   *
+   * @category Inspection Templates
+   * @param {Array<number>} inspTemplateIds - An array of the IDs to reopen the matched inspections
+   * @return {Object} Returns object that represents an array of Entity Types
+   */
+   getTemplateEntityTypes(inspTemplateIds: Array<number>) {
+     return new Promise((resolve, reject) => {
+       var data = {
+         InspTemplateIds: inspTemplateIds
+       };
+       this.cw.runRequest('Ams/InspectionTemplate/EntityTypes', data).then(r => {
+         resolve(r.Value);
+       }).catch(e => {
+         reject(e);
+       });
+     });
+   }
+
+  /**
+  * Get the questions and answers for inspection template(s)
+  *
+  * @category Inspection Templates
+  * @param {Array<number>} inspTemplateIds - An array of the IDs to reopen the matched inspections
+  * @return {Object} Returns object that represents an array which contains a list of InspQuestionPanel for the template
+  */
+  getQA(inspTemplateIds: Array<number>) {
+    return new Promise((resolve, reject) => {
+      var data = {
+        InspTemplateIds: inspTemplateIds
+      };
+      this.cw.runRequest('Ams/InspectionTemplate/QA', data).then(r => {
+        resolve(r.Value);
+      }).catch(e => {
+        reject(e);
+      });
+    });
+  }
+
+  /**
+   * Get inspection template question conditions
+   *
+   * @category Inspection Templates
+   * @param {Array<number>} inspTemplateIds - An array of template IDs to get the matched inspection template Question conditions for
+   * @return {Object} Returns object that represents an array which contains a dictionary of InspQuestion IDs to configs
+   */
+   getQConditions(inspTemplateIds: Array<number>) {
+     return new Promise((resolve, reject) => {
+       var data = {
+         InspTemplateIds: inspTemplateIds
+       };
+       this.cw.runRequest('Ams/InspectionTemplate/QuestionConditions', data).then(r => {
+         resolve(r.Value);
+       }).catch(e => {
+         reject(e);
+       });
+     });
+   }
+
+
   // Attachments
 
   // AddInspectionAttachment InspAttachment
@@ -142,35 +708,83 @@ export class Inspection {
   //   "AttachmentType": null
   // }
 
-  // DeleteInspectionAttachments
-  // Delete inspection attachments
-  // Request Parameters
-  // List<Int32> req AttachmentIds
-  // Ams/Attachments/DeleteInspectionAttachments?data={
-  //   "AttachmentIds": null
-  // }
+  /**
+   * Delete inspection attachments
+   *
+   * @category Inspection Attachments
+   * @param {Array<number>} attachmentIds - An array of inspection attachment IDs to delete
+   * @return {Object} Returns object that represents a boolean for action resolution
+   */
+   deleteAttachments(attachmentIds: Array<number>) {
+     return new Promise((resolve, reject) => {
+       var data = {
+         AttachmentIds: attachmentIds
+       };
+       this.cw.runRequest('Ams/Attachments/DeleteInspectionAttachments', data).then(r => {
+         resolve(r.Value);
+       }).catch(e => {
+         reject(e);
+       });
+     });
+   }
 
-  // DownloadInspectionAttachment
-  // Download an inspection attachment
-  // Request Parameters
-  // Int32 req AttachmentId
-  // Ams/Attachments/DownloadInspectionAttachment?data={
-  //   "AttachmentId": null
-  // }
+  /**
+   * Download an inspection attachment
+   *
+   * @category Inspection Attachments
+   * @param {number} attachmentId - ID of an inspection attachment to download
+   * @return {Object} Returns object that represents a file stream
+   */
+   downloadAttachment(attachmentId: number) {
+     return new Promise((resolve, reject) => {
+       var data = {
+         AttachmentId: attachmentId
+       };
+       this.cw.runRequest('Ams/Attachments/DownloadInspectionAttachment', data).then(r => {
+         // TODO, pass file through // resolve(r.Value);
+       }).catch(e => {
+         reject(e);
+       });
+     });
+   }
 
-  // InspectionAttachmentById InspAttachment
-  // Get an inspection attachment by id
-  // Request Parameters
-  // Int32 req AttachmentId
-  // Ams/Attachments/InspectionAttachmentById?data={
-  //   "AttachmentId": null
-  // }
+  /**
+   * Get inspection attachment by ID
+   *
+   * @category Inspection Attachments
+   * @param {number} attachmentId - An attachment ID to get info for
+   * @return {Object} Returns object that represents an object that describes the matched inspection attachment
+   */
+   getAttachmentById(attachmentId: number) {
+     return new Promise((resolve, reject) => {
+       var data = {
+         AttachmentId: attachmentId
+       };
+       this.cw.runRequest('Ams/Attachments/InspectionAttachmentById', data).then(r => {
+         resolve(r.Value);
+       }).catch(e => {
+         reject(e);
+       });
+     });
+   }
 
-  // InspectionAttachments List<InspAttachment>
-  // Get inspections attachments
-  // Request Parameters
-  // List<Int32>reqInspectionIds
-  // Ams/Attachments/InspectionAttachments?data={
-  //     "InspectionIds": null
-  // }
+  /**
+   * Get inspection attachment by ID
+   *
+   * @category Inspection Attachments
+   * @param {Array<number>} inspectionIds - An array of inspection IDs to get attachments for
+   * @return {Object} Returns object that represents a collection of attachments from the matched inspections
+   */
+   getAttachments(inspectionIds: Array<number>) {
+     return new Promise((resolve, reject) => {
+       var data = {
+         InspectionIds: inspectionIds
+       };
+       this.cw.runRequest('Ams/Attachments/InspectionAttachments', data).then(r => {
+         resolve(r.Value);
+       }).catch(e => {
+         reject(e);
+       });
+     });
+   }
 }

package/src/request.ts

@@ -7,11 +7,480 @@ export class Request {
   /**
    * Construct activity link object for Request functions
    *
-   * @param {object} cw - Feed in the cityworks object instance so that this instance has access to the runRequest from the recursively-linked Cityworks instance
+   * @param {Object} cw - Feed in the cityworks object instance so that this instance has access to the runRequest from the recursively-linked Cityworks instance
    * @return {Object} Returns object that is this module
    */
   constructor(cw) {
     this.cw = cw;
   }
 
+  /**
+   * Create new requests
+   *
+   * @category Requests
+   * @param {Object} sr_data - See /{subdirectory}/apidocs/#/data-type-info;dataType=RequestBase on the Cityworks instance
+   * @return {Object} Returns Promise that represents an object describing the newly-created request
+   */
+  create(sr_data: Object) {
+    return new Promise((resolve, reject) => {
+      if(!_.has(sr_data, 'ProblemSid')) {
+        reject(new CWError(1, 'ProblemSid must be provided.', {'provided': sr_data}))
+      } else {
+        this.cw.runRequest('Ams/ServiceRequest/Create', sr_data).then(r => {
+          resolve(r.Value)
+        }).catch(e => {
+          reject(e)
+        });
+      }
+    });
+  }
+
+  /**
+   * Update a request
+   *
+   * @category Requests
+   * @param {object} sr_data - See /{subdirectory}/apidocs/#/data-type-info;dataType=RequestBase on the Cityworks instance
+   * @return {Object} Returns Promise that represents an object describing the updated request
+   */
+  update(sr_data: Object) {
+    return new Promise((resolve, reject) => {
+      return new Promise((resolve, reject) => {
+        if(!_.has(sr_data, 'RequestId')) {
+          reject(new CWError(1, 'RequestId must be provided.', {'provided': sr_data}));
+        } else {
+          this.cw.runRequest('Ams/ServiceRequest/Update', sr_data).then(r => {
+            resolve(r.Value);
+          }).catch(e => {
+            reject(e);
+          });
+        }
+      });
+    });
+  }
+
+  /**
+   * Change a request's problem code
+   *
+   * @category Requests
+   * @param {number} requestId - The request ID to change
+   * @param {number} problemSid - The request's new ProblemSID
+   * @return {Object} Returns Promise that represents an object describing the updated request
+   */
+  changeProblem(requestId: number, problemSid: number) {
+    return new Promise((resolve, reject) => {
+      return new Promise((resolve, reject) => {
+        var data = {
+          RequestId: requestId,
+          ProblemSid: problemSid
+        }
+        this.cw.runRequest('Ams/ServiceRequest/ChangeProblem', data).then(r => {
+          resolve(r.Value);
+        }).catch(e => {
+          reject(e);
+        });
+      });
+    });
+  }
+
+  /**
+   * Get a request by ID
+   *
+   * @category Requests
+   * @param {number} requestId - The ID of the reuqest to retrieve
+   * @return {Object} Returns Promise that represents an object describing the request
+   */
+  getById(requestId: number) {
+    return new Promise((resolve, reject) => {
+      var data = {
+        RequestId: requestId
+      }
+      this.cw.runRequest('Ams/ServiceRequest/ById', data).then(r => {
+        resolve(r.Value);
+      }).catch(e => {
+        reject(e);
+      });
+    });
+  }
+
+  /**
+   * Get requests by array of IDs
+   *
+   * @category Requests
+   * @param {Array<number>} requestIds - The request IDs to retrieve
+   * @return {Object} Returns Promise that represents a collection of Objects describing the requests
+   */
+  getByIds(requestIds: Array<number>) {
+    return new Promise((resolve, reject) => {
+      var data = {
+        RequestIds: requestIds
+      }
+      this.cw.runRequest('Ams/ServiceRequest/ByIds', data).then(r => {
+        resolve(r.Value);
+      }).catch(e => {
+        reject(e);
+      });
+    });
+  }
+
+  /**
+   * Get the audit log for a specific request
+   *
+   * @category Requests
+   * @param {number} requestId - A Request ID to get the audit log for
+   * @return {Object} Returns Promise that represents a collection of Cityworks Metadata Objects
+   */
+  getAuditLog(requestId: number) {
+    return new Promise((resolve, reject) => {
+      var data = {RequestId: requestId}
+      this.cw.runRequest('Ams/ServiceRequest/AuditLog', data).then(r => {
+        resolve(r.Value)
+      }).catch(e => {
+        reject(e)
+      })
+    })
+  }
+
+  /**
+   * Get custom fields for provided requests
+   *
+   * @category Requests
+   * @param {Array<number>} requestIds - The RequestIds whose custom fields should be returned
+   * @return {Object} Returns Promise that represents a collection of custom fields
+   */
+  getCustomFields(requestIds: Array<number>) {
+    return new Promise((resolve, reject) => {
+      var data = {
+        RequestIds: requestIds,
+      }
+      this.cw.runRequest('Ams/ServiceRequest/CustomFields', data).then(r => {
+        resolve(r.Value)
+      }).catch(e => {
+        reject(e)
+      })
+    })
+  }
+
+  /**
+   * Cancel requests
+   *
+   * @category Requests
+   * @param {Array<number>} requestIds - An array of the IDs to cancel the matched requests
+   * @param {string} [cancelReason] - A reason for cancelling the request(s)
+   * @param {datetime} [dateCancelled] - The date/time that it should be indicated the request was cancelled
+   * @return {Object} Returns object that represents a collection of requests
+   */
+   cancel(requestIds: Array<number>, cancelReason?: string, dateCancelled?: Date) {
+     return new Promise((resolve, reject) => {
+       var m = new Date();
+       var data: {RequestIds: Array<number>, CancelReason?: string, DateCancelled?: Date} = { RequestIds: requestIds };
+       if(typeof(cancelReason)!=='undefined') {
+         data.CancelReason = cancelReason;
+       }
+       if(typeof(dateCancelled)!=='undefined') {
+         data.DateCancelled = dateCancelled;
+       }
+       this.cw.runRequest('Ams/ServiceRequest/Cancel', data).then(r => {
+         resolve(r.Value);
+       }).catch(e => {
+         reject(e);
+       });
+     });
+   }
+
+   /**
+    * Uncancel requests
+    *
+    * @category Requests
+    * @param {Array<number>} requestIds - An array of the IDs to uncancel the matched requests
+    * @return {Object} Returns object that represents a collection of requests
+    */
+    uncancel(requestIds: Array<number>) {
+      return new Promise((resolve, reject) => {
+        var data = {
+          RequestIds: requestIds
+        };
+        this.cw.runRequest('Ams/ServiceRequest/Uncancel', data).then(r => {
+          resolve(r.Value);
+        }).catch(e => {
+          reject(e);
+        });
+      });
+    }
+
+   /**
+    * Close requests
+    *
+    * @category Requests
+    * @param {Array<number>} requestIds - An array of the IDs to close the matched requests
+    * @return {Object} Returns object that represents a collection of requests
+    */
+    close(requestIds: Array<number>) {
+      return new Promise((resolve, reject) => {
+        var data = {
+          RequestIds: requestIds
+        };
+        this.cw.runRequest('Ams/ServiceRequest/Close', data).then(r => {
+          resolve(r.Value);
+        }).catch(e => {
+          reject(e);
+        });
+      });
+    }
+
+    /**
+     * Reopen closed requests
+     *
+     * @category Requests
+     * @param {Array<number>} requestIds - An array of the IDs to reopen the matched requests
+     * @return {Object} Returns object that represents a collection of requests
+     */
+     reopen(requestIds: Array<number>) {
+       return new Promise((resolve, reject) => {
+         var data = {
+           RequestIds: requestIds
+         };
+         this.cw.runRequest('Ams/ServiceRequest/Reopen', data).then(r => {
+           resolve(r.Value);
+         }).catch(e => {
+           reject(e);
+         });
+       });
+     }
+
+  /**
+   * Delete requests
+   *
+   * @category Requests
+   * @param {Array<number>} requestIds - An array of the IDs to delete the matched requests
+   * @return {Object} Returns object that represents a collection of request Ids which have been deleted
+   */
+   delete(inspectionIds: Array<number>) {
+     return new Promise((resolve, reject) => {
+       var data = {
+         InspectionIds: inspectionIds
+       };
+       this.cw.runRequest('Ams/Inspection/Delete', data).then(r => {
+         resolve(r.Value);
+       }).catch(e => {
+         reject(e);
+       });
+     });
+   }
+
+  /**
+   * Get a list of problem nodes for a domain
+   *
+   * @category Request Categorization
+   * @param {number} domainId - The domain ID for which to retrieve problem nodes.
+   * @param {boolean} viewOnly - Return only view only problem nodes. Defaults to false.
+   * @param {Object} [displayMode] - Object that should contain two properties if you provide it: DisplayTextMode: string (C = Code, D = Description, CD = Code ~ Description). DisplayTextDelimeter: string, only impacts CD display text mode.
+   * @param {boolean} includeCancelled - Return only cancelled problem nodes as well. Defaults to false.
+   * @return {Object} Returns Promise that represents a collection of problem node objects.
+   */
+  getProblemNodes(domainId: number, viewOnly: boolean = false, displayMode?: Object, includeCancelled: boolean = false) {
+    return new Promise((resolve, reject) => {
+      var data = {
+        DomainId: domainId,
+        IncludeCancelled: includeCancelled,
+        ViewOnly: viewOnly
+      }
+      if(typeof displayMode != 'undefined' && _.has(displayMode, 'DisplayTextMode')) {
+        _.set(data, 'DisplayTextMode', _.get(displayMode, 'DisplayTextMode'));
+        if(_.get(displayMode, 'DisplayTextMode')=='CD' && _.has(displayMode, 'DisplayTextDelimeter')) {
+          _.set(data, 'DisplayTextDelimeter', _.get(displayMode, 'DisplayTextDelimeter'));
+        }
+      }
+      this.cw.runRequest('Ams/ServiceRequest/ProblemNodes', data).then(r => {
+        resolve(r.Value)
+      }).catch(e => {
+        reject(e)
+      })
+    })
+  }
+
+  /**
+   * Get a list of problem codes
+   *
+   * @category Request Options
+   * @param {boolean} forPublicOnly - Return only publicly-available service requests. Defaults to false.
+   * @param {boolean} onlyActiveTemplates - Return only active templates. Defaults to true.
+   * @return {Object} Returns Promise that represents an Array of problem name objects.
+   */
+  getProblems(forPublicOnly: boolean = false, onlyActiveTemplates: boolean = true, domainIds?: Array<number>) {
+    return new Promise((resolve, reject) => {
+      var data = {
+        ForPublicOnly: forPublicOnly,
+        OnlyActiveTemplates: onlyActiveTemplates
+      }
+      if(typeof domainIds != 'undefined') {
+        _.set(data, 'DomainIds', domainIds);
+      }
+      this.cw.runRequest('Ams/ServiceRequest/Problems', data).then(r => {
+        resolve(r.Value)
+      }).catch(e => {
+        reject(e)
+      })
+    })
+  }
+
+  /**
+   * Get a list of problem codes by keywords
+   *
+   * @category Request Options
+   * @param {string} keywords - Keywords to search for potential problem codes
+   * @return {Object} Returns Promise that represents an Array of problem name objects.
+   */
+  getProblemsByKeywords(keywords: string) {
+    return new Promise((resolve, reject) => {
+      var data = {
+        Keywords: keywords
+      }
+      this.cw.runRequest('Ams/ServiceRequest/ProblemsByKeywords', data).then(r => {
+        resolve(r.Value)
+      }).catch(e => {
+        reject(e)
+      })
+    })
+  }
+
+  /**
+   * Get a list of a problem code's priorities
+   *
+   * @category Request Options
+   * @param {number} problemSid - Return priorities for given problemSid
+   * @return {Object} Returns Promise that represents an Array of priorities
+   */
+  getPriorities(problemSid: number) {
+    return new Promise((resolve, reject) => {
+      var data = {
+        ProblemSids: problemSid,
+      }
+      this.cw.runRequest('Ams/ServiceRequest/Priorities', data).then(r => {
+        resolve(r.Value)
+      }).catch(e => {
+        reject(e)
+      })
+    })
+  }
+
+  /**
+   * Get custom field templates for problem code
+   *
+   * @category Request Options
+   * @param {number} problemSid - The problemSid whose template custom fields should be returned
+   * @return {Object} Returns Promise that represents a collection of custom fields
+   */
+  getCustomFieldTemplate(problemSid: number) {
+    return new Promise((resolve, reject) => {
+      var data = {
+        ProblemSids: problemSid,
+      }
+      this.cw.runRequest('Ams/ServiceRequest/TemplateCustomFields', data).then(r => {
+        resolve(r.Value)
+      }).catch(e => {
+        reject(e)
+      })
+    })
+  }
+
+  /**
+   * Get the questions and answer options for a problem code
+   *
+   * @category Request Options
+   * @param {number} problemSid - The problemSid whose Q&A should be returned
+   * @return {Object} Returns Promise that represents a collection of questions and answer settings
+   */
+  getQASettings(problemSid: number) {
+    return new Promise((resolve, reject) => {
+      var data = {
+        ProblemSids: problemSid,
+      }
+      this.cw.runRequest('Ams/ServiceRequest/QA', data).then(r => {
+        resolve(r.Value)
+      }).catch(e => {
+        reject(e)
+      })
+    })
+  }
+
+  /**
+   * Get problem leaf (template) by Sid
+   *
+   * @category Request Options
+   * @param {number} problemSid - Return problem leaf for given problemSid
+   * @return {Object} Returns Promise that represents an Object that describes the problem leaf (template)
+   */
+  getProblemLeaf(problemSid: number) {
+    return new Promise((resolve, reject) => {
+      var data = {
+        ProblemSid: problemSid
+      }
+      this.cw.runRequest('Ams/ServiceRequest/ProblemLeafBySid', data).then(r => {
+        resolve(r.Value)
+      }).catch(e => {
+        reject(e)
+      })
+    })
+  }
+
+  /**
+   * Get a list of default statuses
+   *
+   * @category Request Options
+   * @param {Array<number>} domainIds - List of domains to return default statuses for
+   * @return {Object} Returns Promise that represents an Array of statuses.
+   */
+  getStatuses(domainIds: Array<number>) {
+    return new Promise((resolve, reject) => {
+      var data = {
+        DomainIds: domainIds
+      }
+      this.cw.runRequest('Ams/ServiceRequest/DefaultStatus', data).then(r => {
+        resolve(r.Value)
+      }).catch(e => {
+        reject(e)
+      })
+    })
+  }
+
+  /**
+   * Get a list of possible DispatchTo values
+   *
+   * @category Request Options
+   * @param {Array<number>} domainId - Domain to return possible dispatchTo values for
+   * @return {Object} Returns Promise that represents an Array of dispatchTo options.
+   */
+  getDispatchTo(domainId: Array<number>) {
+    return new Promise((resolve, reject) => {
+      var data = {
+        DomainId: domainId
+      }
+      this.cw.runRequest('Ams/ServiceRequest/DispatchTo', data).then(r => {
+        resolve(r.Value)
+      }).catch(e => {
+        reject(e)
+      })
+    })
+  }
+
+  /**
+   * Get a list of possible SubmitTo values
+   *
+   * @category Request Options
+   * @param {Array<number>} domainId - Domain to return possible submitTo values for
+   * @return {Object} Returns Promise that represents an Array of submitTo options.
+   */
+  getSubmitTo(domainId: Array<number>) {
+    return new Promise((resolve, reject) => {
+      var data = {
+        DmainId: domainId
+      }
+      this.cw.runRequest('Ams/ServiceRequest/SubmitTo', data).then(r => {
+        resolve(r.Value)
+      }).catch(e => {
+        reject(e)
+      })
+    })
+  }
+
 }