[O2B-1405] Additional query parameters for creating a log

lib/public/views/Logs/Create/LogCreationModel.js

@@ -44,10 +44,14 @@
         this._creationTagsPickerModel.bubbleTo(this);
         this._creationTagsPickerModel.visualChange$.bubbleTo(this);
 
-        const { runNumbers = [], environmentIds = [], lhcFillNumbers = [] } = relations;
+        const { runNumbers = [], environmentIds = [], lhcFillNumbers = [],
+            templateKey = '', issueDescription = '', detectorOrSubsystem = '' } = relations;
         this._runNumbers = runNumbers.join(DATA_DISPLAY_DELIMITER);
         this._lhcFills = lhcFillNumbers.join(DATA_DISPLAY_DELIMITER);
         this._environments = environmentIds.join(DATA_DISPLAY_DELIMITER);
+        this._issueDescription = issueDescription;
+        this._detectorOrSubsystem = detectorOrSubsystem;
+        this._templateKey = templateKey;
         this._isRunNumbersReadonly = Boolean(this._runNumbers);
 
         this._parentLogId = null;
@@ -93,7 +97,8 @@
         this._createdLog = RemoteData.loading();
         this.notify();
 
-        const { title, text, parentLogId, runNumbers, environments, lhcFills, attachments } = this;
+        const { title, text, parentLogId, runNumbers, environments, lhcFills,
+            attachments, templateKey, issueDescription, detectorOrSubsystem } = this;
         const tagsTexts = this._creationTagsPickerModel.selected;
         const environmentsIds = environments ? environments.split(',').map((environment) => environment.trim()) : [];
         const lhcFillNumbers = lhcFills ? lhcFills.split(',').map((lhcFillNumber) => lhcFillNumber.trim()) : [];
@@ -125,6 +130,16 @@
             options.headers['Content-Type'] = 'application/json';
         }
 
+        // The field detectorOrSubsystem and issueDescription should be allowed only if the log templateKey is On-call
+        if (templateKey) {
+            options.body.templateKey = templateKey;
+
+            if (templateKey === 'on-call') {
+                options.body.issueDescription = issueDescription;
+                options.body.detectorOrSubsystem = detectorOrSubsystem;
+            }
+        }
+
         try {
             const { data: createdLog } = await jsonFetch('/api/logs', options);
             this._createdLog = RemoteData.success(createdLog);
@@ -249,6 +264,57 @@
         this.notify();
     }
 
+    /**
+     * Returns the system of the log
+     * @return {string} the system
+     */
+    get detectorOrSubsystem() {
+        return this._detectorOrSubsystem;
+    }
+
+    /**
+     * Set the detectorOrSubsystem of the log
+     * @param {string} value the detectorOrSubsystem
+     */
+    set detectorOrSubsystem(value) {
+        this._detectorOrSubsystem = value;
+        this.notify();
+    }
+
+    /**
+     * Returns the templateKey of the log
+     * @return {string} the templateKey
+     */
+    get templateKey() {
+        return this._templateKey;
+    }
+
+    /**
+     * Set the template of the log
+     * @param {string} value the templateKey
+     */
+    set templateKey(value) {
+        this._templateKey = value;
+        this.notify();
+    }
+
+    /**
+     * Returns the issueDescription of the log
+     * @return {string} the issueDescription
+     */
+    get issueDescription() {
+        return this._issueDescription;
+    }
+
+    /**
+     * Set the issueDescription of the log
+     * @param {string} value the issueDescription
+     */
+    set issueDescription(value) {
+        this._issueDescription = value;
+        this.notify();
+    }
+
     /**
      * Returns the id of the parent log if it exists
      *

lib/public/views/Logs/Create/TemplatedLogCreationModel.js

@@ -27,15 +27,16 @@
  * Return a new instance of log template for the given key
  *
  * @param {logTemplateKey} key the template key
+ * @param {LogCreationRelations} relations the relations of the log
  * @return {LogTemplate|null} the new log template
  */
