cityworks 0.0.52 → 0.0.53

package/dist/inspection_admin.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InspectionAdmin = void 0;
+var _ = require('lodash');
+var InspectionAdmin = /** @class */ (function () {
+    /**
+     * @hidden
+     */
+    function InspectionAdmin(cw) {
+        this.cw = cw;
+    }
+    /**
+     * 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 Inspections matching the provided parameters
+     */
+    InspectionAdmin.prototype.getTemplates = function (entityTypes, canCreate, options) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var data = {};
+            if (typeof (entityTypes) !== 'undefined') {
+                data.EntityTypes = entityTypes;
+            }
+            data.CanCreate = typeof (canCreate) !== 'undefined' ? canCreate : true;
+            if (typeof (options) === 'object') {
+                _.forIn(options, function (v, k) {
+                    data[k] = v;
+                });
+            }
+            _this.cw.runRequest('Ams/InspectionTemplate/Templates', data).then(function (r) {
+                resolve(r.Value);
+            }).catch(function (e) {
+                reject(e);
+            });
+        });
+    };
+    return InspectionAdmin;
+}());
+exports.InspectionAdmin = InspectionAdmin;

package/dist/inspection_costs.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InspectionCosts = void 0;
+var _ = require('lodash');
+var InspectionCosts = /** @class */ (function () {
+    /**
+     * @hidden
+     */
+    function InspectionCosts(cw) {
+        this.cw = cw;
+        this.currentActivityType = "Inspection";
+    }
+    /**
+     * Get Cost Codes
+     *
+     * @category Labor Costs
+     * @param {Array<number>} employeeSids - A list of Employee IDs for which to get the job codes.
+     * @param {boolean} commonOnly - Set to true to get the Cost Codes that are common to ALL employees in the list, otherwise get all job codes that apply to at least one employee in the list.
+     * @return {Object} Returns Promise that represents an object describing
+     */
+    InspectionCosts.prototype.getCodes = function (employeeSids, commonOnly) {
+        var _this = this;
+        if (commonOnly === void 0) { commonOnly = false; }
+        return new Promise(function (resolve, reject) {
+            var data = {
+                EmployeeSids: employeeSids,
+                CommonCodesOnly: commonOnly
+            };
+            _this.cw.runRequest('Ams/LaborCost/CostCodes', data).then(function (r) {
+                resolve(r.Value);
+            }).catch(function (e) {
+                reject(e);
+            });
+        });
+    };
+    /**
+     * Get Job Codes
+     *
+     * @category Labor Costs
+     * @return {Object} Returns Promise that represents an object describing
+     */
+    InspectionCosts.prototype.getJobCodes = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            _this.cw.runRequest('Ams/LaborCost/JobCodes').then(function (r) {
+                resolve(r.Value);
+            }).catch(function (e) {
+                reject(e);
+            });
+        });
+    };
+    /**
+     * Add Inspection Labor Costs
+     *
+     * @category Inspection Costs
+     * @param {number} inspectionId - Inspection ID to add labor costs to
+     * @param {number} hours - The hours to add to the inspection
+     * @param {Object} options - Additional settings for hours setting
+     * @param {boolean} estimated - Boolean, get estimated or real costs, defaults to false (get real by default)
+     * @return {Object} Returns Promise that represents an object describing
+     */
+    InspectionCosts.prototype.addLabor = function (inspectionId, hours, options, estimated) {
+        var _this = this;
+        if (estimated === void 0) { estimated = false; }
+        return new Promise(function (resolve, reject) {
+            var data = {
+                Estimated: estimated,
+                InspectionIds: inspectionId,
+                Hours: hours
+            };
+            if (typeof (options) != 'undefined') {
+                data = _.merge(data, options);
+            }
+            _this.cw.runRequest('Ams/LaborCost/AddInspectionCosts', data).then(function (response) {
+                resolve(response.Value);
+            }).catch(function (e) {
+                reject(e);
+            });
+        });
+    };
+    /**
+    * Get Labor Costs for a specific list of Inspections
+    *
+    * @category Inspection Costs
+    * @param {Array<int>} inspectionIds - An array of inspection IDs to get associated costs for.
+    * @param {boolean} estimated - Boolean, get estimated or real costs, defaults to false (get real by default)
+    * @return {Object} Returns Promise that represents an object describing
+    */
+    InspectionCosts.prototype.getLabor = function (inspectionIds, estimated) {
+        var _this = this;
+        if (estimated === void 0) { estimated = false; }
+        return new Promise(function (resolve, reject) {
+            var data = {
+                Estimated: estimated,
+                InspectionIds: inspectionIds
+            };
+            _this.cw.runRequest('Ams/LaborCost/InspectionCostsByInspection', data).then(function (response) {
+                resolve(response.Value);
+            }).catch(function (e) {
+                reject(e);
+            });
+        });
+    };
+    /**
+     * Delete Inspection Labor Costs
+     *
+     * @category Inspection Costs
+     * @param {Array<int>} laborCostIds - An array of inspection labor cost IDs to delete
+     * @param {boolean} estimated - Boolean, delete estimated or real costs, defaults to false (delete real by default)
+     * @return {Object} Returns Promise that represents an object describing
+     */
+    InspectionCosts.prototype.deleteLabor = function (laborCostIds, estimated) {
+        var _this = this;
+        if (estimated === void 0) { estimated = false; }
+        return new Promise(function (resolve, reject) {
+            var data = {
+                Estimated: estimated,
+                reqLaborCostIds: laborCostIds
+            };
+            _this.cw.runRequest('Ams/LaborCost/DeleteInspectionCosts', data).then(function (response) {
+                resolve(response.Value);
+            }).catch(function (e) {
+                reject(e);
+            });
+        });
+    };
+    /**
+   * Add Inspection Equipment Costs
+   *
+   * @category Inspection Costs
+   * @param {Object} inspectionId - the inspection to add the equipment costs to
+   * @param {Object} options - additional options
+   * @return {Object} Returns Promise that represents an object describing
+   */
+    InspectionCosts.prototype.addEquipment = function (inspectionId, options) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var data = {
+                InspectionId: inspectionId
+            };
+            if (typeof (options) != 'undefined') {
+                data = _.merge(data, options);
+            }
+            // TODO: ensure each object has Hours & InspectionId
+            _this.cw.runRequest('Ams/EquipmentCost/AddInspectionCosts', data).then(function (response) {
+                resolve(response.Value);
+            }).catch(function (e) {
+                reject(e);
+            });
+        });
+    };
+    /**
+    * Get Equipment Costs for Inspection(s)
+    *
+    * @category Inspection Costs
+    * @param {Array<number>} inspectionIds - the inspection to get the equipment costs for.
+    * @param {Object} estimated - get estimated equipment costs. Defaults to false.
+    * @return {Object} Returns Promise that represents an object describing
+    */
+    InspectionCosts.prototype.getEquipment = function (inspectionIds, estimated) {
+        var _this = this;
+        if (estimated === void 0) { estimated = false; }
+        return new Promise(function (resolve, reject) {
+            var data = {
+                InspectionIds: inspectionIds,
+                Estimated: estimated
+            };
+            _this.cw.runRequest('Ams/EquipmentCost/InspectionCostsByInspection', data).then(function (response) {
+                resolve(response.Value);
+            }).catch(function (e) {
+                reject(e);
+            });
+        });
+    };
+    /**
+     * Delete Inspection Equipment Costs
+     *
+     * @category Inspection Costs
+     * @param {Array<number>} equipmentCostIds - the equipment cost IDs to delete.
+     * @param {Object} estimated - delete estimated equipment costs. Defaults to false.
+     * @return {Object} Returns Promise that represents an object describing
+     */
+    InspectionCosts.prototype.deleteEquipment = function (equipmentCostIds, estimated) {
+        var _this = this;
+        if (estimated === void 0) { estimated = false; }
+        return new Promise(function (resolve, reject) {
+            var data = {
+                EquipmentCostIds: equipmentCostIds,
+                Estimated: estimated
+            };
+            _this.cw.runRequest('Ams/EquipmentCost/DeleteInspectionCosts', data).then(function (response) {
+                resolve(response.Value);
+            }).catch(function (e) {
+                reject(e);
+            });
+        });
+    };
+    return InspectionCosts;
+}());
+exports.InspectionCosts = InspectionCosts;

