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

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 {object} templateData the template data
  * @return {LogTemplate|null} the new log template
  */
-const logTemplatesFactory = (key) => {
+const logTemplatesFactory = (key, templateData) => {
     const templateClass = {
         ['on-call']: OnCallLogTemplate,
         ['rc-daily-meeting']: RcDailyMeetingTemplate,
     }[key] ?? null;
     if (templateClass) {
-        return new templateClass();
+        return new templateClass(templateData);
     }
     return null;
 };
@@ -49,8 +50,10 @@
      *
      * @param {function} [onCreation] function called when log is created, with the id of the created log
      * @param {LogCreationRelations} relations the relations of the log
+     * @param {logTemplateKey|null} templateKey the key of the template to use
+     * @param {object} templateData the template data of the log
      */
-    constructor(onCreation, relations) {
+    constructor(onCreation, relations, templateKey, templateData) {
         super(onCreation, relations);
 
         /**
@@ -59,21 +62,20 @@
          */
         this._templateKey = null;
 
-        /**
-         * @type {LogTemplate|null}
-         * @private
-         */
-        this._templateModel = null;
+        if (templateKey) {
+            this.useTemplate(templateKey, templateData);
+        }
     }
 
     /**
      * Defines the template to use, defined by its key
      *
      * @param {logTemplateKey|null} key the key of the template to use (there may be no model for the given key)
+     * @param {object} [templateData={}] the optional template data
      * @return {void}
      */
-    useTemplate(key) {
-        const templateModel = logTemplatesFactory(key);
+    useTemplate(key, templateData = {}) {
+        const templateModel = logTemplatesFactory(key, templateData);
         if (templateModel) {
             templateModel.bubbleTo(this);
         }

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

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

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

@@ -55,7 +55,7 @@ export const onCallLogCreationConfiguration = (creationModel, template) => {
                                     h('option', { disabled: null, selected: true }, '- None -'),
                                     ...systems.map((detectorOrSubsystem) => h(
                                         'option',
-                                        { value: detectorOrSubsystem },
+                                        { value: detectorOrSubsystem, selected: template.formData.detectorOrSubsystem === detectorOrSubsystem },
                                         detectorOrSubsystem,
                                     )),
                                 ],

lib/public/views/Logs/LogsModel.js

@@ -111,10 +111,14 @@
      * @param {string} [queryParams.runNumbers] the run numbers to link to the log being created
      * @param {string} [queryParams.lhcFillNumbers] the lhc fill numbers to link to the log being created
      * @param {string} [queryParams.environmentIds] the environment ids to link to the log being created
+     * @param {string} [queryParams.templateKey] the key of the template to use
+     * @param {string} [queryParams.issueDescription] the description of the issue
+     * @param {string} [queryParams.detectorOrSubsystem] the detector or subsystem to link to the log being created
      * @return {void}
      */
-    loadCreation({ runNumbers, lhcFillNumbers, environmentIds }) {
+    loadCreation({ runNumbers, lhcFillNumbers, environmentIds, templateKey, issueDescription, detectorOrSubsystem }) {
         const relations = {};
+        const templateData = {};
 
         if (runNumbers) {
             relations.runNumbers = this._parseCommaSeparatedNumbers(runNumbers);
@@ -125,8 +129,14 @@
         if (environmentIds) {
             relations.environmentIds = environmentIds.split(',').map((environmentId) => environmentId.trim());
         }
+        if (issueDescription) {
+            templateData.issueDescription = issueDescription;
+        }
+        if (detectorOrSubsystem) {
+            templateData.detectorOrSubsystem = detectorOrSubsystem;
+        }
 
-        this._creationModel = new TemplatedLogCreationModel(this.handleLogCreation.bind(this), relations);
+        this._creationModel = new TemplatedLogCreationModel(this.handleLogCreation.bind(this), relations, templateKey, templateData);
         this._creationModel.bubbleTo(this);
     }
 

test/public/logs/create.test.js

@@ -184,6 +184,46 @@ module.exports = () => {
         await expectInputValue(page, 'input#lhc-fills', '1,2,3');
     });
 
+    it('Should set the correct template when templateKey is specified.', 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');
+    });
+
+    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'));