feat: bulk enable/disable audits

docs/openapi/api.yaml

@@ -75,6 +75,8 @@ paths:
     $ref: './site-api.yaml#/site-by-base-url'
   /sites/with-latest-audit/{auditType}:
     $ref: './sites-api.yaml#/sites-with-latest-audit'
+  /sites/bulk-audit-config:
+    $ref: './sites-api.yaml#/bulk-update-sites-audit-config'
   /sites/{siteId}:
     $ref: './site-api.yaml#/site'
   /sites/{siteId}/audits:

docs/openapi/schemas.yaml

@@ -365,6 +365,28 @@ SiteCreate:
     organizationId: 'o1p2q3r4-s5t6-u7v8-w9x0-yz12x34y56z'
     baseURL: 'https://www.newsite.com'
     deliveryType: 'aem_cs'
+BulkUpdateSitesConfigResponse:
+  type: array
+  items:
+    type: object
+    properties:
+      baseURL:
+        type: string
+        description: The base URL of the site
+      response:
+        type: object
+        description: The response for the site update operation
+        properties:
+          status:
+            type: string
+            description: The status of the operation
+          message:
+            type: string
+            description: The message of the operation
+          site:
+            $ref: './schemas.yaml#/SiteDto'
+        required:
+          - status
 SiteUpdate:
   type: object
   properties:

docs/openapi/sites-api.yaml

@@ -125,3 +125,47 @@ sites-for-organization:
         $ref: './responses.yaml#/500'
     security:
       - api_key: [ ]
+bulk-update-sites-audit-config:
+    patch:
+      tags:
+          - site
+      summary: Enable/Disable audits for multiple sites
+      description: |
+        This endpoint is useful for enabling audit types for multiple sites.
+      operationId: bulkUpdateAuditConfigForSites
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                baseURLs:
+                  type: array
+                  items:
+                    $ref: './schemas.yaml#/URL'
+                auditTypes:
+                  type: array
+                  items:
+                      type: string
+                      examples:
+                          - 404
+                          - broken-backlinks
+                          - organic-traffic
+                enableAudits:
+                  type: boolean
+      responses:
+        '207':
+          description: A list of sites
+          content:
+            application/json:
+              schema:
+                $ref: './schemas.yaml#/BulkUpdateSitesConfigResponse'
+        '401':
+          $ref: './responses.yaml#/401'
+        '500':
+          $ref: './responses.yaml#/500'
+      security:
+          - admin_key: [ ]
+
+

package.json

@@ -65,8 +65,8 @@
     "@adobe/spacecat-shared-data-access": "1.23.4",
     "@adobe/spacecat-shared-http-utils": "1.3.0",
     "@adobe/spacecat-shared-ims-client": "1.3.5",
-    "@adobe/spacecat-shared-slack-client": "1.3.5",
     "@adobe/spacecat-shared-rum-api-client": "1.8.2",
+    "@adobe/spacecat-shared-slack-client": "1.3.5",
     "@adobe/spacecat-shared-utils": "1.15.2",
     "@aws-sdk/client-s3": "3.577.0",
     "@aws-sdk/client-sqs": "3.577.0",
@@ -89,7 +89,7 @@
     "chai-as-promised": "7.1.2",
     "dotenv": "16.4.5",
     "eslint": "8.57.0",
-    "esmock": "2.6.5",
+    "esmock": "^2.6.5",
     "husky": "9.0.11",
     "junit-report-builder": "3.2.1",
     "lint-staged": "15.2.2",

src/controllers/sites.js

@@ -104,6 +104,78 @@ function SitesController(dataAccess) {
     return ok(sites);
   };
 
