GlideRecord Helper Functions

1var GlideRecordUtils = Class.create();
2GlideRecordUtils.prototype = {
3
4  /**
5   * Safely get a record by sys_id with error handling
6   *
7   * @param {string} table - Table name
8   * @param {string} sysId - sys_id of record
9   * @returns {GlideRecord|null} GlideRecord if found, null otherwise
10   */
11  get: function(table, sysId) {
12    if (!table || !sysId) {
13      gs.warn('GlideRecordUtils.get: table and sysId are required');
14      return null;
15    }
16
17    try {
18      var gr = new GlideRecord(table);
19      if (gr.get(sysId)) {
20        return gr;
21      }
22    } catch (e) {
23      gs.error('GlideRecordUtils.get error: ' + e.message);
24    }
25
26    return null;
27  },
28
29  /**
30   * Query records with simplified syntax
31   *
32   * @param {string} table - Table name
33   * @param {object} query - Query object {field: value}
34   * @param {object} options - {orderBy, limit, fields}
35   * @returns {Array} Array of record objects
36   */
37  query: function(table, query, options) {
38    var results = [];
39    options = options || {};
40
41    try {
42      var gr = new GlideRecord(table);
43
44      // Apply query conditions
45      for (var field in query) {
46        gr.addQuery(field, query[field]);
47      }
48
49      // Apply options
50      if (options.orderBy) {
51        gr.orderBy(options.orderBy);
52      }
53
54      if (options.limit) {
55        gr.setLimit(options.limit);
56      }
57
58      gr.query();
59
60      // Convert to array of objects
61      while (gr.next()) {
62        var record = {};
63
64        if (options.fields) {
65          // Only include specified fields
66          options.fields.forEach(function(field) {
67            record[field] = gr.getValue(field);
68          });
69        } else {
70          // Include all fields (be careful with this on large records)
71          record.sys_id = gr.sys_id.toString();
72
73          var elements = gr.getElements();
74          for (var i = 0; i < elements.size(); i++) {
75            var element = elements.get(i);
76            var fieldName = element.getName();
77            record[fieldName] = gr.getValue(fieldName);
78          }
79        }
80
81        results.push(record);
82      }
83    } catch (e) {
84      gs.error('GlideRecordUtils.query error: ' + e.message);
85    }
86
87    return results;
88  },
89
90  /**
91   * Update multiple records matching query
92   *
93   * @param {string} table - Table name
94   * @param {object} query - Query object {field: value}
95   * @param {object} updates - Fields to update {field: value}
96   * @returns {number} Number of records updated
97   */
98  updateMultiple: function(table, query, updates) {
99    var count = 0;
100
101    try {
102      var gr = new GlideRecord(table);
103
104      // Apply query
105      for (var field in query) {
106        gr.addQuery(field, query[field]);
107      }
108
109      gr.query();
110
111      // Update each record
112      while (gr.next()) {
113        for (var updateField in updates) {
114          gr.setValue(updateField, updates[updateField]);
115        }
116        gr.update();
117        count++;
118      }
119
120      gs.info('GlideRecordUtils.updateMultiple: Updated ' + count + ' records in ' + table);
121    } catch (e) {
122      gs.error('GlideRecordUtils.updateMultiple error: ' + e.message);
123    }
124
125    return count;
126  },
127
128  /**
129   * Delete multiple records matching query
130   *
131   * @param {string} table - Table name
132   * @param {object} query - Query object {field: value}
133   * @param {boolean} confirm - Safety confirmation (must be true)
134   * @returns {number} Number of records deleted
135   */
136  deleteMultiple: function(table, query, confirm) {
137    if (!confirm) {
138      gs.warn('GlideRecordUtils.deleteMultiple: confirmation required');
139      return 0;
140    }
141
142    var count = 0;
143
144    try {
145      var gr = new GlideRecord(table);
146
147      // Apply query
148      for (var field in query) {
149        gr.addQuery(field, query[field]);
150      }
151
152      gr.query();
153
154      // Delete each record
155      while (gr.next()) {
156        gr.deleteRecord();
157        count++;
158      }
159
160      gs.info('GlideRecordUtils.deleteMultiple: Deleted ' + count + ' records from ' + table);
161    } catch (e) {
162      gs.error('GlideRecordUtils.deleteMultiple error: ' + e.message);
163    }
164
165    return count;
166  },
167
168  /**
169   * Copy record to another table or same table
170   *
171   * @param {GlideRecord} sourceRecord - Source record to copy
172   * @param {string} targetTable - Target table name
173   * @param {Array} excludeFields - Fields to exclude from copy
174   * @returns {string} sys_id of new record or empty string
175   */
176  copyRecord: function(sourceRecord, targetTable, excludeFields) {
177    excludeFields = excludeFields || ['sys_id', 'sys_created_by', 'sys_created_on', 'sys_updated_by', 'sys_updated_on'];
178
179    try {
180      var grNew = new GlideRecord(targetTable);
181      grNew.initialize();
182
183      // Copy all fields except excluded ones
184      var elements = sourceRecord.getElements();
185      for (var i = 0; i < elements.size(); i++) {
186        var element = elements.get(i);
187        var fieldName = element.getName();
188
189        if (excludeFields.indexOf(fieldName) === -1) {
190          grNew.setValue(fieldName, sourceRecord.getValue(fieldName));
191        }
192      }
193
194      var newId = grNew.insert();
195
196      if (newId) {
197        gs.info('GlideRecordUtils.copyRecord: Copied ' + sourceRecord.getTableName() +
198                ' to ' + targetTable + ', new sys_id: ' + newId);
199        return newId;
200      }
201    } catch (e) {
202      gs.error('GlideRecordUtils.copyRecord error: ' + e.message);
203    }
204
205    return '';
206  },
207
208  /**
209   * Count records matching query
210   *
211   * @param {string} table - Table name
212   * @param {object} query - Query object {field: value}
213   * @returns {number} Count of matching records
214   */
215  count: function(table, query) {
216    try {
217      var ga = new GlideAggregate(table);
218
219      // Apply query
220      for (var field in query) {
221        ga.addQuery(field, query[field]);
222      }
223
224      ga.addAggregate('COUNT');
225      ga.query();
226
227      if (ga.next()) {
228        return parseInt(ga.getAggregate('COUNT'));
229      }
230    } catch (e) {
231      gs.error('GlideRecordUtils.count error: ' + e.message);
232    }
233
234    return 0;
235  },
236
237  /**
238   * Check if record exists
239   *
240   * @param {string} table - Table name
241   * @param {object} query - Query object {field: value}
242   * @returns {boolean} True if at least one record exists
243   */
244  exists: function(table, query) {
245    try {
246      var gr = new GlideRecord(table);
247
248      for (var field in query) {
249        gr.addQuery(field, query[field]);
250      }
251
252      gr.setLimit(1);
253      gr.query();
254
255      return gr.hasNext();
256    } catch (e) {
257      gs.error('GlideRecordUtils.exists error: ' + e.message);
258    }
259
260    return false;
261  },
262
263  /**
264   * Get related records (following reference field)
265   *
266   * @param {GlideRecord} record - Source record
267   * @param {string} relationshipField - Field name that contains relationship
268   * @param {object} options - {fields, limit, orderBy}
269   * @returns {Array} Array of related records
270   */
271  getRelatedRecords: function(record, relationshipField, options) {
272    options = options || {};
273    var results = [];
274
275    try {
276      var relatedTable = record.getElement(relationshipField).getReferenceTable();
277      var relatedId = record.getValue(relationshipField);
278
279      if (!relatedTable || !relatedId) {
280        return results;
281      }
282
283      var gr = new GlideRecord(relatedTable);
284      if (!gr.get(relatedId)) {
285        return results;
286      }
287
288      // Convert single record to result format
289      var result = {};
290      if (options.fields) {
291        options.fields.forEach(function(field) {
292          result[field] = gr.getValue(field);
293        });
294      } else {
295        result.sys_id = gr.sys_id.toString();
296        result.display_value = gr.getDisplayValue();
297      }
298
299      results.push(result);
300    } catch (e) {
301      gs.error('GlideRecordUtils.getRelatedRecords error: ' + e.message);
302    }
303
304    return results;
305  },
306
307  type: 'GlideRecordUtils'
308};