Misc PR adjustments; reorg + amend implementation; add associated unit tests.

Author: swoocn

src/controllers/admin/restrictionController.ts

@@ -0,0 +1,28 @@
+import { Request, Response } from "express";
+import * as restrictionService from "../../services/admin/restriction.service";
+
+import logger from "../../config/loggingConfig";
+
+export const  checkSanctionStatus = async (req: Request, res: Response) => {
+	const { latitude, longitude } = req.body;
+
+	if (typeof latitude !== 'number' || typeof longitude !== 'number') {
+    logger.error(`Invalid coordinates provided as ${latitude}, ${longitude}`);
+		return res.status(400).json({ error: 'Unexpected coordinates provided' });
+	}
+
+	try {
+		const result = await restrictionService.validateSellerLocation(longitude, latitude);
+		const isSanctioned = !!result;
+    logger.info(`User at [${latitude}, ${longitude}] is ${isSanctioned ? '' : 'not '} in a sanctioned zone.`);
+		return res.status(200).json({
+			message: `Sell center is set within a ${isSanctioned ? 'sanctioned' : 'unsanctioned' } zone`,
+			isSanctioned
+		});
+	} catch (error) {
+		logger.error('Failed to get sanctioned status:', error);
+		return res.status(500).json({ 
+      message: 'An error occurred while checking sanction status; please try again later' 
+    });
+	}
+};

src/controllers/sanctionedRegionsController.ts

@@ -1,52 +1,50 @@
 import {Router} from "express";
-import { verifyAdminToken } from "../middlewares/verifyToken";
-import * as sanctionedRegionsController from "../controllers/sanctionedRegionsController"
+import * as restrictionController from "../controllers/admin/restrictionController";
 
-const sanctionedRegionsRoutes = Router();
+const restrictionRoutes = Router();
 
 /**
  * @swagger
- * /api/v1/reports/check-in-sanctioned-region:
+ * /api/v1/restrictions/check-sanction-status:
  *   post:
  *     tags:
- *       - Report
- *     summary: Check if a point is within a sanctioned region
+ *       - Restriction
+ *     summary: Check if a [latitude, longitude] coordinate is within sanctioned boundaries.
  *     requestBody:
  *       required: true
  *       content:
  *         application/json:
  *           schema:
  *             type: object
- *             required:
- *               - latitude
- *               - longitude
  *             properties:
  *               latitude:
  *                 type: number
  *                 example: -1.94995
  *               longitude:
  *                 type: number
  *                 example: 30.0588
+ *             required:
+ *               - latitude
+ *               - longitude
  *     responses:
  *       200:
- *         description: Indicates whether the point is in a sanctioned region
+ *         description: Successful response
  *         content:
  *           application/json:
  *             schema:
  *               type: object
  *               properties:
- *                 isRestricted:
+ *                 isSanctioned:
  *                   type: boolean
  *                   example: true
  *       400:
- *         description: Invalid coordinates provided
+ *         description: Bad request
  *       500:
  *         description: Internal server error
  */
