[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/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 {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;
+        }
     }
 
     /**
@@ -119,6 +128,7 @@
      * @return {boolean} true if the form is valid
      */
     get isValid() {
+        console.log(this.formData)
         return Boolean(this.formData.shortDescription.length >= 4 && this.formData.shortDescription.length <= 100
             && this.formData.detectorOrSubsystem
             && this.formData.severity

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,17 @@
         if (environmentIds) {
             relations.environmentIds = environmentIds.split(',').map((environmentId) => environmentId.trim());
         }
+        if (templateKey) {
+            templateData.templateKey = templateKey;
+        }
+        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);
     }
 

lib/server/services/log/LogService.js

@@ -201,14 +201,16 @@
      * @param {Attachment[]} attachments the list of attachments to link to 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 = []
+    ) {
         const logId = await createLog(
             logAdapter.toDatabase(newLog),
             runNumbers,
             tagsTexts,
             environments,
             lhcFills,
             attachments.map((attachment) => attachmentAdapter.toDatabase(attachment)),
         );
         // No transaction, log is ready here and can not be null
         return this.get(logId);

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'));