Whitelist codes

config/.env.example

@@ -23,3 +23,4 @@ S3_KMS_KEY=
 S3_REGION=
 S3_SECRET_ACCESS_KEY=
 SERVICE_DID=
+WHITELIST_ADMIN_API_KEY=

src/domain/account/whitelist/codes.json

@@ -20,17 +20,13 @@
         "description": "ETHDENVER Campaign"
     },
     {
-        "code": "ARWEAVE",
-        "description": "Areweave Developers"
+        "code": "ONLY_FILES",
+        "description": "Only Files Campaign"
     },
     {
         "code": "FILEVERSE_SUMMER",
         "description": "Limited Activity"
     },
-    {
-        "code": "ONLY_FILES",
-        "description": "Allowlisted Portals"
-    },
     {
         "code": "FARCASTER1",
         "description": "BountyCaster - 7 Days Activity"

src/domain/account/whitelist/hasReferralCode.js

@@ -1,13 +1,22 @@
-const codes = require("./codes.json");
+const WhitelistCodes = require("../../whitelistCodes")
 
 async function hasReferralCode({ code }) {
   if (!code) {
     return false;
   }
-  const found = codes.find(
-    (elem) => elem.code.toLowerCase() === code.toLowerCase()
-  );
-  return !!found;
+  const resp = await WhitelistCodes.isEnalbed({ code });
+
+  if (resp == false) {
+    return false;
+  }
+
+  try {
+    _ = await WhitelistCodes.updateCount({ code });
+  } catch (e) {
+    console.error("failed to update the count of code", code, "due to ", e);
+  }
+  return true;
+
 }
 
 module.exports = hasReferralCode;

src/domain/whitelist/create.js

@@ -0,0 +1,12 @@
+const { Whitelist } = require('../../infra/database/models')
+
+async function create({ addressList, tag, addedBy }) {
+    tag = tag || 'personal-invite'
+    const bulkData = addressList.map((addr) => {
+        return { invokerAddress: addr, tag: tag, addedBy: addedBy }
+    })
+
+    await Whitelist.insertMany(bulkData)
+}
+
+module.exports = create;

src/domain/whitelist/find.js

@@ -0,0 +1,8 @@
+const { Whitelist } = require('../../infra/database/models')
+
+async function find({ address }) {
+    const result = await Whitelist.findOne({ invokerAddress: address });
+    return result;
+}
+
+module.exports = find;

src/domain/whitelist/index.js

@@ -0,0 +1,4 @@
+const create = require('./create');
+const find = require('./find');
+
+module.exports = { create, find };

src/domain/whitelistCodes/disable.js

@@ -0,0 +1,12 @@
+const { WhitelistCodes } = require("../../infra/database/models");
+
+async function disable({ codes }) {
+    const updatedWhitelistCodesData = await WhitelistCodes.findOneAndUpdate(
+        { code: { $in: codes } },
+        { status: 'inactive' },
+        { new: true }
+    );
+    return updatedWhitelistCodesData;
+}
+
+module.exports = disable;

src/domain/whitelistCodes/get.js

@@ -0,0 +1,32 @@
+const { WhitelistCodes } = require("../../infra/database/models");
+
+async function getByCode({ code }) {
+    return await WhitelistCodes.findOne({ code });
+}
+
+async function getAllByStatus({ status }) {
+
+    const whitelistCodes = WhitelistCodes.find({ status });
+    if (status == 'active') {
+        whitelistCodes.find({
+            $and: [
+                {
+                    $or: [
+                        { expiry: null },
+                        { expiry: { $lt: Date.now() } }
+                    ]
+                },
+                {
+                    $or: [
+                        { allowedUses: null },
+                        { $expr: { $gt: ['$allowedUses', '$used'] } }
+                    ]
+                }
+            ]
+        })
+    }
+
+    return await whitelistCodes;
+}
+
+module.exports = { getAllByStatus, getByCode };

src/domain/whitelistCodes/index.js

@@ -0,0 +1,7 @@
+const isEnalbed = require("./isEnabled");
+const add = require("./newCodes");
+const disable = require("./disable");
+const { getAllByStatus, getByCode } = require("./get");
+const updateCount = require("./updateCount");
+
+module.exports = { isEnalbed, add, disable, updateCount, getAllByStatus, getByCode };

src/domain/whitelistCodes/isEnabled.js

@@ -0,0 +1,17 @@
+const { WhitelistCodes } = require("../../infra/database/models");
+
+async function isEnalbed({ code }) {
+    const whitelistCode = await WhitelistCodes.findOne({ code });
+
+    if (whitelistCode.status != 'active') {
+        return false;
+    } else if (whitelistCode.expiry && whitelistCode.expiry < new Date()) {
+        return false;
+    } else if (whitelistCode.allowedUses && whitelistCode.allowedUses <= whitelistCode.used) {
+        return false;
+    } else {
+        return true;
+    }
+}
+
+module.exports = isEnalbed;

src/domain/whitelistCodes/newCodes.js

@@ -0,0 +1,21 @@
+const { WhitelistCodes } = require("../../infra/database/models");
+
+async function add({ code, description, expiry, status, allowedUses, timeStamp }) {
+    const isExistingCode = await WhitelistCodes.findOne({ code });
+    if (isExistingCode) {
+        throw new Error('Code already exists');
+    }
+
+    const createdWhitelistCodesData = await WhitelistCodes.create({
+        code,
+        description,
+        expiry: expiry ? new Date(expiry) : null,
+        status,
+        allowedUses: allowedUses || null,
+        timeStamp,
+    });
+
+    return createdWhitelistCodesData;
+}
+
+module.exports = add;

src/domain/whitelistCodes/updateCount.js

@@ -0,0 +1,13 @@
+const { WhitelistCodes } = require("../../infra/database/models");
+
+async function updateCount({ code }) {
+    const whitelistCode = await WhitelistCodes.findOneAndUpdate(
+        { code },
+        { $inc: { used: 1 } },
+        { new: true }
+    );
+
+    return whitelistCode;
+}
+
+module.exports = updateCount;

src/infra/database/models/index.js

@@ -5,6 +5,7 @@ const _models = {
   Gate: require("./gate").model,
   Whitelist: require("./whitelist").model,
   Heart: require("./heart").model,
+  WhitelistCodes: require("./whitelistCodes").model,
 };
 
 module.exports = _models;

src/infra/database/models/whitelist.js

@@ -15,6 +15,7 @@ _whitelist.schema = new Schema({
     required: true,
     default: Date.now
   },
+  addedBy: { type: String },
 });
 
 _whitelist.schema.pre('save', function (next) {
@@ -28,6 +29,7 @@ _whitelist.schema.methods.safeObject = function () {
     'invokerAddress',
     'tag',
     'timeStamp',
+    'addedBy'
   ];
   const newSafeObject = {};
   safeFields.forEach((elem) => {

src/infra/database/models/whitelistCodes.js

@@ -0,0 +1,67 @@
+const mongoose = require('mongoose');
+const { Schema } = mongoose;
+
+const _whitelist_codes = {};
+
+
+
+_whitelist_codes.schema = new Schema({
+  code: {
+    type: String,
+    required: true
+  },
+  description: {
+    type: String,
+    required: true
+  },
+  timeStamp: {
+    type: Date,
+    required: true,
+    default: Date.now
+  },
+  status: {
+    type: String,
+    required: true,
+    enum: ['active', 'inactive', 'expired'], // Optional: to restrict the values for status
+    default: 'active'
+  },
+  expiry: {
+    type: Date,
+    required: false
+  },
+  allowedUses: {
+    type: Number,
+    required: false,
+  },
+  used: {
+    type: Number,
+    required: true,
+    default: 0
+  }
+});
+
+_whitelist_codes.schema.pre('save', function (next) {
+  this.timeStamp = Date.now();
+  next();
+});
+
+_whitelist_codes.schema.methods.safeObject = function () {
+  const safeFields = [
+    '_id',
+    'code',
+    'description',
+    'expiry',
+    'status',
+    'timeStamp',
+  ];
+  const newSafeObject = {};
+  safeFields.forEach((elem) => {
+    // eslint-disable-next-line security/detect-object-injection
+    newSafeObject[elem] = this[elem];
+  });
+  return newSafeObject;
+};
+
+_whitelist_codes.model = mongoose.model('whitelist_codes', _whitelist_codes.schema);
+
+module.exports = _whitelist_codes;

src/interface/index.js

@@ -4,9 +4,11 @@ const router = express.Router();
 const gate = require('./gate');
 const account = require('./account');
 const contract = require('./contract');
+const whitelist = require('./whitelist');
 
 router.use('/gate', gate);
 router.use('/account', account);
 router.use('/contract', contract);
+router.use('/whitelist', whitelist);
 
 module.exports = router;

src/interface/middleware/index.js

@@ -6,5 +6,6 @@ module.exports = {
   canRegisterMember: require('./canRegisterMember'),
   canCheckWhitelist: require('./canCheckWhitelist'),
   errorHandler: require('./errorHandler'),
+  whitelistAdmin: require('./whitelistAdmin'),
   validator: require('./validator'),
 };

src/interface/middleware/whitelistAdmin.js

@@ -0,0 +1,19 @@
+const ErrorHandler = require('../../infra/errorHandler');
+const config = require('../../../config');
+
+const whitelistAdminApiKey = config.WHITELIST_ADMIN_API_KEY;
+
+async function whitelistAdmin(req, res, next) {
+  const xApiKey = req.headers['x-api-key'];
+  if (!xApiKey || !whitelistAdminApiKey || xApiKey !== whitelistAdminApiKey) {
+    return ErrorHandler.throwError({
+      code: 401,
+      message: 'Unauthorized',
+      req,
+    });
+  }
+
+  next();
+}
+
+module.exports = whitelistAdmin;

src/interface/whitelist/address/address.js

@@ -0,0 +1,27 @@
+const Whitelist = require('../../../domain/whitelist');
+const { validator } = require("../../middleware");
+const { Joi, validate } = validator;
+
+const whiteListAddressValidation = {
+    body: Joi.object({
+        addressList: Joi.array().items(
+            Joi.string().required(),
+        ).required(),
+        tag: Joi.string().optional(),
+        addedBy: Joi.string().required(),
+    }),
+};
+
+
+async function whitelistAddress(req, res) {
+    const { addressList, tag, addedBy } = req.body;
+    try {
+        await Whitelist.create({ addressList, tag, addedBy });
+        res.json({ success: true, error: null });
+    }
+    catch (error) {
+        return res.status(400).json({ success: false, error: error.message });
+    }
+}
+
+module.exports = [validate(whiteListAddressValidation), whitelistAddress];

src/interface/whitelist/address/index.js

@@ -0,0 +1,17 @@
+const express = require('express');
+
+const router = express.Router();
+
+const {
+    asyncHandler,
+    asyncHandlerArray,
+} = require('../../../infra/asyncHandler');
+
+const whitelistAddress = require('./address');
+const isWhitelistedAddress = require('./isWhitelistedAddress');
+const { whitelistAdmin } = require('../../middleware');
+
+router.post('/address', asyncHandler(whitelistAdmin), asyncHandlerArray(whitelistAddress));
+router.get('/address/:address', asyncHandler(isWhitelistedAddress));
+
+module.exports = router;