feat: add site management endpoints

docker-compose-prod.yaml

@@ -2,7 +2,7 @@ services:
 
   vis:
     container_name: vis
-    image: ghcr.io/local-connectivity-lab/ccn-coverage-vis:latest
+    image: ccn-coverage-vis:latest
     ports:
       - "8090:80"
     depends_on:
@@ -12,7 +12,7 @@ services:
 
   api:
     container_name: api
-    image:  ghcr.io/local-connectivity-lab/ccn-coverage-api:latest
+    image:  ccn-coverage-api:latest
     ports:
       - "8091:3000"
     environment:

docker-compose.yaml

@@ -8,7 +8,7 @@ services:
       - MONGODB_URI=mongodb://mongodb:27017/api-data
       - LDAP_URI=ldap://ldap:389
     volumes:
-      - ./keys/:/app/keys
+      - ./keys/:/usr/src/app/keys/
     depends_on:
       - mongodb
       - ldap

src/index.ts

@@ -11,6 +11,8 @@ import { ldapRouter } from './routes/ldap-login';
 import { newUserRouter } from './routes/new-user';
 import { usersRouter } from './routes/users';
 import { editSitesRouter } from './routes/edit-sites';
+import { secureSitesRouter } from './routes/secure-site';
+import { publicSitesRouter } from './routes/public-sites';
 import logger from './logger';
 import cors from 'cors';
 
@@ -72,6 +74,8 @@ app.use(ldapRouter);
 app.use(newUserRouter);
 app.use(usersRouter);
 app.use(editSitesRouter);
+app.use(secureSitesRouter);
+app.use(publicSitesRouter);
 
 process.on('SIGINT', async () => {
   await mongoose.connection.close();

src/models/site.ts

@@ -0,0 +1,66 @@
+import mongoose from 'mongoose';
+import { components } from '../types/schema';
+
+type ISite = components['schemas']['Site'];
+
+interface SiteDoc extends mongoose.Document, ISite {}
+
+interface SiteModelInterface extends mongoose.Model<SiteDoc> {
+  build(attr: ISite): SiteDoc;
+}
+
+const siteSchema = new mongoose.Schema(
+  {
+    name: {
+      type: String,
+      required: true,
+    },
+    latitude: {
+      type: Number,
+      required: true,
+    },
+    longitude: {
+      type: Number,
+      required: true,
+    },
+    status: {
+      type: String,
+      enum: ['active', 'confirmed', 'in-conversation'],
+      required: true,
+    },
+    address: {
+      type: String,
+      required: true,
+    },
+    cell_id: {
+      type: [String],
+      required: true,
+    },
+    color: {
+      type: String,
+      required: false,
+    },
+    boundary: {
+      type: [[Number]],
+      validate: {
+        validator: function (val: number[][]) {
+          return val.every(pair => pair.length === 2);
+        },
+        message:
+          'Each boundary coordinate must be a pair of [latitude, longitude]',
+      },
+      required: false,
+    },
+  },
+  {
+    versionKey: false,
+  },
+);
+
+siteSchema.statics.build = (attr: ISite) => {
+  return new Site(attr);
+};
+
+const Site = mongoose.model<SiteDoc, SiteModelInterface>('Site', siteSchema);
+
+export { Site, ISite, SiteDoc };

src/routes/public-sites.ts

@@ -0,0 +1,19 @@
+import express, { Request, Response } from 'express';
+import { Site } from '../models/site';
+
+const router = express.Router();
+
+router.get('/api/public-sites', async (req: Request, res: Response) => {
+  try {
+    const sites = await Site.find();
+
+    res.status(200).json({
+      sites: sites,
+    });
+  } catch (error) {
+    console.error('Error retrieving public sites:', error);
+    res.status(500).send('Internal server error');
+  }
+});
+
+export { router as publicSitesRouter };

src/routes/secure-site.ts

@@ -0,0 +1,91 @@
+import express, { Request, Response } from 'express';
+import { Site } from '../models/site';
+// import connectEnsureLogin from 'connect-ensure-login';
+import { components } from '../types/schema';
+
+const router = express.Router();
+
+type SiteRequest = components['schemas']['Site'];
+
+router.put(
+  '/api/secure-site',
+  //   connectEnsureLogin.ensureLoggedIn('/api/failure'),
+  async (req: Request, res: Response) => {
+    try {
+      const siteData: SiteRequest = req.body;
+
+      if (!siteData.name) {
+        res.status(400).json({ error: 'Site name is required' });
+        return;
+      }
+
+      const updatedSite = await Site.findOneAndUpdate(
+        { name: siteData.name },
+        siteData,
+        { new: true, runValidators: true },
+      );
+
+      if (!updatedSite) {
+        res.status(404).json({ error: 'Site not found' });
+        return;
+      }
+
+      res.status(200).json({ message: 'Site updated successfully' });
+    } catch (error: any) {
+      res.status(500).json({ error: 'Internal server error' });
+    }
+  },
+);
+
+router.post(
+  '/api/secure-site',
+  //   connectEnsureLogin.ensureLoggedIn('/api/failure'),
+  async (req: Request, res: Response) => {
+    try {
+      const siteData: SiteRequest = req.body;
+
+      const newSite = Site.build(siteData);
+      const savedSite = await newSite.save();
+
+      res.status(201).json(savedSite);
+    } catch (error: any) {
+      if (error.name === 'ValidationError') {
+        res
+          .status(400)
+          .json({ error: 'Validation error', details: error.message });
+        return;
+      }
+      res.status(500).json({ error: 'Internal server error' });
+    }
+  },
+);
+
+router.delete(
+  '/api/secure-site',
+  //   connectEnsureLogin.ensureLoggedIn('/api/failure'),
+  async (req: Request, res: Response) => {
+    try {
+      const siteData: SiteRequest = req.body;
+
+      if (!siteData.name) {
+        res.status(400).json({ error: 'Site name is required' });
+        return;
+      }
+
+      const deletedSite = await Site.findOneAndDelete({ name: siteData.name });
+
+      if (!deletedSite) {
+        res.status(404).json({ error: 'Site not found' });
+        return;
+      }
+
+      res
+        .status(200)
+        .json({ message: 'Site deleted successfully', site: deletedSite });
+    } catch (error: any) {
+      res.status(500).json({ error: 'Internal server error' });
+    }
+  },
+);
+
+export { router as secureSitesRouter };