-sanctionedRegionsRoutes.post(
-  "/check-in-sanctioned-region",
-  // verifyAdminToken,
-  sanctionedRegionsController.checkIfPointInRegion
+restrictionRoutes.post(
+  "/check-sanction-status",
+  restrictionController.checkSanctionStatus
 );
 
-export default sanctionedRegionsRoutes;
+export default restrictionRoutes;

src/routes/sanctionedRegions.routes.ts renamed to src/routes/restriction.routes.ts

@@ -0,0 +1,18 @@
+import SanctionedRegion from "../../models/misc/SanctionedRegion";
+
+export const validateSellerLocation = async (longitude: number, latitude: number)  => {
+	const sellCenter = {
+		type: 'Point' as const,
+		coordinates: [longitude, latitude],
+	};
+
+	const isSanctionedLocation = await SanctionedRegion.findOne({
+		boundary: {
+			$geoIntersects: {
+				$geometry: sellCenter
+			}
+		}
+	}).exec();
+
+	return isSanctionedLocation;
+};

src/services/admin/restriction.service.ts

@@ -16,7 +16,7 @@ import reviewFeedbackRoutes from "../routes/reviewFeedback.routes";
 import mapCenterRoutes from "../routes/mapCenter.routes";
 import reportRoutes from "../routes/report.routes";
 import toggleRoutes from "../routes/toggle.routes";
-import sanctionedRegionsRoutes from "../routes/sanctionedRegions.routes";
+import restrictionRoutes from "../routes/restriction.routes";
 
 dotenv.config();
 
@@ -46,7 +46,7 @@ app.use("/api/v1/review-feedback", reviewFeedbackRoutes);
 app.use("/api/v1/map-center", mapCenterRoutes);
 app.use("/api/v1/reports", reportRoutes);
 app.use("/api/v1/toggles", toggleRoutes);
-app.use("/api/v1/sanctioned-regions", sanctionedRegionsRoutes);
+app.use("/api/v1/restrictions", restrictionRoutes);
 
 app.use("/", homeRoutes);
 

src/utils/app.ts

@@ -0,0 +1,83 @@
+import { checkSanctionStatus } from '../../../src/controllers/admin/restrictionController';
+import * as restrictionService from '../../../src/services/admin/restriction.service';
+import { RestrictedArea } from '../../../src/models/enums/restrictedArea';
+
+jest.mock('../../../src/services/admin/restriction.service', () => ({
+  validateSellerLocation: jest.fn(),
+}));
+
+describe('RestrictionController', () => {
+  let req: any;
+  let res: any;
+
+  beforeEach(() => {
+    req = { body: {} };
+    res = {
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn(),
+    };
+  });
+
+  describe('checkSanctionedStatus function', () => {
+    const mockSanctionedRegion = {
+      location: RestrictedArea.NORTH_KOREA,
+      boundary: {
+        type: 'Polygon',
+        coordinates: [[
+          [123.5, 37.5],
+          [131.2, 37.5],
+          [131.2, 43.0],
+          [123.5, 43.0],
+          [123.5, 37.5],
+        ]],
+      },
+    };
+
+    it('should return [200] and isSanctioned true if seller is in a sanctioned zone', async () => {
+      req.body = { latitude: 123.5, longitude: 40.5 };
+      (restrictionService.validateSellerLocation as jest.Mock).mockResolvedValue(mockSanctionedRegion);
+
+      await checkSanctionStatus(req, res);
+      expect(restrictionService.validateSellerLocation).toHaveBeenCalled();
+      expect(res.status).toHaveBeenCalledWith(200);
+      expect(res.json).toHaveBeenCalledWith({
+        message: 'Sell center is set within a sanctioned zone',
+        isSanctioned: true,
+      });
+    });
+
+    it('should return [200] and isSanctioned false if seller is not in a sanctioned zone', async () => {
+      req.body = { latitude: 23.5, longitude: 40.5 };
+      (restrictionService.validateSellerLocation as jest.Mock).mockResolvedValue(null);
+
+      await checkSanctionStatus(req, res);
+      expect(restrictionService.validateSellerLocation).toHaveBeenCalled();
+      expect(res.status).toHaveBeenCalledWith(200);
+      expect(res.json).toHaveBeenCalledWith({
+        message: 'Sell center is set within a unsanctioned zone',
+        isSanctioned: false,
+      });
+    });
+
+    it('should return [400] if latitude or longitude is missing or invalid', async () => {
+      req.body = { latitude: "malformed", longitude: null };
+  
+      await checkSanctionStatus(req, res);
+  
+      expect(res.status).toHaveBeenCalledWith(400);
+      expect(res.json).toHaveBeenCalledWith({ error: "Unexpected coordinates provided" });
+    });
+
+    it('should return appropriate [500] if check sanction status fails', async () => {
+      const mockError = new Error('An error occurred while checking sanction status; please try again later');
+      
+      req.body = { latitude: 23.5, longitude: 40.5 };
+      (restrictionService.validateSellerLocation as jest.Mock).mockRejectedValue(mockError);
+  
+      await checkSanctionStatus(req, res);
+      expect(restrictionService.validateSellerLocation).toHaveBeenCalled();
+      expect(res.status).toHaveBeenCalledWith(500);
+      expect(res.json).toHaveBeenCalledWith({ message: mockError.message });
+    });
+  });
+});

test/controllers/admin/restrictionController.spec.ts

@@ -0,0 +1,54 @@
+import { validateSellerLocation } from '../../../src/services/admin/restriction.service';
+import SanctionedRegion from '../../../src/models/misc/SanctionedRegion';
+import { RestrictedArea } from '../../../src/models/enums/restrictedArea';
+
+jest.mock('../../../src/models/misc/SanctionedRegion');
+
+describe('validateSellerLocation function', () => {
+  const longitude = 123.5;
+  const latitude = 40.5;
+
+  const mockSanctionedRegion = {
+    location: RestrictedArea.NORTH_KOREA,
+    boundary: {
+      type: 'Polygon',
+      coordinates: [[
+        [123.5, 37.5],
+        [131.2, 37.5],
+        [131.2, 43.0],
+        [123.5, 43.0],
+        [123.5, 37.5],
+      ]],
+    },
+  }; 
+
+  it('should return a sanctioned region given the coordinates is found', async () => {
+    (SanctionedRegion.findOne as jest.Mock).mockReturnValue({
+      exec: jest.fn().mockResolvedValue(mockSanctionedRegion),
+    });
+
+    const result = await validateSellerLocation(longitude, latitude);
+
+    expect(SanctionedRegion.findOne).toHaveBeenCalledWith({
+      boundary: {
+        $geoIntersects: {
+          $geometry: {
+            type: 'Point',
+            coordinates: [longitude, latitude],
+          },
+        },
+      },
+    });
+
+    expect(result).toEqual(mockSanctionedRegion);
+  });
+
+  it('should return null if no sanctioned region given the coordinates is found', async () => {
+    (SanctionedRegion.findOne as jest.Mock).mockReturnValue({
+      exec: jest.fn().mockResolvedValue(null),
+    });
+
+    const result = await validateSellerLocation(longitude, latitude);
+    expect(result).toBeNull();
+  });
+});