Merge pull request #264 from map-of-pi/feat/expose-sanctioned-regions-to-client

Approved (1); Feat/expose sanctioned regions to client

Author: swoocn

src/controllers/admin/restrictionController.ts

@@ -0,0 +1,30 @@
+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;
+
+    const status = isSanctioned ? 'in a sanctioned zone' : 'not in a sanctioned zone';
+    logger.info(`User at [${latitude}, ${longitude}] is ${status}.`);
+		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/routes/restriction.routes.ts

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

src/services/admin/restriction.service.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/utils/app.ts

@@ -16,6 +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 restrictionRoutes from "../routes/restriction.routes";
 
 dotenv.config();
 
@@ -45,6 +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/restrictions", restrictionRoutes);
 
 app.use("/", homeRoutes);
 

test/controllers/admin/restrictionController.spec.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/services/admin/restriction.service.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();
+  });
+});