package/dist/message_queue.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageQueue = void 0;
+var error_1 = require("./error");
+var _ = require('lodash');
+var MessageQueue = /** @class */ (function () {
+    /**
+     * @hidden
+     */
+    function MessageQueue(cw) {
+        /**
+         * Statuses -
+         * Pending: 0,
+         * Processing: 1,
+         * Complete: 2,
+         * Failed: 3
+         */
+        this.status = {
+            Pending: 0,
+            Processing: 1,
+            Complete: 2,
+            Failed: 3
+        };
+        /**
+         * Hook Types -
+         * Unknown: 0,
+         * ActivityUpdate: 1,
+         * Email: 2,
+         * WebHook: 3
+         */
+        this.hook_types = {
+            Unknown: 0,
+            ActivityUpdate: 1,
+            Email: 2,
+            WebHook: 3
+        };
+        this.cw = cw;
+    }
+    /**
+     * Process Webhook MessageQueue records by MessageQueueId
+     *
+     * @param {Array<number>} [ids] - List of MessageQueueId values
+     * @param {boolean} [delete_successful] - automatically delete messages that complete with successful execution, default is false
+     * @return {Array<>} Returns Promise object that represents a collection of QueueMessages which have been processed
+     */
+    MessageQueue.prototype.processMessages = function (ids, delete_successful) {
+        var _this = this;
+        if (delete_successful === void 0) { delete_successful = false; }
+        return new Promise(function (resolve, reject) {
+            var data = { Ids: ids, Delete: delete_successful };
+            var path = 'General/WebHookEvent/ProcessMessages';
+            _this.cw.runRequest(path, data).then(function (response) {
+                // TODO
+            }).catch(function (e) {
+                reject(e);
+            });
+        });
+    };
+    /**
+     * Get Messages specified in list of MessageQueueIds
+     *
+     * @param {Array<number>} ids - List of MessageQueueId values
+     * @param {string} status -
+     * @param {number} [maxcount] - Maximum number returned. Defaults to 15
+     * @return {Array<>} Returns Promise object that represents a collection of QueueMessages which have been processed
+     */
+    MessageQueue.prototype.get = function (ids, status, maxcount) {
+        var _this = this;
+        if (maxcount === void 0) { maxcount = 15; }
+        return new Promise(function (resolve, reject) {
+            if (typeof (_this.status[status]) == 'undefined') {
+                reject(new error_1.CWError(1, 'Status provided does not exist or is mispelled.', { 'provided': status, 'available': _this.status }));
+            }
+            var data = {
+                "Ids": ids,
+                "MaxCount": typeof (maxcount) != 'undefined' ? maxcount : 15,
+                "Status": _this.status[status]
+            };
+            var path = 'General/MessageQueue/ByIds';
+            _this.cw.runRequest(path, data).then(function (response) {
+                // TODO
+            }).catch(function (e) {
+                reject(e);
+            });
+        });
+    };
+    /**
+     * Delete Messages specified in list of MessageQueueIds
+     *
+     * @param {Array<number>} ids - List of MessageQueueId values
+     * @param {string} status - automatically delete messages that complete with successful execution, default is false
+     * @param {number} [hours_to_keep] - utomatically delete messages that complete with successful execution, default is false
+     * @return {Array<>} Returns Promise object that represents a collection of QueueMessages which have been processed
+     */
+    MessageQueue.prototype.delete = function (ids, status, hours_to_keep) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            if (typeof (_this.status[status]) == 'undefined') {
+                reject(new error_1.CWError(2, 'Status provided does not exist or is mispelled.', { 'provided': status, 'available': _this.status }));
+            }
+            var data = {
+                "Ids": ids,
+                "Status": _this.status[status],
+                "HoursToKeep": hours_to_keep
+            };
+            var path = 'General/MessageQueue/Delete';
+            _this.cw.runRequest(path, data).then(function (response) {
+                // TODO
+            }).catch(function (e) {
+                reject(e);
+            });
+        });
+    };
+    // PreferencesList<GlobalPreference>
+    // Base response type: CoreResponseBase
+    // Get a list of message queue preferences
+    // This method has no parameters
+    MessageQueue.prototype.preferences = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var data = {};
+            var path = 'General/MessageQueue/Preferences';
+            _this.cw.runRequest(path, data).then(function (response) {
+                // TODO
+            }).catch(function (e) {
+                reject(e);
+            });
+        });
+    };
+    MessageQueue.prototype.search = function (parameters, max_results) {
+        var _this = this;
+        var data;
+        return new Promise(function (resolve, reject) {
+            if (typeof (parameters.status) !== 'undefined' && typeof (_this.status[parameters.status]) == 'undefined') {
+                reject(new error_1.CWError(3, 'Status provided does not exist or is mispelled.', { 'provided': parameters.status, 'available': _this.status }));
+            }
+            else if (typeof (parameters.status) !== 'undefined' && typeof (_this.status[parameters.status]) !== 'undefined') {
+                data.Status = _this.status[parameters.status];
+            }
+            if (typeof (max_results) !== 'undefined') {
+                data.MaxResults = max_results;
+            }
+            var allowed_params = ['Id', 'HookId', 'HookType', 'Result', 'DateCreatedBegin', 'DateCreatedEnd', 'DateUpdatedBegin', 'DateUpdatedEnd'];
+            var disallowed_params = ['Status', 'MaxResults'];
+            _.forEach(parameters, function (v, k) {
+                if (_.indexOf(allowed_params, k) != -1 && _.indexOf(disallowed_params, k) == -1) {
+                    data[k] = v;
+                }
+                else if (_.indexOf(disallowed_params, k) == -1) {
+                    reject(new error_1.CWError(4, 'Provided parameter does not exist or is mispelled.', { 'provided': k, 'value': v, 'available': _.concat(allowed_params, disallowed_params) }));
+                }
+            });
+            var path = 'General/MessageQueue/Search';
+            _this.cw.runRequest(path, data).then(function (response) {
+                // TODO
+                if (typeof (response.Value) == 'undefined') {
+                    response.Value = [];
+                }
+                resolve(response.Value);
+            }).catch(function (e) {
+                reject(e);
+            });
+        });
+    };
+    /**
+     * Update queue message
+     *
+     * @param {Object} parameters - Provide allowed parameters:
+     *
+     *      {
+     *        HookId: number,
+     *        Id: number,
+     *        Packet: string,
+     *        Result: string,
+     *        Status: string, // Available options: Pending, Processing, Complete, Failed
+     *        HookType: string // Available options: Unknown, ActivityUpdate, Email, WebHook
+     *      }
+     *
+     * @return {Object} Returns Promise object that represents an Object with the desired GIS service definitions
+     */
+    MessageQueue.prototype.update = function (parameters) {
+        var _this = this;
+        var data;
+        return new Promise(function (resolve, reject) {
+            if (typeof (parameters.status) !== 'undefined' && typeof (_this.status[parameters.status]) == 'undefined') {
+                reject(new error_1.CWError(3, 'Status provided does not exist or is mispelled.', { 'provided': parameters.status, 'available': _this.status }));
+            }
+            else if (typeof (parameters.status) !== 'undefined' && typeof (_this.status[parameters.status]) !== 'undefined') {
+                data.Status = _this.status[parameters.status];
+            }
+            if (typeof (parameters.hook_types) !== 'undefined' && typeof (_this.hook_types[parameters.hook_types]) == 'undefined') {
+                reject(new error_1.CWError(3, 'Status provided does not exist or is mispelled.', { 'provided': parameters.hook_types, 'available': _this.hook_types }));
+            }
+            else if (typeof (parameters.hook_types) !== 'undefined' && typeof (_this.hook_types[parameters.hook_types]) !== 'undefined') {
+                data.HookType = _this.hook_types[parameters.hook_types];
+            }
+            var allowed_params = ['Id', 'HookId', 'Packet', 'Result'];
+            var disallowed_params = ['Status', 'HookType'];
+            _.forEach(parameters, function (v, k) {
+                if (_.indexOf(allowed_params, k) != -1 && _.indexOf(disallowed_params, k) == -1) {
+                    data[k] = v;
+                }
+                else if (_.indexOf(disallowed_params, k) == -1) {
+                    reject(new error_1.CWError(5, 'Provided parameter does not exist or is mispelled.', { 'provided': k, 'value': v, 'available': _.concat(allowed_params, disallowed_params) }));
+                }
+            });
+            var path = 'General/MessageQueue/Update';
+            _this.cw.runRequest(path, data).then(function (response) {
+                // TODO
+                if (typeof (response.Value) == 'undefined') {
+                    response.Value = [];
+                }
+                resolve(response.Value);
+            });
+        });
+    };
+    MessageQueue.prototype.updateMessageStatus = function (ids, status, hours_to_keep) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            if (typeof (_this.status[status]) == 'undefined') {
+                reject(new error_1.CWError(2, 'Status provided does not exist or is mispelled.', { 'provided': status, 'available': _this.status }));
+            }
+            var data = {
+                "Ids": ids,
+                "Status": _this.status[status],
+                "HoursToKeep": hours_to_keep
+            };
+            var path = 'General/MessageQueue/UpdateMessageStatus';
+            _this.cw.runRequest(path, data).then(function (response) {
+                // TODO
+            });
+        });
+    };
+    MessageQueue.prototype.getWebooks = function (hook_ids) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var data = {
+                "HookIds": hook_ids
+            };
+            var path = 'General/MessageQueue/WebHooks';
+            _this.cw.runRequest(path, data).then(function (response) {
+                // TODO
+            });
+        });
+    };
+    return MessageQueue;
+}());
+exports.MessageQueue = MessageQueue;

