fix(userHandler-asyncGetDeleted): ZMSA-52: user-handler create new asyncGetDeleted function to get deleted user by username, id, main address (#947)

* ZMSA-52: user-handler create new asyncGetDeleted function to get deleted user by username, id, main address

* add indexes for deletedusers collection

* user-handler asyncGetDeleted tests

* users-async-get-deleted-test.js remove .only from describe

* indexes, deletedusers indexes don't need to be unique indexes

Author: NickOvt

indexes.yaml

@@ -762,6 +762,21 @@ indexes:
           key:
               domain: 1
 
+    # Indexes for the deletedusers collection
+    - collection: deletedusers
+      type: users # index applies to users database
+      index:
+          name: deletedusers_dotless
+          key:
+              unameview: 1
+
+    - collection: deletedusers
+      type: users # index applies to users database
+      index:
+          name: deletedusers_address
+          key:
+              address: 1
+
 deleteindexes:
     - collection: settings
       index: key_enumerable

lib/user-handler.js

@@ -296,6 +296,55 @@ class UserHandler {
         }
     }
 
+    // Get user from deletedusers
+    async asyncGetDeleted(username, extraFields) {
+        let fields = {
+            _id: true,
+            quota: true,
+            storageUsed: true,
+            disabled: true,
+            suspended: true
+        };
+
+        Object.keys(extraFields || {}).forEach(field => {
+            fields[field] = true;
+        });
+
+        let addressData;
+        let query;
+        if (tools.isId(username)) {
+            query = { _id: new ObjectId(username) };
+        } else if (username.indexOf('@') < 0) {
+            // assume regular username
+            query = { unameview: tools.uview(username) };
+        } else {
+            // assume main address
+            query = { address: tools.uview(username) };
+        }
+
+        if (!query) {
+            return false;
+        }
+
+        try {
+            let userData = await this.users.collection('deletedusers').findOne(query, {
+                projection: fields,
+                maxTimeMS: consts.DB_MAX_TIME_USERS
+            });
+
+            if (userData && fields.name && addressData && addressData.name) {
+                // override name
+                userData.name = addressData.name;
+            }
+
+            return userData;
+        } catch (err) {
+            err.responseCode = 500;
+            err.code = 'InternalDatabaseError';
+            throw err;
+        }
+    }
+
     /**
      * rateLimitIP
      * if ip is not available will always return success object

test/api/users-async-get-deleted-test.js

@@ -0,0 +1,97 @@
+/*eslint no-unused-expressions: 0, prefer-arrow-callback: 0, no-console:0 */
+/* globals before: false, after: false */
+
+'use strict';
+
+const supertest = require('supertest');
+const chai = require('chai');
+const ObjectId = require('mongodb').ObjectId;
+
+const expect = chai.expect;
+chai.config.includeStack = true;
+
+const config = require('@zone-eu/wild-config');
+const UserHandler = require('../../lib/user-handler');
+const db = require('../../lib/db');
+
+const server = supertest.agent(`http://127.0.0.1:${config.api.port}`);
+
+describe('Async Get Deleted User', function () {
+    this.timeout(10000); // eslint-disable-line no-invalid-this
+
+    const username = 'deleted-user-handler';
+    const address = 'deleted-user-handler@example.com';
+
+    let userHandler;
+    let deletedUserId;
+
+    before(async () => {
+        await new Promise((resolve, reject) => db.connect(err => (err ? reject(err) : resolve())));
+        userHandler = new UserHandler({
+            database: db.database,
+            users: db.users,
+            redis: db.redis
+        });
+
+        const createResponse = await server
+            .post('/users')
+            .send({
+                username,
+                address,
+                password: 'secretvalue'
+            })
+            .expect(200);
+
+        expect(createResponse.body.success).to.be.true;
+        deletedUserId = createResponse.body.id;
+
+        const deleteAfter = new Date(Date.now() + 3600 * 1000).toISOString();
+        const deleteResponse = await server.delete(`/users/${deletedUserId}?deleteAfter=${encodeURIComponent(deleteAfter)}`).expect(200);
+
+        expect(deleteResponse.body.success).to.be.true;
+    });
+
+    after(async () => {
+        if (!deletedUserId) {
+            return;
+        }
+
+        const userObjectId = new ObjectId(deletedUserId);
+        await db.users.collection('deletedusers').deleteOne({ _id: userObjectId });
+        await db.database.collection('tasks').deleteMany({
+            task: 'user-delete',
+            $or: [{ user: userObjectId }, { 'data.user': userObjectId }]
+        });
+    });
+
+    it('should get deleted user by id expect success', async () => {
+        const deletedUser = await userHandler.asyncGetDeleted(deletedUserId, { username: true, address: true });
+
+        expect(deletedUser).to.exist;
+        expect(deletedUser._id.toString()).to.equal(deletedUserId);
+        expect(deletedUser.username).to.equal(username);
+        expect(deletedUser.address).to.equal(address);
+    });
+
+    it('should get deleted user by username expect success', async () => {
+        const deletedUser = await userHandler.asyncGetDeleted(username.toUpperCase(), { username: true });
+
+        expect(deletedUser).to.exist;
+        expect(deletedUser._id.toString()).to.equal(deletedUserId);
+        expect(deletedUser.username).to.equal(username);
+    });
+
+    it('should get deleted user by address expect success', async () => {
+        const deletedUser = await userHandler.asyncGetDeleted(address.toUpperCase(), { address: true });
+
+        expect(deletedUser).to.exist;
+        expect(deletedUser._id.toString()).to.equal(deletedUserId);
+        expect(deletedUser.address).to.equal(address);
+    });
+
+    it('should get deleted user expect failure for missing account', async () => {
+        const deletedUser = await userHandler.asyncGetDeleted('missing-user@example.com');
+
+        expect(deletedUser).to.be.null;
+    });
+});