+  /** Bulk update audit configuration for multiple sites.
+   * @param {object} context - Context of the request.
+   * @returns {Promise<Response>}  Array of sites response.
+   */
+  const bulkUpdateSitesConfig = async (context) => {
+    const { baseURLs, enableAudits, auditTypes } = context.data;
+
+    if (!Array.isArray(baseURLs) || baseURLs.length === 0) {
+      return badRequest('Base URLs are required');
+    }
+    if (!Array.isArray(auditTypes) || auditTypes.length === 0) {
+      return badRequest('Audit types are required');
+    }
+    if (!isBoolean(enableAudits)) {
+      return badRequest('enableAudits is required');
+    }
+
+    const organizationsMap = new Map();
+
+    const sites = await Promise.all(baseURLs.map(async (baseURL) => {
+      const site = await dataAccess.getSiteByBaseURL(baseURL);
+      if (!site) {
+        return { baseURL, site: null };
+      }
+      const organizationId = site.getOrganizationId();
+
+      if (organizationId !== 'default' && !organizationsMap.has(organizationId)) {
+        const organization = await dataAccess.getOrganizationByID(organizationId);
+        if (!organization) {
+          return { baseURL, response: { message: `Organization with ID: ${organizationId} not found`, status: 404 } };
+        }
+        organizationsMap.set(organizationId, organization);
+      }
+
+      return { baseURL, site };
+    }));
+
+    const responses = await Promise.all(sites.map(async ({ baseURL, site }) => {
+      if (!site) {
+        return { baseURL, response: { message: `Site with baseURL: ${baseURL} not found`, status: 404 } };
+      }
+      const organizationId = site.getOrganizationId();
+      const organization = organizationsMap.get(organizationId);
+
+      auditTypes.forEach((auditType) => {
+        if (organization) {
+          organization.getAuditConfig().updateAuditTypeConfig(
+            auditType,
+          );
+        }
+        site.getAuditConfig().updateAuditTypeConfig(auditType, { auditsDisabled: !enableAudits });
+      });
+
+      if (organization && enableAudits) {
+        try {
+          await dataAccess.updateOrganization(organization);
+        } catch (error) {
+          return { baseURL: site.getBaseURL(), message: `Error updating organization with id: ${organizationId}`, status: 500 };
+        }
+      }
+      try {
+        await dataAccess.updateSite(site);
+      } catch (error) {
+        return { baseURL: site.getBaseURL(), response: { message: `Error updating site with id: ${site.getId()}`, status: 500 } };
+      }
+
+      return { baseURL: site.getBaseURL(), response: { body: SiteDto.toJSON(site), status: 200 } };
+    }));
+
+    return createResponse(responses, 207);
+  };
+
   /**
    * Gets all sites as an XLS file.
    * @returns {Promise<Response>} XLS file.
@@ -377,6 +449,7 @@ function SitesController(dataAccess) {
     getAuditForSite,
     getByBaseURL,
     getAllByDeliveryType,
+    bulkUpdateSitesConfig,
     getByID,
     removeSite,
     updateSite,

src/routes/index.js

@@ -101,6 +101,7 @@ export default function getRouteHandlers(
     'GET /sites/by-base-url/:baseURL': sitesController.getByBaseURL,
     'GET /sites/by-delivery-type/:deliveryType': sitesController.getAllByDeliveryType,
     'GET /sites/with-latest-audit/:auditType': sitesController.getAllWithLatestAudit,
+    'PATCH /sites/bulk-audit-config': sitesController.bulkUpdateSitesConfig,
     'GET /slack/events': slackController.handleEvent,
     'POST /slack/events': slackController.handleEvent,
     'POST /slack/channels/invite-by-user-id': slackController.inviteUserToChannel,

src/support/slack/commands/bulk-enable-audits.js

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2024 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import BaseCommand from './base.js';
+import bulkUpdateSitesConfig from '../../../controllers/sites.js';
+
+const PHRASES = ['bulk enable audits'];
+
+function BulkEnableAuditsCommand(context) {
+  const baseCommand = BaseCommand({
+    id: 'bulk-enable-audits',
+    name: 'Bulk Enable Audits',
+    description: 'Enables audits for multiple sites.',
+    phrases: PHRASES,
+    usageText: `${PHRASES[0]} {site1,site2,...} {auditType1,auditType2,...}`,
+  });
+
+  const { log } = context;
+
+  const handleExecution = async (args, slackContext) => {
+    const { say } = slackContext;
+
+    try {
+      const [baseURLsInput, auditTypesInput] = args;
+
+      const baseURLs = baseURLsInput.split(',');
+      const auditTypes = auditTypesInput.split(',');
+
+      const enableAudits = true;
+
+      const responses = await bulkUpdateSitesConfig({
+        data: { baseURLs, enableAudits, auditTypes },
+      });
+
+      let message = 'Bulk update completed with the following responses:\n';
+      responses.forEach((response) => {
+        message += `- ${response.baseURL}: ${response.response.status}\n`;
+      });
+
+      await say(message);
+    } catch (error) {
+      log.error(error);
+      await say(`Error during bulk update: ${error.message}`);
+    }
+  };
+
+  baseCommand.init(context);
+
+  return {
+    ...baseCommand,
+    handleExecution,
+  };
+}
+
+export default BulkEnableAuditsCommand;

test/controllers/sites.test.js

@@ -89,6 +89,7 @@ describe('Sites Controller', () => {
     'getAll',
     'getAllByDeliveryType',
     'getAllWithLatestAudit',
+    'bulkUpdateSitesConfig',
     'getAllAsCSV',
     'getAllAsXLS',
     'getAuditForSite',
@@ -639,4 +640,69 @@ describe('Sites Controller', () => {
     expect(result.status).to.equal(404);
     expect(error).to.have.property('message', 'Site not found');
   });
+  describe('bulkUpdateSitesConfig', () => {
+    it('updates multiple sites and returns their responses', async () => {
+      const baseURLs = ['https://site1.com', 'https://site2.com'];
+      const enableAudits = true;
+      const auditTypes = ['type1', 'type2'];
+
+      const site1 = SiteDto.fromJson({ id: 'site1', baseURL: 'https://site1.com', deliveryType: 'aem_edge' });
+      const site2 = SiteDto.fromJson({ id: 'site2', baseURL: 'https://site2.com', deliveryType: 'aem_edge' });
+
+      mockDataAccess.getSiteByBaseURL.withArgs('https://site1.com').resolves(site1);
+      mockDataAccess.getSiteByBaseURL.withArgs('https://site2.com').resolves(site2);
+
+      const response = await sitesController.bulkUpdateSitesConfig({
+        data: { baseURLs, enableAudits, auditTypes },
+      });
+
+      expect(mockDataAccess.getSiteByBaseURL.calledTwice).to.be.true;
+      expect(mockDataAccess.updateSite.calledTwice).to.be.true;
+      expect(response.status).to.equal(207);
+      const multiResponse = await response.json();
+      expect(multiResponse).to.be.an('array').with.lengthOf(2);
+      expect(multiResponse[0].baseURL).to.equal('https://site1.com');
+      expect(multiResponse[0].response.status).to.equal(200);
+      expect(multiResponse[1].baseURL).to.equal('https://site2.com');
+      expect(multiResponse[1].response.status).to.equal(200);
+    });
+
+    it('returns bad request when baseURLs is not provided', async () => {
+      const response = await sitesController.bulkUpdateSitesConfig({ data: {} });
+      const error = await response.json();
+
+      expect(response.status).to.equal(400);
+      expect(error).to.have.property('message', 'Base URLs are required');
+    });
+
+    it('returns bad request when auditTypes is not provided', async () => {
+      const response = await sitesController.bulkUpdateSitesConfig({ data: { baseURLs: ['https://site1.com'] } });
+      const error = await response.json();
+
+      expect(response.status).to.equal(400);
+      expect(error).to.have.property('message', 'Audit types are required');
+    });
+
+    it('returns bad request when enableAudits is not provided', async () => {
+      const response = await sitesController.bulkUpdateSitesConfig({ data: { baseURLs: ['https://site1.com'], auditTypes: ['type1'] } });
+      const error = await response.json();
+
+      expect(response.status).to.equal(400);
+      expect(error).to.have.property('message', 'enableAudits is required');
+    });
+
+    it('returns not found when site is not found', async () => {
+      mockDataAccess.getSiteByBaseURL.withArgs('https://site1.com').resolves(null);
+
+      const response = await sitesController.bulkUpdateSitesConfig({
+        data: { baseURLs: ['https://site1.com'], enableAudits: true, auditTypes: ['type1'] },
+      });
+      const responses = await response.json();
+
+      expect(responses).to.be.an('array').with.lengthOf(1);
+      expect(responses[0].baseURL).to.equal('https://site1.com');
+      expect(responses[0].response.status).to.equal(404);
+      expect(responses[0].response.message).to.equal('Site with baseURL: https://site1.com not found');
+    });
+  });
 });