-const logTemplatesFactory = (key) => {
+const logTemplatesFactory = (key, relations) => {
     const templateClass = {
         ['on-call']: OnCallLogTemplate,
         ['rc-daily-meeting']: RcDailyMeetingTemplate,
     }[key] ?? null;
     if (templateClass) {
-        return new templateClass();
+        return new templateClass(relations);
     }
     return null;
 };
@@ -53,6 +54,8 @@
     constructor(onCreation, relations) {
         super(onCreation, relations);
 
+        this._relations = relations;
+
         /**
          * @type {logTemplateKey|null}
          * @private
@@ -64,6 +67,10 @@
          * @private
          */
         this._templateModel = null;
+
+        if (relations.templateKey) {
+            this.useTemplate(relations.templateKey);
+        }
     }
 
     /**
@@ -73,7 +80,7 @@
      * @return {void}
      */
     useTemplate(key) {
-        const templateModel = logTemplatesFactory(key);
+        const templateModel = logTemplatesFactory(key, this._relations);
         if (templateModel) {
             templateModel.bubbleTo(this);
         }

lib/public/views/Logs/Create/logCreationComponent.js

@@ -279,7 +279,7 @@ export const logCreationComponent = (creationModel) => {
                     'select.f5.form-control',
                     { onchange: (e) => creationModel.useTemplate(e.target.value) },
                     [
-                        h('option', { value: null, selected: creationModel.templateKey === null }, '- No template -'),
+                        h('option', { value: 'null', selected: creationModel.templateKey === null }, '- No template -'),
                         ...Object.entries(templates)
                             .map(([template, configuration]) => h(
                                 'option',

lib/public/views/Logs/Create/templates/OnCallLogTemplate.js

@@ -49,8 +49,10 @@
 export class OnCallLogTemplate extends Observable {
     /**
      * Constructor
+     *
+     * @param {LogCreationRelations} relations the relations of the log
      */
-    constructor() {
+    constructor(relations) {
         super();
 
         /**
@@ -73,6 +75,13 @@
             reason: '',
             alreadyTakenActions: '',
         };
+
+        if (relations.detectorOrSubsystem) {
+            this.formData.detectorOrSubsystem = relations.detectorOrSubsystem;
+        }
+        if (relations.issueDescription) {
+            this.formData.issueDescription = relations.issueDescription;
+        }
     }
 
     /**

lib/public/views/Logs/Create/templates/onCallLogCreationConfiguration.js

@@ -55,7 +55,7 @@
                                     h('option', { disabled: null, selected: true }, '- None -'),
                                     ...systems.map((detectorOrSubsystem) => h(
                                         'option',
-                                        { value: detectorOrSubsystem },
+                                        { value: detectorOrSubsystem, selected: creationModel._detectorOrSubsystem === detectorOrSubsystem },
                                         detectorOrSubsystem,
                                     )),
                                 ],
@@ -145,7 +145,7 @@
             h(PanelComponent, { class: 'flex-column flex-grow' }, [
                 h(LabelPanelHeaderComponent, { required: true, for: 'issue-description' }, 'Description of the issue'),
                 markdownInput(
-                    template.formData.issueDescription,
+                    template.formData.issueDescription || creationModel._issueDescription,
                     {
                         id: 'issue-description',
                         onchange: (e) => template.patchFormData({ issueDescription: e.target.value }),

lib/public/views/Logs/LogsModel.js

@@ -113,7 +113,7 @@
      * @param {string} [queryParams.environmentIds] the environment ids to link to the log being created
      * @return {void}
      */
-    loadCreation({ runNumbers, lhcFillNumbers, environmentIds }) {
+    loadCreation({ runNumbers, lhcFillNumbers, environmentIds, templateKey, issueDescription, detectorOrSubsystem }) {
         const relations = {};
 
         if (runNumbers) {
@@ -125,6 +125,15 @@
         if (environmentIds) {
             relations.environmentIds = environmentIds.split(',').map((environmentId) => environmentId.trim());
         }
+        if (templateKey) {
+            relations.templateKey = templateKey;
+        }
+        if (issueDescription) {
+            relations.issueDescription = issueDescription;
+        }
+        if (detectorOrSubsystem) {
+            relations.detectorOrSubsystem = detectorOrSubsystem;
+        }
 
         this._creationModel = new TemplatedLogCreationModel(this.handleLogCreation.bind(this), relations);
         this._creationModel.bubbleTo(this);

lib/server/services/log/LogService.js

@@ -199,16 +199,25 @@ class LogService {
      * @param {string[]} environments the environmentIds to attach to log
      * @param {number[]} lhcFills the LHC fill numbers associated with this log
      * @param {Attachment[]} attachments the list of attachments to link to the log
+     * @param {string} templateKey the template key used to create the log
+     * @param {string} issueDescription the description of the log
+     * @param {string} detectorOrSubsystem the system of the log
      * @return {Promise<Log>} resolve with the created log instance
      */
-    async create(newLog, runNumbers = [], tagsTexts = [], environments = [], lhcFills = [], attachments = []) {
+    async create(
+        newLog, runNumbers = [], tagsTexts = [], environments = [], lhcFills = [],
+        attachments = [], templateKey = '', issueDescription = '', detectorOrSubsystem = '',
+    ) {
         const logId = await createLog(
             logAdapter.toDatabase(newLog),
             runNumbers,
             tagsTexts,
             environments,
             lhcFills,
             attachments.map((attachment) => attachmentAdapter.toDatabase(attachment)),
+            templateKey,
+            issueDescription,
+            detectorOrSubsystem,
         );
         // No transaction, log is ready here and can not be null
         return this.get(logId);

test/public/logs/create.test.js

@@ -184,6 +184,52 @@ module.exports = () => {
         await expectInputValue(page, 'input#lhc-fills', '1,2,3');
     });
 
+    it('Should set the correct template when templateKey is specified without setting other values.', async () => {
+        const templateKey = 'on-call';
+        await goToPage(page, `log-create&templateKey=${templateKey}`);
+
+        await page.waitForSelector('select');
+        const selectedOption = await page.evaluate(() => document.querySelector('select').value);
+        expect(selectedOption).to.equal('on-call');
+
+        await expectInputValue(page, 'input#run-numbers', '');
+        await expectInputValue(page, 'input#environments', '');
+        await expectInputValue(page, 'input#lhc-fills', '');
+        expect(await page.evaluate(() => document.querySelector('select#detectorOrSubsystem').value)).to.equal('- None -');
+        await expectInputValue(page, 'textarea#issue-description', '');
+    });
+
+    it('Should autofill detectorOrSubsystem and issueDescription if templateKey is "on-call".', async () => {
+        const templateKey = 'on-call';
+        const detectorOrSubsystem = 'ALL';
+        const issueDescription = 'This is a sample issue description';
+        await goToPage(
+            page,
+            `log-create&templateKey=${templateKey}&detectorOrSubsystem=${detectorOrSubsystem}&` +
+            `issueDescription=${issueDescription}`,
+        );
+
+        await expectInputValue(page, 'input#run-numbers', '');
+        await expectInputValue(page, 'input#environments', '');
+        await expectInputValue(page, 'input#lhc-fills', '');
+        expect(await page.evaluate(() => document.querySelector('select#detectorOrSubsystem').value)).to.equal('ALL');
+        await expectInputValue(page, 'textarea#issue-description', issueDescription);
+    });
+
+    it('Should autofill all inputs with provided full parameters.', async () => {
+        await goToPage(
+            page,
+            'log-create&runNumbers=1,2,3&lhcFillNumbers=1,2,3&environmentIds=1,2,3&templateKey=on-call&detectorOrSubsystem=ALL&' +
+            'issueDescription=This is a sample issue description',
+        );
+
+        await expectInputValue(page, 'input#run-numbers', '1,2,3');
+        await expectInputValue(page, 'input#environments', '1,2,3');
+        await expectInputValue(page, 'input#lhc-fills', '1,2,3');
+        expect(await page.evaluate(() => document.querySelector('select#detectorOrSubsystem').value)).to.equal('ALL');
+        await expectInputValue(page, 'textarea#issue-description', 'This is a sample issue description');
+    });
+
     it('should successfully provide a tag picker with search input', async () => {
         await waitForNavigation(page, () => pressElement(page, '#create-log-button'));