PageSourceSearch
Opt out API access

https://app.datasert.com/assets/Jobs-CgikPvva.js

js datasert.com collected 2026-09-24 14:41:51 UTC 100,861 bytes, 1,017 lines download raw bytes 

1import { Q as QBreadcrumbsEl } from "./QBreadcrumbsEl-DJmFSikN.js";
2import { O as getDeletedJobBackup, P as getDeletedJobsBackups, Q as deleteAndPurgeJobs, S as createJobBackup, T as getJobsJsonSummaryUrl, U as getSummaryJson, V as updateJobsBulk, W as executeJobs, X as importJob, Y as purgeJobs, Z as unlockJobs, _ as lockJobs, $ as deleteJobs, a0 as cloneJob, a1 as getJobFolders, a2 as getRecentJobIds, a3 as getJobs } from "./realsyncUtils-B_eb3OgH.js";
3import { aY as Folder_Recent, aB as sortIc, B as getEntityNamesListForDialog, y as confirmDelete, j as jsUtilsExports, h as notifySuccess, aP as showInput, R as showConfirm, aZ as Folder_Blank, aC as getEnvNamefromEnv, P as confirmExecute, K as STATUS_INACTIVE, S as STATUS_ACTIVE, H as isFilterStatusMatch, t as getCachedProfileOrNil, ag as getCacheOrCompute, z as deepClone, s as setLocalStore, _ as filterOwnerOptions, a_ as filterFrequencyOptions, aO as filterStatusesOptions, a6 as getLocalStore, aF as getFrequencyForList, v as valueLabels } from "./utils-Dl9t6EOZ.js";
4import { B as BackupsDialog, J as JobDialog } from "./BackupsDialog-CyfOwrVw.js";
5import { m as mixins } from "./mixins-BCMXzTHA.js";
6import { C as ChangeOwnerDialog } from "./ChangeOwnerDialog-BQ1BAtot.js";
7import { Q as QForm } from "./QForm-B7u6vHMU.js";
8import { _ as _export_sfc, c as createBlock, o as openBlock, w as withCtx, a as createVNode, r as resolveComponent, e as createCommentVNode, j as createTextVNode } from "./index-l2g1tnsc.js";
9import { T as TextViewerDialog } from "./TextViewerDialog-BPyN4E_q.js";
10import { I as InputJsonDialog } from "./InputJsonDialog-CZBYKuBU.js";
11import { E as EnvRef } from "./EnvRef-DLnnFTas.js";
12import { G as GridSelect } from "./GridSelect-CjyiI6pi.js";
13import "./http-QV44vcaW.js";
14import "./NotificationProps-CMkALiQg.js";
15import "./DialogSection-D-hqVt65.js";
16import "./Tooltip-BL9mlxg7.js";
17import "./Popover-DdmYwYku.js";
18import "./light-ChFcYHVz.js";
19import "./Scrollbar-w6xdyLLY.js";
20import "./SharingDialog-8nsVnUso.js";
21import "./api-CsX1TBBI.js";
22import "./mixinsV3-DJOx874v.js";
23import "./lodash-D-1jTqv6.js";
24/* empty css                                                     */
25import "./InputDateTime-Bg3tHE_T.js";
26import "./use-render-cache-DRJWLz-b.js";
27import "./QMenu-CMxSVE7y.js";
28import "./position-engine-DlL3Wjag.js";
29import "./selection-CtEbNG46.js";
30import "./ClosePopup-BJ95hjD9.js";
31import "./Column-CHEOSUiF.js";
32import "./InputSelect-BYAmTdat.js";
33import "./QItemSection-BtIVec04.js";
34import "./QSelect-a5Elgrcr.js";
35import "./QChip-o69cw4ec.js";
36import "./QItemLabel-Bl1X4QV1.js";
37import "./rtl-DDpZOXNn.js";
38import "./api-Dz7DFSvS.js";
39import "./api-5Qbpc5nF.js";
40import "./api-EaByEhnn.js";
41import "./TextViewer-DMWZwv7n.js";
42import "./styles-Ba8hxl-j.js";
43import "./CheckboxInline-OqdiZR8_.js";
44import "./QTooltip-CLIBmLrc.js";
45import "./IconMenu-DT6mxtJq.js";
46import "./QList-uCfqyM8w.js";
47import "./Icon-PX2LcDsd.js";
48import "./MenuItem-DTtADa1D.js";
49import "./Row-D4VaIJlq.js";
50import "./InputTemplate-C6rgpBgP.js";
51import "./FileViewerDialog2-dcy5GH6m.js";
52import "./Datagrid-0ZPXgtsI.js";
53import "./AgGridVue-P7zRffUM.js";
54import "./DataGridStatusRenderer-BEpV8SXs.js";
55import "./SyncStatus-Ehz8Em6K.js";
56import "./Close-CMLcMmhU.js";
57import "./Icon-XvtDqeG4.js";
58import "./replaceable-D4umoBrm.js";
59import "./upperFirst-DygzsnnD.js";
60import "./Toolbar-Cf2a7rhK.js";
61import "./QToolbarTitle-BeXkQQHt.js";
62import "./QToolbar-DonaEblG.js";
63import "./Avatar-DzN63Sfl.js";
64import "./is-browser-DvVMOi1n.js";
65import "./RecordRef-71_FjUo4.js";
66import "./RecordLink-BhuEBSlE.js";
67import "./RouteLink-CCU5m11L.js";
68const _sfc_main$2 = {
69  mixins: [mixins],
70  props: {
71    modelValue: Boolean,
72    model: Object,
73    envs: Array
74  },
75  emits: ["ok", "cancel", "update:modelValue"],
76  data() {
77    return {
78      modelInternal: Object.assign({}, this.model)
79    };
80  },
81  watch: {
82    modelValue() {
83      if (!this.modelValue) {
84        return;
85      }
86      this.message = null;
87      this.initingSuccess = true;
88    }
89  },
90  methods: {
91    close() {
92      this.$emit("cancel");
93    },
94    save() {
95      this.processForm(async () => {
96        this.$emit("ok", this.modelInternal);
97        this.close();
98      });
99    },
100    getStatusOptions() {
101      return [
102        { id: "", name: "All" },
103        { id: "active", name: "Active" },
104        { id: "inactive", name: "Inactive" },
105        { id: "error", name: "Error" }
106      ];
107    }
108  }
109};
110function _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) {

111  const _component_InputSelect = resolveComponent("InputSelect");
112  const _component_Column = resolveComponent("Column");
113  const _component_Row = resolveComponent("Row");
114  const _component_ContentDialog = resolveComponent("ContentDialog");
115  return openBlock(), createBlock(_component_ContentDialog, {
116    title: "Jobs Filter",
117    modelValue: $props.modelValue,
118    "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => _ctx.$emit("update:modelValue")),
119    message: _ctx.message,
120    messageType: _ctx.messageType,
121    initing: _ctx.initing,
122    initingSuccess: _ctx.initingSuccess,
123    processing: _ctx.processing,
124    processingCancellable: _ctx.processingCancellable,
125    height: "auto",
126    width: "600px",
127    onProcessingCancelled: _cache[3] || (_cache[3] = ($event) => _ctx.processingCancelled = true),
128    onDOk: $options.save
129  }, {
130    default: withCtx(() => [
131      createVNode(QForm, {
132        autofocus: "",
133        ref: "form"
134      }, {
135        default: withCtx(() => [
136          createVNode(_component_Row, null, {
137            default: withCtx(() => [
138              createVNode(_component_Column, null, {
139                default: withCtx(() => [
140                  createVNode(_component_InputSelect, {
141                    options: $options.getStatusOptions(),
142                    modelValue: $data.modelInternal.status,
143                    "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => $data.modelInternal.status = $event),
144                    label: "Status"
145                  }, null, 8, ["options", "modelValue"])
146                ]),
147                _: 1
148              }),
149              createVNode(_component_Column, null, {
150                default: withCtx(() => [
151                  createVNode(_component_InputSelect, {
152                    modelValue: $data.modelInternal.envId,
153                    "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => $data.modelInternal.envId = $event),
154                    label: "Env",
155                    options: $props.envs,
156                    showDefault: "",
157                    defaultLabel: "All",
158                    defaultValue: ""
159                  }, null, 8, ["modelValue", "options"])
160                ]),
161                _: 1
162              })
163            ]),
164            _: 1
165          })
166        ]),
167        _: 1
168      }, 512)
169    ]),
170    _: 1
171  }, 8, ["modelValue", "message", "messageType", "initing", "initingSuccess", "processing", "processingCancellable", "onDOk"]);
172}
173const JobsFilterDialog = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["render", _sfc_render$2], ["__scopeId", "data-v-d17e2ede"], ["__file", "JobsFilterDialog.vue"]]);
174const _sfc_main$1 = {
175  mixins: [mixins],
176  components: { TextViewerDialog },
177  props: {
178    modelValue: Boolean
179  },
180  emits: ["update:modelValue"],
181  data() {
182    return {
183      columns: [{ value: "name" }],
184      records: this.getBackups,
185      progressOpen: false,
186      loading: false,
187      init: false,
188      initingSuccess: true,
189      backups: [],
190      textViewerOpen: false,
191      textViewerContent: "",
192      textViewerTitle: "Job Backup"
193    };
194  },
195  methods: {
196    async getBackups() {
197      this.backups = await getDeletedJobsBackups() || [];
198      return this.backups;
199    },
200    refresh() {
201      this.refreshGrid();
202    },
203    refreshGrid() {
204      if (this.$refs.grid) {
205        this.$refs.grid.refresh();
206      }
207    },
208    getSelection() {
209      return this.$refs.grid.getConfirmedSelection();
210    },
211    async handleView(rec) {
212      if (!rec) {
213        return;
214      }
215      this.processForm(async () => {
216        const resp = await getDeletedJobBackup(rec.id);
217        this.textViewerContent = JSON.stringify(resp.content, void 0, "  ");
218        this.textViewerOpen = true;
219      });
220    }
221  }
222};
223function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
224  const _component_Table = resolveComponent("Table");
225  const _component_TextViewerDialog = resolveComponent("TextViewerDialog");
226  const _component_ContentDialog = resolveComponent("ContentDialog");
227  return openBlock(), createBlock(_component_ContentDialog, {
228    title: "Deleted Jobs",
229    modelValue: $props.modelValue,
230    "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => _ctx.$emit("update:modelValue")),
231    height: "auto",
232    width: "1000px",
233    closeMode: "",
234    initing: _ctx.initing,
235    initingSuccess: $data.initingSuccess,
236    processing: _ctx.processing,
237    message: _ctx.message,
238    messageType: _ctx.messageType
239  }, {
240    default: withCtx(() => [
241      createVNode(_component_Table, {
242        ref: "grid",
243        auditCreated: "",
244        updatable: false,
245        creatable: false,
246        deletable: false,
247        hideSelection: true,
248        viewable: "",
249        columns: $data.columns,
250        records: $data.records,
251        onView: $options.handleView,
252        recordType: "Backup",
253        recordTypePlural: "Backups",
254        refreshable: true
255      }, null, 8, ["columns", "records", "onView"]),
256      createVNode(_component_TextViewerDialog, {
257        modelValue: $data.textViewerOpen,
258        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => $data.textViewerOpen = $event),
259        content: $data.textViewerContent,
260        title: $data.textViewerTitle,
261        code: ""
262      }, null, 8, ["modelValue", "content", "title"])
263    ]),
264    _: 1
265  }, 8, ["modelValue", "initing", "initingSuccess", "processing", "message", "messageType"]);
266}
267const DeletedJobsBackupsDialog = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["render", _sfc_render$1], ["__file", "DeletedJobsBackupsDialog.vue"]]);
268const cacheKeyFilterFolder = "rt.jobs.filter.folder";
269const cacheKeyFilterEnvId = "rt.jobs.filter.env";

