Start implementing logos

Author: o-seliuchenko

src/app.ts

@@ -9,6 +9,7 @@ import userRoutes from './routes/userRoutes.js';
 import bannerRoutes from './routes/bannerRoutes.js';
 import swepBannerRoutes from './routes/swepBannerRoutes.js';
 import resourceRoutes from './routes/resourceRoutes.js';
+import locationLogoRoutes from './routes/locationLogoRoutes.js';
 import { errorHandler, notFound } from './middleware/errorMiddleware.js';
 import checkJwt from './middleware/checkJwt.js';
 import './instrument.js';
@@ -38,6 +39,7 @@ app.use('/api/users', userRoutes);
 app.use('/api/banners', bannerRoutes);
 app.use('/api/swep-banners', swepBannerRoutes);
 app.use('/api/resources', resourceRoutes);
+app.use('/api/location-logos', locationLogoRoutes);
 
 // The error handler must be registered before any other error middleware and after all controllers
 Sentry.setupExpressErrorHandler(app);

src/controllers/bannerController.ts

@@ -16,7 +16,7 @@ export const getBanners = asyncHandler(async (req: Request, res: Response) => {
     isActive, 
     search,
     page = 1, 
-    limit = 10,
+    limit = 9,
     sortBy = 'Priority',
     sortOrder = 'desc'
   } = req.query;

src/controllers/faqController.ts

@@ -13,7 +13,7 @@ export const getFaqs = asyncHandler(async (req: Request, res: Response) => {
     location,
     search,
     page = 1,
-    limit = 10,
+    limit = 9,
     sortBy = 'DocumentModifiedDate',
     sortOrder = 'desc'
   } = req.query;

src/controllers/locationLogoController.tsx

@@ -0,0 +1,198 @@
+import { Request, Response } from 'express';
+import { asyncHandler } from '../utils/asyncHandler.js';
+import { sendSuccess, sendBadRequest, sendNotFound, sendPaginatedSuccess } from '../utils/apiResponses.js';
+import { validateLocationLogo } from '../schemas/locationLogoSchema.js';
+import LocationLogo from '../models/locationLogosModel.js';
+import { deleteFile } from '../middleware/uploadMiddleware.js';
+
+// @desc    Get all location logos with optional filtering
+// @route   GET /api/location-logos
+// @access  Private
+export const getLocationLogos = asyncHandler(async (req: Request, res: Response) => {
+  const {
+    location,
+    locations, // Comma-separated list for location filtering
+    search,
+    page = 1,
+    limit = 9,
+    sortBy = 'DocumentModifiedDate',
+    sortOrder = 'desc'
+  } = req.query;
+
+  const query: any = {};
+  const conditions: any[] = [];
+
+  // Apply search filter
+  if (search && typeof search === 'string') {
+    conditions.push({
+      $or: [
+        { DisplayName: { $regex: search.trim(), $options: 'i' } }
+      ]
+    });
+  }
+
+  // Apply location filter
+  if (locations && typeof locations === 'string') {
+    const locationArray = locations.split(',').map(loc => loc.trim()).filter(Boolean);
+    if (locationArray.length > 0) {
+      conditions.push({ LocationSlug: { $in: locationArray } });
+    }
+  } else if (location && typeof location === 'string') {
+    conditions.push({ LocationSlug: location });
+  }
+
+  // Combine all conditions with AND logic
+  if (conditions.length > 0) {
+    query.$and = conditions;
+  }
+
+  // Pagination
+  const skip = (Number(page) - 1) * Number(limit);
+
+  // Sort options
+  const sortOptions: any = {};
+  sortOptions[sortBy as string] = sortOrder === 'desc' ? -1 : 1;
+
+  const logos = await LocationLogo.find(query)
+    .sort(sortOptions)
+    .skip(skip)
+    .limit(Number(limit))
+    .lean();
+
+  // Get total count using the same query
+  const total = await LocationLogo.countDocuments(query);
+
+  return sendPaginatedSuccess(res, logos, {
+    page: Number(page),
+    limit: Number(limit),
+    total,
+    pages: Math.ceil(total / Number(limit))
+  });
+});
+
+// @desc    Get single location logo by ID
+// @route   GET /api/location-logos/:id
+// @access  Private
+export const getLocationLogoById = asyncHandler(async (req: Request, res: Response) => {
+  const logo = await LocationLogo.findById(req.params.id);
+  
+  if (!logo) {
+    return sendNotFound(res, 'Location logo not found');
+  }
+  
+  return sendSuccess(res, logo);
+});
+
+
+// @desc    Create location logo
+// @route   POST /api/location-logos
+// @access  Private
+export const createLocationLogo = asyncHandler(async (req: Request, res: Response) => {
+  // Extract uploaded file URL from req
+  let logoPath = '';
+  if (req.body.LogoPath) {
+    logoPath = req.body.LogoPath;
+  }
+
+  const logoData = {
+    ...req.body,
+    LogoPath: logoPath,
+    CreatedBy: req.user?.id || 'system'
+  };
+
+  // Validate logo data
+  const validation = validateLocationLogo(logoData);
+  if (!validation.success) {
+    return sendBadRequest(res, 'Validation failed');
+  }
+
+  // Create location logo
+  const logo = await LocationLogo.create(logoData);
+  
+  return sendSuccess(res, logo, 'Location logo created successfully');
+});
+
+// @desc    Update location logo
+// @route   PUT /api/location-logos/:id
+// @access  Private
+export const updateLocationLogo = asyncHandler(async (req: Request, res: Response) => {
+  const { id } = req.params;
+  
+  // Get existing location logo
+  const existingLogo = await LocationLogo.findById(id);
+  
+  if (!existingLogo) {
+    return sendNotFound(res, 'Location logo not found');
+  }
+
+  // Store old logo path for cleanup
+  const oldLogoPath = existingLogo.LogoPath;
+
+  // Extract uploaded file URL from req
+  let logoPath = existingLogo.LogoPath;
+  if (req.body.LogoPath && req.body.LogoPath !== existingLogo.LogoPath) {
+    logoPath = req.body.LogoPath;
+  }
+
+  const logoData = {
+    ...req.body,
+    LogoPath: logoPath,
+    DocumentModifiedDate: new Date()
+  };
+
+  // Validate logo data
+  const validation = validateLocationLogo(logoData);
+  if (!validation.success) {
+    return sendBadRequest(res, 'Validation failed');
+  }
+
+  // Update location logo
+  const updatedLogo = await LocationLogo.findByIdAndUpdate(
+    id,
+    logoData,
+    { new: true, runValidators: true }
+  );
+
+  // Cleanup old logo file if it was replaced
+  if (logoPath !== oldLogoPath && oldLogoPath) {
+    try {
+      await deleteFile(oldLogoPath);
+      console.log(`Deleted old logo file: ${oldLogoPath}`);
+    } catch (error) {
+      console.error(`Failed to delete old logo file: ${oldLogoPath}`, error);
+    }
+  }
+  
+  return sendSuccess(res, updatedLogo, 'Location logo updated successfully');
+});
+
+// @desc    Delete location logo
+// @route   DELETE /api/location-logos/:id
+// @access  Private
+export const deleteLocationLogo = asyncHandler(async (req: Request, res: Response) => {
+  const { id } = req.params;
+  
+  const logo = await LocationLogo.findById(id);
+  
+  if (!logo) {
+    return sendNotFound(res, 'Location logo not found');
+  }
+
+  // Store logo path for cleanup
+  const logoPath = logo.LogoPath;
+  
+  // Delete from database
+  await LocationLogo.findByIdAndDelete(id);
+
+  // Delete logo file from storage
+  if (logoPath) {
+    try {
+      await deleteFile(logoPath);
+      console.log(`Deleted logo file: ${logoPath}`);
+    } catch (error) {
+      console.error(`Failed to delete logo file: ${logoPath}`, error);
+    }
+  }
+  
+  return sendSuccess(res, null, 'Location logo deleted successfully');
+});

src/controllers/swepBannerController.ts

@@ -15,7 +15,7 @@ export const getSwepBanners = asyncHandler(async (req: Request, res: Response) =
     isActive,
     search,
     page = 1,
-    limit = 10,
+    limit = 9,
     sortBy = 'DocumentModifiedDate',
     sortOrder = 'desc'
   } = req.query;

src/controllers/userController.ts

@@ -19,7 +19,7 @@ const getUsers = asyncHandler(async (req: Request, res: Response) => {
     location,
     locations, // New: comma-separated list of locations for CityAdmin filtering
     page = 1, 
-    limit = 10,
+    limit = 9,
     sortBy = 'DocumentModifiedDate',
     sortOrder = 'desc'
   } = req.query;

src/middleware/authMiddleware.ts

@@ -20,6 +20,7 @@ import { asyncHandler } from '../utils/asyncHandler.js';
 import Accommodation from '../models/accommodationModel.js';
 import GroupedService from '../models/groupedServiceModel.js';
 import SwepBanner from '../models/swepModel.js';
+import LocationLogo from '../models/locationLogosModel.js';
 
 type PreValidatedBannerData = z.output<typeof BannerPreUploadApiSchema>;
 // Extend Request interface to include user
@@ -1587,3 +1588,104 @@ export const resourcesAuth = [
   authenticate,
   requireResourceAccess
 ];
+
+/**
+ * Middleware for location logo access control with location validation
+ */
+export const requireLocationLogoAccess = asyncHandler(async (req: Request, res: Response, next: NextFunction) => {
+  if (ensureAuthenticated(req, res)) return;
+
+  if (req.method === HTTP_METHODS.GET || req.method === HTTP_METHODS.PUT || req.method === HTTP_METHODS.POST || req.method === HTTP_METHODS.DELETE) {
+    const userAuthClaims = req.user?.AuthClaims || [];
+  
+    // SuperAdmin and VolunteerAdmin global rule
+    if (handleSuperAdminAccess(userAuthClaims) || handleVolunteerAdminAccess(userAuthClaims)) { return next(); }
+
+    // Check if user has CityAdmin role
+    if (!userAuthClaims.includes(ROLES.CITY_ADMIN)) {
+      return sendForbidden(res);
+    }
+
+    // For operations on specific location logos, check LocationSlug access
+    const locationLogoIdOrSlug = req.params.id || req.body.LocationSlug;
+    
+    if (locationLogoIdOrSlug) {
+      try {
+        // If it's an ID, get the logo first
+        let locationSlug = '';
+        if (req.params.id) {
+          const logo = await LocationLogo.findById(req.params.id).lean();
+          if (logo) {
+            locationSlug = logo.LocationSlug;
+          }
+        } else {
+          locationSlug = req.body.LocationSlug;
+        }
+
+        if (locationSlug) {
+          // Check if CityAdmin has access to this location
+          const locations = [locationSlug];
+          if (validateSwepAndCityAdminLocationsAccess(userAuthClaims, locations, res)) {
+            return; // Access denied, response already sent
+          }
+        }
+
+        next();
+      } catch (error) {
+        console.error('Error validating location logo access:', error);
+        return sendInternalError(res);
+      }
+    } else {
+      // No specific location, allow access for listing
+      next();
+    }
+  } else {
+    return sendForbidden(res, 'Invalid HTTP method for this endpoint');
+  }
+});
+
+/**
+ * Combined middleware for location logos endpoint
+ */
+export const locationLogosAuth = [
+  authenticate,
+  requireLocationLogoAccess
+];
+
+/**
+ * Middleware for location logos location-based access (GET list)
+ */
+export const requireLocationLogoByFiltersAccess = (req: Request, res: Response, next: NextFunction) => {
+  if (ensureAuthenticated(req, res)) return;
+
+  if (req.method !== HTTP_METHODS.GET) {
+    return sendForbidden(res, 'Invalid HTTP method for this endpoint');
+  }
+
+  const userAuthClaims = req.user?.AuthClaims || [];
+  
+  // SuperAdmin and VolunteerAdmin global rule
+  if (handleSuperAdminAccess(userAuthClaims) || handleVolunteerAdminAccess(userAuthClaims)) { return next(); }
+
+  // Check if user has CityAdmin role
+  if (!userAuthClaims.includes(ROLES.CITY_ADMIN)) {
+    return sendForbidden(res);
+  }
+
+  // For location-based access, check the location and locations param
+  const locations = extractLocationsFromQuery(req);
+
+  if (validateSwepAndCityAdminLocationsAccess(userAuthClaims, locations, res)) {
+    return; // Access denied, response already sent
+  }
+
+  next();
+};
+
+/**
+ * Combined middleware for location logos GET list endpoint
+ */
+export const locationLogosGetAuth = [
+  authenticate,
+  requireLocationLogoByFiltersAccess
+];