package/dist/query.d.ts

@@ -0,0 +1,108 @@
+interface DynamicVariableMap {
+    [key: string]: any;
+}
+interface DynamicResponseDefinition {
+    [key: string]: any;
+}
+export declare class Query {
+    /**
+     * @hidden
+     */
+    cw: any;
+    /**
+     * @hidden
+     */
+    constructor(cw: any);
+    /**
+     * Build a query using query language syntax or by specifying a saved query ID
+     *
+     * @category Query
+     * @param {number} query - Query to run (specify syntax or queryID)
+     * @param {Object} options - Other options. See: /{subdirectory}/apidocs/#/service-info/General/Query
+     * @param {number} [domainId] - The domain ID of the domain to search, defaut is authenticated user's current domain
+     * @return {Object} Returns Promise object that represents a list of Objects
+     */
+    build(query: number | string, options?: {
+        Page?: number;
+        PageSize?: number;
+        SortDescending?: boolean;
+        SortField?: string;
+        Variables?: DynamicVariableMap;
+    }, domainId?: number): Promise<unknown>;
+    /**
+     * Get available query types
+     *
+     * @category Query
+     * @return {Object} Returns Promise object that represents a list of Objects
+     */
+    getTypes(): Promise<unknown>;
+    /**
+     * Get info about query types
+     *
+     * @category Query
+     * @param {boolean} includeDefaultSchemasInclude - Include schemas (Work Order, Service Request, etc), default is true.
+     * @param {boolean} includeGisSchemas - Include gis schemas, ddefault is true.
+     * @param {number} [domainId] - The domain ID of the domain to search, defaut is authenticated user's current domain
+     * @return {Object} Returns Promise object that represents a list of Objects
+     */
+    getTypesInfo(includeDefaultSchemasInclude?: boolean, includeGisSchemas?: boolean, domainId?: number): Promise<unknown>;
+    /**
+     * Validate a query string
+     *
+     * @category Query
+     * @param {string} query - The query to validate
+     * @param {DynamicVariableMap} variables - Required if the query includes variables
+     * @param {number} [domainId] - The domain ID of the domain to search, defaut is authenticated user's current domain
+     * @return {Object} Returns Promise object that represents a list of Objects
+     */
+    validateQuery(query: string, variables: DynamicVariableMap, domainId?: number): Promise<unknown>;
+    /**
+     * Validate a query response definition
+     *
+     * @category Query
+     * @param {string} queryType - The query to validate
+     * @param {DynamicResponseDefinition} responseDefinition - Required if the query includes variables
+     * @param {number} [domainId] - The domain ID of the domain to search, defaut is authenticated user's current domain
+     * @return {Object} Returns Promise object that represents a list of Objects
+     */
+    validateResponseDefinition(queryType: string, responseDefinition: DynamicResponseDefinition, domainId?: number): Promise<unknown>;
+    /**
+     * Get schema for specified query type
+     *
+     * @category Query
+     * @param {string} queryType - Specify Query Type
+     * @param {number} [domainId] - The domain ID of the domain to search, defaut is authenticated user's current domain. Used to determine query field configuration for the schema fields.
+     * @return {Object} Returns Promise object that represents a list of Objects
+     */
+    getSchema(queryType: string, domainId?: number): Promise<unknown>;
+    /**
+     * Run a query using query language syntax
+     *
+     * @category Query
+     * @param {number} query - Query syntax string or saved query ID to run. If you want to append addt'l query items to a saved query, add QueryValue in the options
+     * @param {Object} options - Other options. See: /{subdirectory}/apidocs/#/service-info/General/Query
+     * @return {Object} Returns Promise object that represents a list of Objects
+     */
+    run(query: string, options?: {
+        QueryValue?: string;
+        Page?: number;
+        PageSize?: number;
+        ResponseFields?: any;
+        SortDescending?: boolean;
+        SortField?: string;
+        Variables?: DynamicVariableMap;
+    }): Promise<unknown>;
+    /**
+     * Get a list of the saved queries the current user can access.
+     *
+     * @category Query
+     * @param {Array<string>} queryTypes - Get the saved queries for a particular type, default is all types
+     * @param {boolean} createdOnly - Get only queries created by the current user, default is get all queries current user can access
+     * @param {boolean} includeQuery - Restrict GIS searches to specified entity types
+     * @param {boolean} [visibleToMobile] - Filter visibility to mobile. Default ignore visibility to mobile.
+     * @param {number} [domainId] - The domain ID of the domain to search, defaut is authenticated user's current domain
+     * @return {Object} Returns Promise object that represents a collection of SavedQueries
+     */
+    getSaved(queryTypes?: Array<string>, createdOnly?: boolean, includeQuery?: boolean, visibleToMobile?: boolean, domainId?: number): Promise<unknown>;
+}
+export {};