270const _sfc_main = {
271  mixins: [mixins],
272  components: {
273    JobDialog,
274    ChangeOwnerDialog,
275    JobsFilterDialog,
276    BackupsDialog,
277    DeletedJobsBackupsDialog,
278    InputJsonDialog,
279    EnvRef,
280    TextViewerDialog,
281    GridSelect
282  },
283  data() {
284    return {
285      columns: [
286        {
287          value: "name"
288        },
289        { value: "status" },
290        { value: (row) => getFrequencyForList(row.options.scheduling), label: "Frequency" },
291        {
292          value: "envField",
293          label: "Env"
294        },
295        { value: "folder" },
296        {
297          value: (row) => {
298            var _a, _b;
299            return ((_b = (_a = row.settings) == null ? void 0 : _a.scheduling) == null ? void 0 : _b.lastRunAt) || "";
300          },
301          type: "datetime",
302          label: "Last Run At"
303        },
304        { value: "nextRunAt", type: "datetime" },
305        {
306          value: (row) => row.run_updated_at || "",
307          type: "datetime",
308          label: "Run Updated At"
309        },
310        { value: (row) => row.options.resourceLevel, label: "Resource Level" },
311        {
312          value: (row) => row.options.executionMethod,
313          label: "Job Duration",
314          valueLabels: valueLabels.executionMethod
315        },
316        { value: (row) => row.options.logLevel, label: "Log Level" }
317      ],
318      records: this.getRecords,
319      progressOpen: false,
320      loading: false,
321      init: false,
322      initingSuccess: true,
323      dialogOpen: false,
324      dialogFolder: "",
325      dialogMode: "add",
326      dialogJobId: null,
327      dialogData: [],
328      model: {},
329      changeOwnerDialogOpen: false,
330      changeOwnerDialogData: [],
331      filterReq: {
332        envId: getLocalStore(cacheKeyFilterEnvId) || "",
333        folder: getLocalStore(cacheKeyFilterFolder) || "",
334        status: "",
335        frequency: ""
336      },
337      jobsFilterDialogOpen: false,
338      envs: [],
339      folders: [],
340      status: "",
341      jobs: [],
342      filteredJobs: [],
343      recentJobIds: [],
344      filterStatuses: filterStatusesOptions,
345      filterFrequencyOptions,
346      filterOwnerOptions,
347      textViewerOpen: false,
348      textViewerContent: "",
349      textViewerTitle: "Job Export (Json)",
350      backupsDialogOpen: false,
351      backupsDialogEntityId: "",
352      backupsDialogTitle: "Job Backups",
353      deletedJobsBackupsDialogOpen: false,
354      importJobsDialogOpen: false,
355      importJobsDialogError: "",
356      importJobsDialogContent: ""
357    };
358  },
359  async created() {
360    this.envs = await this.getEnvRefs();
361  },
362  watch: {
363    "filterReq.envId"() {
364      setLocalStore(cacheKeyFilterEnvId, this.filterReq.envId);
365      this.filter();
366    },
367    "filterReq.folder"() {
368      setLocalStore(cacheKeyFilterFolder, this.filterReq.folder);
369      this.filter();
370      this.sortJobs();
371    },
372    "filterReq.status"() {
373      this.filter();
374    },
375    "filterReq.frequency"() {
376      this.filter();
377    },
378    "filterReq.owner"() {
379      this.filter();
380    }
381  },
382  methods: {
383    async getRecords() {
384      if (!this.init) {
385        this.init = true;
386        await this.getJobs();
387      }
388      this.updateStatus();
389      return deepClone(this.filteredJobs);
390    },
391    async getJobs(force = false) {
392      this.loading = true;
393      const filterParams = {
394        envId: this.filterReq.envId || void 0,
395        folder: this.filterReq.folder || void 0
396      };
397      const cacheKey = `rtJobs_${JSON.stringify(filterParams)}`;
398      const [jobs, foldersResp, recentJobsResp] = await Promise.all([
399        getCacheOrCompute("jobs", cacheKey, 30, force, () => getJobs(filterParams)),
400        getJobFolders(),
401        getRecentJobIds()
402      ]);
403      this.recentJobIds = (recentJobsResp.ids || []).slice(0, 10);
404      this.filteredJobs = this.jobs = jobs || [];
405      this.updateFolders(foldersResp);
406      this.filter();
407      this.sortJobs();
408      this.updateStatus();
409      this.loading = false;
410      force ? this.refresh() : void 0;
411    },
412    setFilteredJobs(jobs = []) {
413      this.filteredJobs = jobs;
414    },
415    refresh() {
416      this.refreshGrid();
417    },
418    refreshGrid() {
419      if (this.$refs.grid) {
420        this.$refs.grid.refresh();
421      }
422    },
423    async refreshJobs() {
424      await this.getJobs(true);
425    },
426    handleAdd() {
427      this.message = null;
428      this.dialogJobId = void 0;
429      this.dialogMode = "add";
430      this.dialogOpen = true;
431      this.dialogFolder = this.filterReq.folder;
432    },
433    filter() {
434      if (this.filterReq.folder !== Folder_Recent && this.filterReq.folder !== Folder_Blank && !this.folders.map((folder) => folder.id).includes(this.filterReq.folder)) {
435        this.filterReq.folder = "";
436      }
437      if (!this.filterReq.folder && !this.filterReq.envId && !this.filterReq.status && !this.filterReq.frequency && !this.filterReq.owner) {
438        const jobs = [...this.jobs].filter((it) => it.status !== "deleted");
439        this.setFilteredJobs(jobs);
440      } else {
441        let jobs = [...this.jobs];
442        if (this.filterReq.folder) {
443          if (this.filterReq.folder === Folder_Recent) {
444            jobs = jobs.filter((job) => this.recentJobIds.includes(job.id));
445          } else if (this.filterReq.folder === Folder_Blank) {
446            jobs = jobs.filter((job) => !job.folder || jsUtilsExports.equalsIc(job.folder, Folder_Blank));
447          } else {
448            jobs = jobs.filter((job) => jsUtilsExports.equalsIc(job.folder, this.filterReq.folder));
449          }
450        }
451        if (this.filterReq.envId) {
452          jobs = jobs.filter((job) => job.envId === this.filterReq.envId);
453        }
454        if (this.filterReq.status) {
455          jobs = jobs.filter((job) => isFilterStatusMatch(job.status, job.runStatus, this.filterReq.status));
456        } else {
457          jobs = jobs.filter((job) => job.status !== "deleted");
458        }
459        if (this.filterReq.frequency) {
460          jobs = jobs.filter(
461            (job) => {
462              var _a, _b, _c, _d;
463              return this.filterReq.frequency === "manual" ? ((_b = (_a = job.options) == null ? void 0 : _a.scheduling) == null ? void 0 : _b.frequency) === "manual" : ((_d = (_c = job.options) == null ? void 0 : _c.scheduling) == null ? void 0 : _d.frequency) !== "manual";
464            }
465          );
466        }
467        if (this.filterReq.owner) {
468          const profile = getCachedProfileOrNil();
469          if (profile) {
470            jobs = jobs.filter((job) => this.filterReq.owner === "me" ? job.ownerId === profile.userId : job.ownerId !== profile.userId);
471          }
472        }
473        this.setFilteredJobs(jobs);
474      }
475      this.refresh();
476    },
477    async handleClone(rec) {
478      return this.processForm(async () => {
479        try {
480          await cloneJob(rec.id);
481          this.processing = false;

482          await this.getJobs(true);
483        } finally {
484          this.progressOpen = false;
485        }
486      });
487    },
488    async handleDelete(recs) {
489      this.message = null;
490      const msg = `Are you sure you want to delete following Jobs? </br> ${getEntityNamesListForDialog(recs)}`;
491      const confirmed = await confirmDelete("Delete Jobs?", msg);
492      if (confirmed) {
493        this.handleDeleteAfterConfirm(recs);
494      }
495    },
496    handleDeleteAfterConfirm(recs) {
497      this.progressOpen = true;
498      this.processForm(async () => {
499        try {
500          const resp = await deleteJobs({ records: recs.map((rec) => ({ id: rec.id })) });
501          notifySuccess(resp.message);
502          this.processing = false;
503          await this.getJobs(true);
504        } finally {
505          this.progressOpen = false;
506        }
507      });
508    },
509    handleEdit(rec) {
510      this.message = null;
511      this.dialogJobId = rec.id;
512      this.dialogMode = "edit";
513      this.dialogOpen = true;
514      this.dialogData = rec;
515    },
516    async handleSave(conn) {
517      await this.getJobs(true);
518    },
519    handleActivate() {
520      this.updateJobsBulk(this.getSelection(), { status: STATUS_ACTIVE });
521    },
522    handleInactivate() {
523      this.updateJobsBulk(this.getSelection(), { status: STATUS_INACTIVE });
524    },
525    handleLockJobs() {
526      const sels = this.getSelection();
527      this.processForm(async () => {
528        await lockJobs({ ids: jsUtilsExports.mapToIds(sels) });
529        notifySuccess("Jobs have been locked");
530        await this.getJobs(true);
531      });
532    },
533    handleUnlockJobs() {
534      const sels = this.getSelection();
535      this.processForm(async () => {
536        await unlockJobs({ ids: jsUtilsExports.mapToIds(sels) });
537        notifySuccess("Jobs have been unlocked");
538        await this.getJobs(true);
539      });
540    },
541    async handlePurgeJobs() {
542      const sels = this.getSelection();
543      const nonDeletedSels = sels.filter((it) => !jsUtilsExports.isDeleted(it));
544      if (nonDeletedSels.length > 0) {
545        this.message = "Only deleted Jobs can be purged";
546        return;
547      }
548      this.message = null;
549      const msg = `Are you sure you want to purge following Jobs? <ul> ${getEntityNamesListForDialog(sels)} </ul>If confirmed, selected Jobs, its Tasks and Runs will be PERMANENTLY DELETED.`;
550      const confirmed = await confirmDelete("Purge Jobs?", msg);
551      if (confirmed) {
552        return this.processForm(async () => {
553          const resp = await purgeJobs({ ids: jsUtilsExports.mapToIds(sels) });
554          notifySuccess(resp.message || "Selected Jobs have been purged");
555          await this.getJobs(true);
556        });
557      }
558    },
559    validateImportJobJson(content) {
560      if (!content.name) {
561        throw new Error("Field name is required");
562      }
563    },
564    handleImportJob() {
565      this.importJobsDialogContent = "";
566      this.importJobsDialogError = "";
567      this.importJobsDialogOpen = true;
568    },
569    handleImportJobOk(content) {
570      this.importJobsDialogOpen = false;
571      this.process(async () => {
572        try {
573          const resp = await importJob(JSON.parse(content));
574          this.refreshJobs();
575          notifySuccess(resp.message || "Job has been imported");
576        } catch (e) {
577          this.importJobsDialogContent = content;
578          this.importJobsDialogOpen = true;
579          this.importJobsDialogError = e.message;
580        }
581      });
582    },
583    async handleRunJobs() {
584      const sels = this.getSelection();
585      if (sels) {
586        const confirmed = await confirmExecute("Run Jobs?", `Are you sure you want to run selected ${sels.length} Jobs?`);
587        if (confirmed) {
588          this.executeJobs(sels);
589        }
590      }
591    },
592    executeJobs(sels) {
593      this.processForm(async () => {
594        await executeJobs({ records: sels.map((dl) => ({ id: dl.id })) });
595        this.processing = false;
596        notifySuccess("Jobs have been submitted for execution");
597        await this.getJobs(true);
598      });
599    },
600    updateJobsBulk(sels, fieldsToUpdate) {
601      if (!sels || sels.length === 0) {
602        return;
603      }
604      const payload = sels.map((sel) => Object.assign({ id: sel.id }, fieldsToUpdate));
605      this.processForm(async () => {
606        await updateJobsBulk({ records: payload });
607        notifySuccess("Jobs have been updated");
608        await this.getJobs(true);
609      });
610    },
611    getSelection() {
612      return this.$refs.grid.getConfirmedSelection();
613    },
614    // async runClickHandle(sel) {
615    //   if (sel) {
616    //     const confirmed = await utils.confirmExecute('Run Job?', 'Are you sure you want to run selected Job?');
617    //
618    //     if (confirmed) {
619    //       this.executeJobs([sel]);
620    //     }
621    //   }
622    // },
623    handleChangeOwner() {

624      this.changeOwnerDialogData = this.getSelection();
625      if (this.changeOwnerDialogData) {
626        this.changeOwnerDialogOpen = true;
627      }
628    },
629    async handleChangeFolder() {
630      const input = await showInput("New Folder Name", "Enter new folder name. Leave it blank and click Ok to remove folder from selected jobs.");
631      if (input === void 0) {
632        return;
633      }
634      await this.updateJobsBulk(this.getSelection(), { folder: input });
635    },
636    openJobsFilterDialog() {
637      this.jobsFilterDialogOpen = true;
638    },
639    handleJobFilter(range) {
640      this.filterReq = this.filterReq || {};
641      this.filterReq.status = range.status;
642      this.filterReq.envId = range.envId || "";
643      this.filterReq.folder = range.folder || "";
644      this.$refs.grid.refresh();
645    },
646    updateStatus() {
647      const filters = [
648        `Env: ${this.filterReq.envId ? getEnvNamefromEnv(this.envs, this.filterReq.envId) : "All"}`,
649        `Folder: ${this.filterReq.folder ? this.filterReq.folder : "All"}`,
650        `Status: ${this.filterReq.status ? this.filterReq.status : "All"}`
651      ];
652      this.status = `Filter [${filters.join(", ")}]`;
653    },
654    updateFolders(foldersResp) {
655      const folders = sortIc(foldersResp.folders.map((it) => it));
656      this.folders = [
657        { id: Folder_Recent, name: Folder_Recent },
658        { id: Folder_Blank, name: Folder_Blank },
659        ...folders.map((folder) => ({ id: folder, name: folder }))
660      ];
661    },
662    async viewSummaryJson() {
663      const rec = this.$refs.grid.getConfirmedSelectionOne();
664      if (!rec) {
665        return;
666      }
667      return this.processForm(async () => {
668        this.textViewerContent = await getSummaryJson(rec.id);
669        this.textViewerOpen = true;
670      });
671    },
672    async exportAllJobs() {
673      const recs = this.$refs.grid.getConfirmedSelection();
674      if (!recs) {
675        return;
676      }
677      const msg = `You are exporting details of ${recs.length} Jobs. </br></br> Are you sure you want to continue?`;
678      const confirmed = await showConfirm("Export Jobs", msg);
679      if (!confirmed) {
680        return;
681      } else {
682        return this.processForm(async () => {
683          const res = await getJobsJsonSummaryUrl({ ids: recs.map((it) => it.id) });
684          window.open(res.downloadUrl, "_self");
685        });
686      }
687    },
688    async createBackup() {
689      const rec = this.$refs.grid.getConfirmedSelectionOne();
690      if (!rec) {
691        return;
692      }
693      const name = await showInput("Backup Name", "Please enter backup name", { required: true });
694      if (!name) {
695        return;
696      }
697      return this.processForm(async () => {
698        const resp = await createJobBackup(rec.id, { name });
699        notifySuccess(resp.message || "Backup has been created");
700      });
701    },
702    async viewBackups() {
703      const rec = this.$refs.grid.getConfirmedSelectionOne();
704      if (!rec) {
705        return;
706      }
707      this.backupsDialogEntityId = rec.id;
708      this.backupsDialogTitle = `Job Backups - ${rec.name}`;
709      this.backupsDialogOpen = true;
710    },
711    viewDeletedJobs() {
712      this.deletedJobsBackupsDialogOpen = true;
713    },
714    async handleDeletePurgeJobs() {
715      const sels = this.getSelection();
716      if (!sels || sels.length === 0) {
717        return;
718      }
719      const msg = `Are you sure you want to delete and purge following Jobs? <ul> ${getEntityNamesListForDialog(sels)} </ul>If confirmed, selected Jobs, its Tasks and Runs will be PERMANENTLY DELETED.`;
720      const result = await confirmDelete("Delete and Purge Jobs?", msg);
721      if (result) {
722        return this.processForm(async () => {
723          const resp = await deleteAndPurgeJobs({ ids: jsUtilsExports.mapToIds(sels) });
724          notifySuccess(resp.message || "Jobs have been purged");
725          await this.getJobs(true);
726        });
727      }
728    },
729    sortJobs() {
730      if (this.filterReq.folder === Folder_Recent) {
731        const recentIdsSet = new Set(this.recentJobIds);
732        this.filteredJobs = [
733          ...this.filteredJobs.sort((a, b) => {
734            const aInRecent = recentIdsSet.has(a.id);
735            const bInRecent = recentIdsSet.has(b.id);
736            if (aInRecent && !bInRecent) return -1;
737            if (!aInRecent && bInRecent) return 1;
738            if (aInRecent && bInRecent) {
739              return this.recentJobIds.indexOf(a.id) - this.recentJobIds.indexOf(b.id);
740            }
741            return sortIc(a.name, b.name);
742          })
743        ];
744      }
745    }
746  }
747};
748function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {

749  const _component_GridSelect = resolveComponent("GridSelect");
750  const _component_MenuItem = resolveComponent("MenuItem");
751  const _component_Separator = resolveComponent("Separator");
752  const _component_IconMenu = resolveComponent("IconMenu");
753  const _component_Icon = resolveComponent("Icon");
754  const _component_EnvRef = resolveComponent("EnvRef");
755  const _component_Table = resolveComponent("Table");
756  const _component_JobDialog = resolveComponent("JobDialog");
757  const _component_ChangeOwnerDialog = resolveComponent("ChangeOwnerDialog");
758  const _component_JobsFilterDialog = resolveComponent("JobsFilterDialog");
759  const _component_TextViewerDialog = resolveComponent("TextViewerDialog");
760  const _component_BackupsDialog = resolveComponent("BackupsDialog");
761  const _component_DeletedJobsBackupsDialog = resolveComponent("DeletedJobsBackupsDialog");
762  const _component_InputJsonDialog = resolveComponent("InputJsonDialog");
763  const _component_Page = resolveComponent("Page");
764  return openBlock(), createBlock(_component_Page, {
765    title: "Jobs",
766    initing: _ctx.initing,
767    initingSuccess: $data.initingSuccess,
768    processing: _ctx.processing,
769    message: _ctx.message,
770    messageType: _ctx.messageType
771  }, {
772    breadcrumbs: withCtx(() => [
773      createVNode(QBreadcrumbsEl, {
774        label: "Home",
775        to: "/realtask/home"
776      })
777    ]),
778    default: withCtx(() => [
779      createVNode(_component_Table, {
780        ref: "grid",
781        recordType: "Job",
782        recordTypePlural: "Jobs",
783        nameLinkPrefix: "/realtask/jobs",
784        onAdd: $options.handleAdd,
785        onEdit: $options.handleEdit,
786        onDelete: $options.handleDelete,
787        clone: "",
788        onCloneClick: $options.handleClone,
789        audit: "",
790        owner: "",
791        sharing: "",
792        status: $data.status,
793        refreshable: false,
794        columns: $data.columns,
795        records: $data.records,
796        customRefresh: "",
797        onCustomRefresh: _cache[5] || (_cache[5] = ($event) => $options.getJobs(true)),
798        customLoading: $data.loading
799      }, {
800        "toolbar-actions": withCtx(() => [
801          createVNode(_component_GridSelect, {
802            modelValue: $data.filterReq.envId,
803            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => $data.filterReq.envId = $event),
804            options: $data.envs,
805            showDefault: "",
806            defaultLabel: "-Env-",
807            defaultValue: ""
808          }, null, 8, ["modelValue", "options"]),
809          createVNode(_component_GridSelect, {
810            modelValue: $data.filterReq.folder,
811            "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => $data.filterReq.folder = $event),
812            options: $data.folders,
813            showDefault: "",
814            defaultLabel: "-Folder-",
815            defaultValue: ""
816          }, null, 8, ["modelValue", "options"]),
817          createVNode(_component_GridSelect, {
818            modelValue: $data.filterReq.status,
819            "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => $data.filterReq.status = $event),
820            options: $data.filterStatuses,
821            showDefault: "",
822            defaultLabel: "-Status-",
823            defaultValue: ""
824          }, null, 8, ["modelValue", "options"]),
825          createVNode(_component_GridSelect, {
826            modelValue: $data.filterReq.frequency,
827            "onUpdate:modelValue": _cache[3] || (_cache[3] = ($event) => $data.filterReq.frequency = $event),
828            options: $data.filterFrequencyOptions,
829            showDefault: "",
830            defaultLabel: "-Frequency-",
831            defaultValue: ""
832          }, null, 8, ["modelValue", "options"]),
833          createVNode(_component_GridSelect, {
834            modelValue: $data.filterReq.owner,
835            "onUpdate:modelValue": _cache[4] || (_cache[4] = ($event) => $data.filterReq.owner = $event),
836            options: $data.filterOwnerOptions,
837            showDefault: "",
838            defaultLabel: "-Owner-",
839            defaultValue: ""
840          }, null, 8, ["modelValue", "options"]),
841          createVNode(_component_IconMenu, null, {
842            default: withCtx(() => [
843              createVNode(_component_MenuItem, { onClick: $options.handleActivate }, {
844                default: withCtx(() => [..._cache[16] || (_cache[16] = [
845                  createTextVNode("Activate", -1)
846                ])]),
847                _: 1
848              }, 8, ["onClick"]),
849              createVNode(_component_MenuItem, { onClick: $options.handleInactivate }, {
850                default: withCtx(() => [..._cache[17] || (_cache[17] = [
851                  createTextVNode("Inactivate", -1)
852                ])]),
853                _: 1
854              }, 8, ["onClick"]),
855              createVNode(_component_MenuItem, { onClick: $options.handleChangeFolder }, {
856                default: withCtx(() => [..._cache[18] || (_cache[18] = [
857                  createTextVNode("Change Folder", -1)
858                ])]),
859                _: 1
860              }, 8, ["onClick"]),
861              createVNode(_component_MenuItem, { onClick: $options.handleChangeOwner }, {
862                default: withCtx(() => [..._cache[19] || (_cache[19] = [
863                  createTextVNode("Change Owner", -1)
864                ])]),
865                _: 1
866              }, 8, ["onClick"]),
867              createVNode(_component_Separator),
868              createVNode(_component_MenuItem, { onClick: $options.handleLockJobs }, {
869                default: withCtx(() => [..._cache[20] || (_cache[20] = [
870                  createTextVNode("Lock", -1)
871                ])]),
872                _: 1
873              }, 8, ["onClick"]),
874              createVNode(_component_MenuItem, { onClick: $options.handleUnlockJobs }, {
875                default: withCtx(() => [..._cache[21] || (_cache[21] = [
876                  createTextVNode("Unlock", -1)
877                ])]),
878                _: 1
879              }, 8, ["onClick"]),
880              createVNode(_component_Separator),
881              createVNode(_component_MenuItem, { onClick: $options.handlePurgeJobs }, {
882                default: withCtx(() => [..._cache[22] || (_cache[22] = [
883                  createTextVNode("Purge", -1)
884                ])]),
885                _: 1
886              }, 8, ["onClick"]),
887              createVNode(_component_MenuItem, { onClick: $options.handleDeletePurgeJobs }, {
888                default: withCtx(() => [..._cache[23] || (_cache[23] = [
889                  createTextVNode("Delete and Purge", -1)
890                ])]),
891                _: 1
892              }, 8, ["onClick"]),
893              createVNode(_component_Separator),
894              createVNode(_component_MenuItem, { onClick: $options.createBackup }, {
895                default: withCtx(() => [..._cache[24] || (_cache[24] = [
896                  createTextVNode("Create Backup", -1)
897                ])]),
898                _: 1
899              }, 8, ["onClick"]),
900              createVNode(_component_MenuItem, { onClick: $options.viewBackups }, {
901                default: withCtx(() => [..._cache[25] || (_cache[25] = [
902                  createTextVNode("View Backups", -1)
903                ])]),
904                _: 1
905              }, 8, ["onClick"]),
906              createVNode(_component_Separator),
907              createVNode(_component_MenuItem, { onClick: $options.exportAllJobs }, {
908                default: withCtx(() => [..._cache[26] || (_cache[26] = [
909                  createTextVNode("Export Jobs (Zip file)", -1)
910                ])]),
911                _: 1
912              }, 8, ["onClick"]),
913              createVNode(_component_MenuItem, { onClick: $options.viewSummaryJson }, {
914                default: withCtx(() => [..._cache[27] || (_cache[27] = [
915                  createTextVNode("Export Job (Json)", -1)
916                ])]),
917                _: 1
918              }, 8, ["onClick"]),
919              createVNode(_component_MenuItem, { onClick: $options.handleImportJob }, {

920                default: withCtx(() => [..._cache[28] || (_cache[28] = [
921                  createTextVNode("Import Job (Json)", -1)
922                ])]),
923                _: 1
924              }, 8, ["onClick"]),
925              createVNode(_component_Separator),
926              createVNode(_component_MenuItem, { onClick: $options.handleRunJobs }, {
927                default: withCtx(() => [..._cache[29] || (_cache[29] = [
928                  createTextVNode("Run Jobs", -1)
929                ])]),
930                _: 1
931              }, 8, ["onClick"])
932            ]),
933            _: 1
934          })
935        ]),
936        "additional-actions": withCtx((row) => [
937          row.options.multiRuns && row.options.multiRuns.location ? (openBlock(), createBlock(_component_Icon, {
938            key: 0,
939            name: "mediation",
940            size: "xs",
941            tooltip: "Multi Runs enabled with " + (row.options.multiRuns.instances || "unknown") + " instances"
942          }, null, 8, ["tooltip"])) : createCommentVNode("", true),
943          row.options.runLooping && row.options.runLooping.location ? (openBlock(), createBlock(_component_Icon, {
944            key: 1,
945            name: "repeat_one",
946            size: "xs",
947            tooltip: "Run Looping enabled"
948          })) : createCommentVNode("", true)
949        ]),
950        envField: withCtx((row) => [
951          createVNode(_component_EnvRef, {
952            model: row,
953            field: "envId"
954          }, null, 8, ["model"])
955        ]),
956        _: 1
957      }, 8, ["onAdd", "onEdit", "onDelete", "onCloneClick", "status", "columns", "records", "customLoading"]),
958      createVNode(_component_JobDialog, {
959        modelValue: $data.dialogOpen,
960        "onUpdate:modelValue": _cache[6] || (_cache[6] = ($event) => $data.dialogOpen = $event),
961        jobId: $data.dialogJobId,
962        mode: $data.dialogMode,
963        folder: this.dialogFolder,
964        data: $data.dialogData,
965        onCancel: _cache[7] || (_cache[7] = ($event) => $data.dialogOpen = false),
966        onOk: $options.handleSave
967      }, null, 8, ["modelValue", "jobId", "mode", "folder", "data", "onOk"]),
968      createVNode(_component_ChangeOwnerDialog, {
969        modelValue: $data.changeOwnerDialogOpen,
970        "onUpdate:modelValue": _cache[8] || (_cache[8] = ($event) => $data.changeOwnerDialogOpen = $event),
971        resources: $data.changeOwnerDialogData,
972        onCancel: _cache[9] || (_cache[9] = ($event) => $data.changeOwnerDialogOpen = false),
973        onOk: $options.handleSave,
974        type: "rtjob"
975      }, null, 8, ["modelValue", "resources", "onOk"]),
976      createVNode(_component_JobsFilterDialog, {
977        modelValue: $data.jobsFilterDialogOpen,
978        "onUpdate:modelValue": _cache[10] || (_cache[10] = ($event) => $data.jobsFilterDialogOpen = $event),
979        model: $data.filterReq,
980        onCancel: _cache[11] || (_cache[11] = ($event) => $data.jobsFilterDialogOpen = false),
981        onOk: $options.handleJobFilter,
982        envs: $data.envs
983      }, null, 8, ["modelValue", "model", "onOk", "envs"]),
984      createVNode(_component_TextViewerDialog, {
985        modelValue: $data.textViewerOpen,
986        "onUpdate:modelValue": _cache[12] || (_cache[12] = ($event) => $data.textViewerOpen = $event),
987        content: $data.textViewerContent,
988        title: $data.textViewerTitle,
989        code: ""
990      }, null, 8, ["modelValue", "content", "title"]),
991      createVNode(_component_BackupsDialog, {
992        modelValue: $data.backupsDialogOpen,
993        "onUpdate:modelValue": _cache[13] || (_cache[13] = ($event) => $data.backupsDialogOpen = $event),
994        title: $data.backupsDialogTitle,
995        entityId: $data.backupsDialogEntityId
996      }, null, 8, ["modelValue", "title", "entityId"]),
997      createVNode(_component_DeletedJobsBackupsDialog, {
998        modelValue: $data.deletedJobsBackupsDialogOpen,
999        "onUpdate:modelValue": _cache[14] || (_cache[14] = ($event) => $data.deletedJobsBackupsDialogOpen = $event)
1000      }, null, 8, ["modelValue"]),
1001      createVNode(_component_InputJsonDialog, {
1002        title: "Enter Job Json to import",
1003        modelValue: $data.importJobsDialogOpen,
1004        "onUpdate:modelValue": _cache[15] || (_cache[15] = ($event) => $data.importJobsDialogOpen = $event),
1005        json: $data.importJobsDialogContent,
1006        error: $data.importJobsDialogError,
1007        onOk: $options.handleImportJobOk
1008      }, null, 8, ["modelValue", "json", "error", "onOk"])
1009    ]),
1010    _: 1
1011  }, 8, ["initing", "initingSuccess", "processing", "message", "messageType"]);
1012}
1013const Jobs = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "Jobs.vue"]]);
1014export {
1015  Jobs as default
1016};
1017//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSm9icy1DZ2lrUHZ2YS5qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3Byb2R1Y3RzL3JlYWx0YXNrL3BhZ2VzL2pvYnMvSm9ic0ZpbHRlckRpYWxvZy52dWUiLCIuLi8uLi8uLi9zcmMvcHJvZHVjdHMvcmVhbHRhc2svcGFnZXMvam9icy9EZWxldGVkSm9ic0JhY2t1cHNEaWFsb2cudnVlIiwiLi4vLi4vLi4vc3JjL3Byb2R1Y3RzL3JlYWx0YXNrL3BhZ2VzL2pvYnMvSm9icy52dWUiXSwic291cmNlc0NvbnRlbnQiOlsiPHRlbXBsYXRlPlxuICA8Q29udGVudERpYWxvZ1xuICAgIHRpdGxlPVwiSm9icyBGaWx0ZXJcIlxuICAgIDptb2RlbFZhbHVlPVwibW9kZWxWYWx1ZVwiXG4gICAgQHVwZGF0ZTptb2RlbFZhbHVlPVwiJGVtaXQoJ3VwZGF0ZTptb2RlbFZhbHVlJylcIlxuICAgIDptZXNzYWdlPVwibWVzc2FnZVwiXG4gICAgOm1lc3NhZ2VUeXBlPVwibWVzc2FnZVR5cGVcIlxuICAgIDppbml0aW5nPVwiaW5

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

