Merge pull request #1101 from Chia-Network/reset-audit-table-to-gener…

…ation

feat: added resetToGeneration audit endpoint

src/controllers/audit.controller.js

@@ -1,9 +1,10 @@
 import { Audit } from '../models';
-
+import _ from 'lodash';
 import {
   paginationParams,
   optionallyPaginatedResponse,
 } from '../utils/helpers';
+import { assertIfReadOnlyMode } from '../utils/data-assertions.js';
 
 export const findAll = async (req, res) => {
   try {
@@ -20,7 +21,7 @@ export const findAll = async (req, res) => {
     return res.json(optionallyPaginatedResponse(auditResults, page, limit));
   } catch (error) {
     res.status(400).json({
-      message: 'Can not retreive audit data',
+      message: 'Can not retrieve audit data',
       error: error.message,
       success: false,
     });
@@ -32,9 +33,73 @@ export const findConflicts = async (req, res) => {
     return res.json(await Audit.findConflicts());
   } catch (error) {
     res.status(400).json({
-      message: 'Can not retreive audit data',
+      message: 'Can not retrieve audit data',
       error: error.message,
       success: false,
     });
   }
 };
+
+export const resetToGeneration = async (req, res) => {
+  try {
+    await assertIfReadOnlyMode();
+    const { generation, orgUid } = req.body;
+
+    const result = await Audit.resetToGeneration(generation, orgUid);
+    if (_.isNil(result)) {
+      throw new Error('query failed');
+    }
+    return res.json({
+      message: result
+        ? 'reset to generation ' + String(generation)
+        : 'no matching records',
+      success: true,
+    });
+  } catch (error) {
+    if (error.message === 'SQLITE_BUSY: database is locked') {
+      res.status(400).json({
+        message: 'failed to change generation',
+        error: 'cadt is currently syncing, please try again later',
+        success: false,
+      });
+    } else {
+      res.status(400).json({
+        message: 'failed to change generation',
+        error: error.message,
+        success: false,
+      });
+    }
+  }
+};
+
+export const resetToDate = async (req, res) => {
+  try {
+    await assertIfReadOnlyMode();
+    const { date, orgUid, includeHomeOrg } = req.body;
+
+    const result = orgUid
+      ? await Audit.resetOrgToDate(date, orgUid)
+      : await Audit.resetToDate(date, includeHomeOrg);
+    if (_.isNil(result)) {
+      throw new Error('query failed');
+    }
+    return res.json({
+      message: result ? 'reset to date ' + String(date) : 'no matching records',
+      success: true,
+    });
+  } catch (error) {
+    if (error.message === 'SQLITE_BUSY: database is locked') {
+      res.status(400).json({
+        message: 'failed to reset to date',
+        error: 'cadt is currently syncing, please try again later',
+        success: false,
+      });
+    } else {
+      res.status(400).json({
+        message: 'failed to reset to date',
+        error: error.message,
+        success: false,
+      });
+    }
+  }
+};

src/models/audit/audit.model.js

@@ -6,6 +6,7 @@ import { sequelize, safeMirrorDbHandler } from '../../database';
 import { AuditMirror } from './audit.model.mirror';
 import ModelTypes from './audit.modeltypes.cjs';
 import findDuplicateIssuancesSql from './sql/find-duplicate-issuances.sql.js';
+import { Organization } from '../organizations/index.js';
 
 class Audit extends Model {
   static async create(values, options) {
@@ -45,6 +46,56 @@ class Audit extends Model {
     const [results] = await sequelize.query(findDuplicateIssuancesSql);
     return results;
   }
+
+  static async resetToGeneration(generation, orgUid) {
+    const where = {
+      generation: { [Sequelize.Op.gt]: generation },
+    };
+
+    if (orgUid) {
+      where.orgUid = orgUid;
+    }
+
+    return await Audit.destroy({ where });
+  }
+
+  static async resetToDate(date, includeHomeOrg) {
+    const timestampInSeconds = Math.round(new Date(date).valueOf() / 1000);
+    const homeOrgUid = Organization.getHomeOrg()?.uid;
+
+    const conditions = [
+      sequelize.where(
+        sequelize.cast(
+          sequelize.col('onChainConfirmationTimeStamp'),
+          'UNSIGNED',
+        ),
+        { [Sequelize.Op.gt]: timestampInSeconds },
+      ),
+    ];
+
+    if (!includeHomeOrg && homeOrgUid) {
+      conditions.push({ orguid: { [Sequelize.Op.ne]: homeOrgUid } });
+    }
+
+    return await Audit.destroy({ where: { [Sequelize.Op.and]: conditions } });
+  }
+
+  static async resetOrgToDate(date, orgUid) {
+    const timestampInSeconds = Math.round(new Date(date).valueOf() / 1000);
+
+    return await Audit.destroy({
+      where: {
+        orgUid: orgUid,
+        [Sequelize.Op.and]: sequelize.where(
+          sequelize.cast(
+            sequelize.col('onchainConfirmationTimeStamp'),
+            'UNSIGNED',
+          ),
+          { [Sequelize.Op.gt]: timestampInSeconds },
+        ),
+      },
+    });
+  }
 }
 
 Audit.init(ModelTypes, {

src/routes/v1/resources/audit.js

@@ -4,7 +4,11 @@ import express from 'express';
 import joiExpress from 'express-joi-validation';
 
 import { AuditController } from '../../../controllers';
-import { auditGetSchema } from '../../../validations';
+import {
+  auditGetSchema,
+  auditResetToDateSchema,
+  auditResetToGenerationSchema,
+} from '../../../validations';
 
 const validator = joiExpress.createValidator({ passError: true });
 const AuditRouter = express.Router();
@@ -17,4 +21,20 @@ AuditRouter.get('/findConflicts', (req, res) => {
   return AuditController.findConflicts(req, res);
 });
 
+AuditRouter.post(
+  '/resetToGeneration',
+  validator.body(auditResetToGenerationSchema),
+  (req, res) => {
+    return AuditController.resetToGeneration(req, res);
+  },
+);
+
+AuditRouter.post(
+  '/resetToDate',
+  validator.body(auditResetToDateSchema),
+  (req, res) => {
+    return AuditController.resetToDate(req, res);
+  },
+);
+
 export { AuditRouter };

src/tasks/index.js

@@ -6,6 +6,7 @@ import syncRegistries from './sync-registries';
 import syncOrganizationMeta from './sync-organization-meta';
 import syncGovernanceBody from './sync-governance-body';
 import mirrorCheck from './mirror-check';
+import resetAuditTable from './reset-audit-table';
 
 const scheduler = new ToadScheduler();
 
@@ -25,6 +26,7 @@ const start = () => {
     syncRegistries,
     syncOrganizationMeta,
     mirrorCheck,
+    resetAuditTable,
   ];
   defaultJobs.forEach((defaultJob) => {
     jobRegistry[defaultJob.id] = defaultJob;

src/tasks/reset-audit-table.js

@@ -0,0 +1,66 @@
+import { SimpleIntervalJob, Task } from 'toad-scheduler';
+import { Audit, Meta } from '../models';
+import { logger } from '../config/logger.cjs';
+import dotenv from 'dotenv';
+import _ from 'lodash';
+dotenv.config();
+
+const task = new Task('reset-audit-table', async () => {
+  try {
+    const metaResult = await Meta.findOne({
+      where: {
+        metaKey: 'may2024AuditResetTaskHasRun',
+      },
+      attributes: ['metaValue'],
+      raw: true,
+    });
+
+    const taskHasRun = metaResult?.metaValue;
+
+    if (taskHasRun === 'true') {
+      return;
+    }
+
+    logger.info('performing audit table reset');
+
+    const where = { type: 'NO CHANGE' };
+    const noChangeEntries = await Audit.findAll({ where });
+
+    if (noChangeEntries.length) {
+      const result = await Audit.resetToDate('2024-05-11');
+      logger.info(
+        'audit table has been reset, records modified: ' + String(result),
+      );
+    }
+
+    if (_.isNil(taskHasRun)) {
+      await Meta.create({
+        metaKey: 'may2024AuditResetTaskHasRun',
+        metaValue: 'true',
+      });
+    } else {
+      await Meta.update(
+        { metavalue: 'true' },
+        {
+          where: {
+            metakey: 'may2024AuditResetTaskHasRun',
+          },
+          returning: true,
+        },
+      );
+    }
+  } catch (error) {
+    logger.error('Retrying in 600 seconds', error);
+  }
+});
+
+const job = new SimpleIntervalJob(
+  {
+    seconds: 600,
+    runImmediately: true,
+  },
+  task,
+  { id: 'reset-audit-table', preventOverrun: true },
+);
+
+export default job;

src/validations/audit.validations.js

@@ -9,3 +9,14 @@ export const auditGetSchema = Joi.object()
   })
   .with('page', 'limit')
   .with('limit', 'page');
+
+export const auditResetToGenerationSchema = Joi.object().keys({
+  generation: Joi.number(),
+  orgUid: Joi.string(),
+});
+
+export const auditResetToDateSchema = Joi.object().keys({
+  date: Joi.date(),
+  orgUid: Joi.string().optional(),
+  includeHomeOrg: Joi.bool().optional(),
+});