1017HRoaXMuc2V0RmlsdGVyZWRKb2JzKGpvYnMpO1xuICAgICAgfSBlbHNlIHtcbiAgICAgICAgbGV0IGpvYnMgPSBbLi4udGhpcy5qb2JzXTtcblxuICAgICAgICBpZiAodGhpcy5maWx0ZXJSZXEuZm9sZGVyKSB7XG4gICAgICAgICAgaWYgKHRoaXMuZmlsdGVyUmVxLmZvbGRlciA9PT0gRm9sZGVyX1JlY2VudCkge1xuICAgICAgICAgICAgam9icyA9IGpvYnMuZmlsdGVyKChqb2IpID0+IHRoaXMucmVjZW50Sm9iSWRzLmluY2x1ZGVzKGpvYi5pZCkpO1xuICAgICAgICAgIH0gZWxzZSBpZiAodGhpcy5maWx0ZXJSZXEuZm9sZGVyID09PSBGb2xkZXJfQmxhbmspIHtcbiAgICAgICAgICAgIGpvYnMgPSBqb2JzLmZpbHRlcigoam9iKSA9PiAham9iLmZvbGRlciB8fCBlcXVhbHNJYyhqb2IuZm9sZGVyLCBGb2xkZXJfQmxhbmspKTtcbiAgICAgICAgICB9IGVsc2Uge1xuICAgICAgICAgICAgam9icyA9IGpvYnMuZmlsdGVyKChqb2IpID0+IGVxdWFsc0ljKGpvYi5mb2xkZXIsIHRoaXMuZmlsdGVyUmVxLmZvbGRlcikpO1xuICAgICAgICAgIH1cbiAgICAgICAgfVxuXG4gICAgICAgIGlmICh0aGlzLmZpbHRlclJlcS5lbnZJZCkge1xuICAgICAgICAgIGpvYnMgPSBqb2JzLmZpbHRlcigoam9iKSA9PiBqb2IuZW52SWQgPT09IHRoaXMuZmlsdGVyUmVxLmVudklkKTtcbiAgICAgICAgfVxuXG4gICAgICAgIGlmICh0aGlzLmZpbHRlclJlcS5zdGF0dXMpIHtcbiAgICAgICAgICBqb2JzID0gam9icy5maWx0ZXIoKGpvYikgPT4gaXNGaWx0ZXJTdGF0dXNNYXRjaChqb2Iuc3RhdHVzLCBqb2IucnVuU3Rh

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

1017QUM1QixZQUFNLE9BQU8sS0FBSyxhQUFZO0FBQzlCLFVBQUksQ0FBQyxRQUFRLEtBQUssV0FBVyxHQUFHO0FBQzlCO0FBQUEsTUFDRjtBQUVBLFlBQU0sTUFDSixrRUFDUSw0QkFBNEIsSUFBSSxDQUFDO0FBQzNDLFlBQU0sU0FBUyxNQUFNRixjQUFvQiwwQkFBMEIsR0FBRztBQUN0RSxVQUFJLFFBQVE7QUFDVixlQUFPLEtBQUssWUFBWSxZQUFZO0FBQ2xDLGdCQUFNLE9BQU8sTUFBTW9CLG1CQUF1QixFQUFDLEtBQUtkLGVBQUFBLFNBQVMsSUFBSSxFQUFDLENBQUM7QUFDL0Qsd0JBQWMsS0FBSyxXQUFXLHVCQUF1QjtBQUNyRCxnQkFBTSxLQUFLLFFBQVEsSUFBSTtBQUFBLFFBQ3pCLENBQUM7QUFBQSxNQUNIO0FBQUEsSUFDRjtBQUFBLElBRUEsV0FBVztBQUNULFVBQUksS0FBSyxVQUFVLFdBQVcsZUFBZTtBQUMzQyxjQUFNLGVBQWUsSUFBSSxJQUFJLEtBQUssWUFBWTtBQUM5QyxhQUFLLGVBQWU7QUFBQSxVQUNsQixHQUFHLEtBQUssYUFBYSxLQUFLLENBQUMsR0FBRyxNQUFNO0FBQ2xDLGtCQUFNLFlBQVksYUFBYSxJQUFJLEVBQUUsRUFBRTtBQUN2QyxrQkFBTSxZQUFZLGFBQWEsSUFBSSxFQUFFLEVBQUU7QUFDdkMsZ0JBQUksYUFBYSxDQUFDLFVBQVcsUUFBTztBQUNwQyxnQkFBSSxDQUFDLGFBQWEsVUFBVyxRQUFPO0FBQ3BDLGdCQUFJLGFBQWEsV0FBVztBQUMxQixxQkFBTyxLQUFLLGFBQWEsUUFBUSxFQUFFLEVBQUUsSUFBSSxLQUFLLGFBQWEsUUFBUSxFQUFFLEVBQUU7QUFBQSxZQUN6RTtBQUNBLG1CQUFPLE9BQU8sRUFBRSxNQUFNLEVBQUUsSUFBSTtBQUFBLFVBQzlCLENBQUM7QUFBQTtNQUVMO0FBQUEsSUFDRjtBQUFBO0FBRUo7Ozs7Ozs7Ozs7Ozs7Ozs7O3NCQTFxQkVsQixZQStGTyxpQkFBQTtBQUFBLElBL0ZELE9BQU07QUFBQSxJQUFRLFNBQVMsS0FBQTtBQUFBLElBQVUsZ0JBQWdCLE1BQUE7QUFBQSxJQUFpQixZQUFZLEtBQUE7QUFBQSxJQUFhLFNBQVMsS0FBQTtBQUFBLElBQVUsYUFBYSxLQUFBO0FBQUE7SUFDOUcscUJBQ2YsTUFBcUQ7QUFBQSxNQUFyREMsWUFBcUQsZ0JBQUE7QUFBQSxRQUFuQyxPQUFNO0FBQUEsUUFBTyxJQUFHO0FBQUE7O3FCQUdwQyxNQThEUTtBQUFBLE1BOURSQSxZQThEUSxrQkFBQTtBQUFBLFFBN0ROLEtBQUk7QUFBQSxRQUNKLFlBQVc7QUFBQSxRQUNYLGtCQUFpQjtBQUFBLFFBQ2pCLGdCQUFlO0FBQUEsUUFDZCxPQUFLLFNBQUE7QUFBQSxRQUNMLFFBQU0sU0FBQTtBQUFBLFFBQ04sVUFBUSxTQUFBO0FBQUEsUUFDVCxPQUFBO0FBQUEsUUFDQyxjQUFZLFNBQUE7QUFBQSxRQUNiLE9BQUE7QUFBQSxRQUNBLE9BQUE7QUFBQSxRQUNBLFNBQUE7QUFBQSxRQUNDLFFBQVEsTUFBQTtBQUFBLFFBQ1IsYUFBYTtBQUFBLFFBQ2IsU0FBUyxNQUFBO0FBQUEsUUFDVCxTQUFTLE1BQUE7QUFBQSxRQUNWLGVBQUE7QUFBQSxRQUNDLHVEQUFlLFNBQUEsUUFBTyxJQUFBO0FBQUEsUUFDdEIsZUFBZSxNQUFBO0FBQUE7UUFFQywyQkFDZixNQUF5RztBQUFBLFVBQXpHQSxZQUF5Ryx1QkFBQTtBQUFBLFlBQXBGLFlBQUEsTUFBQSxVQUFVO0FBQUEsWUFBVix1QkFBQSxPQUFBLENBQUEsTUFBQSxPQUFBLENBQUEsSUFBQSxZQUFBLE1BQUEsVUFBVSxRQUFLO0FBQUEsWUFBRyxTQUFTLE1BQUE7QUFBQSxZQUFNLGFBQUE7QUFBQSxZQUFZLGNBQWE7QUFBQSxZQUFRLGNBQWE7QUFBQTtVQUNwR0EsWUFBZ0gsdUJBQUE7QUFBQSxZQUEzRixZQUFBLE1BQUEsVUFBVTtBQUFBLFlBQVYsdUJBQUEsT0FBQSxDQUFBLE1BQUEsT0FBQSxDQUFBLElBQUEsWUFBQSxNQUFBLFVBQVUsU0FBTTtBQUFBLFlBQUcsU0FBUyxNQUFBO0FBQUEsWUFBUyxhQUFBO0FBQUEsWUFBWSxjQUFhO0FBQUEsWUFBVyxjQUFhO0FBQUE7VUFDM0dBLFlBQXVILHVCQUFBO0FBQUEsWUFBbEcsWUFBQSxNQUFBLFVBQVU7QUFBQSxZQUFWLHVCQUFBLE9BQUEsQ0FBQSxNQUFBLE9BQUEsQ0FBQSxJQUFBLFlBQUEsTUFBQSxVQUFVLFNBQU07QUFBQSxZQUFHLFNBQVMsTUFBQTtBQUFBLFlBQWdCLGFBQUE7QUFBQSxZQUFZLGNBQWE7QUFBQSxZQUFXLGNBQWE7QUFBQTtVQUNsSEEsWUFBcUksdUJBQUE7QUFBQSxZQUFoSCxZQUFBLE1BQUEsVUFBVTtBQUFBLFlBQVYsdUJBQUEsT0FBQSxDQUFBLE1BQUEsT0FBQSxDQUFBLElBQUEsWUFBQSxNQUFBLFVBQVUsWUFBUztBQUFBLFlBQUcsU0FBUyxNQUFBO0FBQUEsWUFBd0IsYUFBQTtBQUFBLFlBQVksY0FBYTtBQUFBLFlBQWMsY0FBYTtBQUFBO1VBQ2hJQSxZQUF5SCx1QkFBQTtBQUFBLFlBQXBHLFlBQUEsTUFBQSxVQUFVO0FBQUEsWUFBVix1QkFBQSxPQUFBLENBQUEsTUFBQSxPQUFBLENBQUEsSUFBQSxZQUFBLE1BQUEsVUFBVSxRQUFLO0FBQUEsWUFBRyxTQUFTLE1BQUE7QUFBQSxZQUFvQixhQUFBO0FBQUEsWUFBWSxjQUFhO0FBQUEsWUFBVSxjQUFhO0FBQUE7VUFDcEhBLFlBb0JXLHFCQUFBLE1BQUE7QUFBQSw2QkFuQlQsTUFBcUQ7QUFBQSxjQUFyREEsWUFBcUQscUJBQUEsRUFBMUMsU0FBTyxTQUFBLGVBQWMsR0FBQTtBQUFBLGlDQUFFLE1BQVEsQ0FBQSxHQUFBLE9BQUEsRUFBQSxNQUFBLE9BQUEsRUFBQSxJQUFBO0FBQUEsa0NBQVIsWUFBUSxFQUFBO0FBQUE7OztjQUMxQ0EsWUFBeUQscUJBQUEsRUFBOUMsU0FBTyxTQUFBLGlCQUFnQixHQUFBO0FBQUEsaUNBQUUsTUFBVSxDQUFBLEdBQUEsT0FBQSxFQUFBLE1BQUEsT0FBQSxFQUFBLElBQUE7QUFBQSxrQ0FBVixjQUFVLEVBQUE7QUFBQTs7O2NBQzlDQSxZQUE4RCxxQkFBQSxFQUFuRCxTQUFPLFNBQUEsbUJBQWtCLEdBQUE7QUFBQSxpQ0FBRSxNQUFhLENBQUEsR0FBQSxPQUFBLEVBQUEsTUFBQSxPQUFBLEVBQUEsSUFBQTtBQUFBLGtDQUFiLGlCQUFhLEVBQUE7QUFBQTs7O2NBQ25EQSxZQUE0RCxxQkFBQSxFQUFqRCxTQUFPLFNBQUEsa0JBQWlCLEdBQUE7QUFBQSxpQ0FBRSxNQUFZLENBQUEsR0FBQSxPQUFBLEVBQUEsTUFBQSxPQUFBLEVBQUEsSUFBQTtBQUFBLGtDQUFaLGdCQUFZLEVBQUE7QUFBQTs7O2NBQ2pEQSxZQUFhLG9CQUFBO0FBQUEsY0FDYkEsWUFBaUQscUJBQUEsRUFBdEMsU0FBTyxTQUFBLGVBQWMsR0FBQTtBQUFBLGlDQUFFLE1BQUksQ0FBQSxHQUFBLE9BQUEsRUFBQSxNQUFBLE9BQUEsRUFBQSxJQUFBO0FBQUEsa0NBQUosUUFBSSxFQUFBO0FBQUE7OztjQUN0Q0EsWUFBcUQscUJBQUEsRUFBMUMsU0FBTyxTQUFBLGlCQUFnQixHQUFBO0FBQUEsaUNBQUUsTUFBTSxDQUFBLEdBQUEsT0FBQSxFQUFBLE1BQUEsT0FBQSxFQUFBLElBQUE7QUFBQSxrQ0FBTixVQUFNLEVBQUE7QUFBQTs7O2NBQzFDQSxZQUFhLG9CQUFBO0FBQUEsY0FDYkEsWUFBbUQscUJBQUEsRUFBeEMsU0FBT

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

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.