fixed the get in the getbyid

prisma/schema.prisma

@@ -554,20 +554,6 @@ model Frequencies {
   @@schema("mst")
 }
 
-model NavigationModes {
-  id                      Int                       @id @default(autoincrement())
-  navigationModeName      String                    @unique @map("navigation_mode_name") @db.VarChar(30)
-  navigationModeIcon      String                    @map("navigation_mode_icon") @db.VarChar(500)
-  isActive                Boolean                   @default(true) @map("is_active")
-  createdAt               DateTime                  @default(now()) @map("created_at")
-  updatedAt               DateTime                  @updatedAt @map("updated_at")
-  deletedAt               DateTime?                 @map("deleted_at")
-  ActivityNavigationModes ActivityNavigationModes[]
-
-  @@map("navigation_modes")
-  @@schema("mst")
-}
-
 model TransportModes {
   id                      Int                       @id @default(autoincrement())
   transportModeName       String                    @unique @map("transport_mode_name") @db.VarChar(60)
@@ -1456,8 +1442,7 @@ model ActivityNavigationModes {
   id                           Int                            @id @default(autoincrement())
   activityXid                  Int                            @map("activity_xid")
   activity                     Activities                     @relation(fields: [activityXid], references: [id], onDelete: Cascade)
-  navigationModeXid            Int                            @map("navigation_mode_xid")
-  navigationMode               NavigationModes                @relation(fields: [navigationModeXid], references: [id], onDelete: Restrict)
+  navigationModeName           String                         @map("navigation_mode_name") @db.VarChar(30)
   isInActivityChargeable       Boolean                        @default(false) @map("is_in_activity_chargeable")
   navigationModesBasePrice     Int                            @map("navigation_modes_base_price")
   navigationModesTotalPrice    Int                            @map("navigation_modes_total_price")
@@ -1637,8 +1622,8 @@ model Cancellations {
   scheduleHeaderXid  Int            @map("schedule_header_xid")
   scheduleHeader     ScheduleHeader @relation(fields: [scheduleHeaderXid], references: [id], onDelete: Cascade)
   occurenceDate      DateTime?      @map("occurence_date")
-  startTime          String?         @map("start_time") @db.VarChar(30)
-  endTime            String?         @map("end_time") @db.VarChar(30)
+  startTime          String?        @map("start_time") @db.VarChar(30)
+  endTime            String?        @map("end_time") @db.VarChar(30)
   cancellationReason String?        @map("cancellation_reason")
   isActive           Boolean        @default(true) @map("is_active")
   createdAt          DateTime       @default(now()) @map("created_at")

serverless/functions/host.yml

@@ -258,6 +258,22 @@ acceptAggrement:
         path: /host/Host_Admin/onboarding/accept-agreement
         method: patch
 
+getLatestAgreement:
+  handler: src/modules/host/handlers/Host_Admin/onboarding/getLatestAgreement.handler
+  memorySize: 384
+  package:
+    patterns:
+      - 'src/modules/host/handlers/Host_Admin/onboarding/getLatestAgreement.*'
+      - 'src/modules/host/services/**'
+      - ${file(./serverless/patterns/base.yml):pattern1}
+      - ${file(./serverless/patterns/base.yml):pattern2}
+      - ${file(./serverless/patterns/base.yml):pattern3}
+      - ${file(./serverless/patterns/base.yml):pattern4}
+  events:
+    - httpApi:
+        path: /host/Host_Admin/onboarding/get-latest-agreement
+        method: get
+
 getStepperInfo:
   handler: src/modules/host/handlers/getStepper.handler
   memorySize: 384

serverless/functions/user.yml

@@ -346,4 +346,19 @@ getNearbyActivities:
   events:
     - httpApi:
         path: /user/activities/get-nearby-activities
-        method: get
+        method: get
+
+addActivityToBucketInterested:
+  handler: src/modules/user/handlers/activities/addToBucketInterested.handler
+  memorySize: 384
+  package:
+    patterns:
+      - 'src/modules/user/handlers/activities/**'
+      - ${file(./serverless/patterns/base.yml):pattern1}
+      - ${file(./serverless/patterns/base.yml):pattern2}
+      - ${file(./serverless/patterns/base.yml):pattern3}
+      - ${file(./serverless/patterns/base.yml):pattern4}
+  events:
+    - httpApi:
+        path: /user/activities/add-to-bucket-interested
+        method: post

src/modules/host/dto/createActivity.schema.ts

@@ -54,7 +54,7 @@ export const EquipmentDto = z.object({
 
 /* ================= NAVIGATION MODE ================= */
 export const NavigationModeDto = z.object({
-  navigationModeXid: z.number().int(),
+  navigationModeName: z.string().optional(),
   isChargeable: z.boolean().optional(),
   totalPrice: z.number().int().optional().default(0),
 });

src/modules/host/handlers/Host_Admin/onboarding/getLatestAgreement.ts

@@ -0,0 +1,54 @@
+import { verifyMinglarAdminHostToken } from '../../../../../common/middlewares/jwt/authForMinglarAdminHost';
+import { APIGatewayProxyEvent, APIGatewayProxyResult, Context } from 'aws-lambda';
+import { prismaClient } from '../../../../../common/database/prisma.lambda.service';
+import { safeHandler } from '../../../../../common/utils/handlers/safeHandler';
+import ApiError from '../../../../../common/utils/helper/ApiError';
+import { HostService } from '../../../services/host.service';
+
+const hostService = new HostService(prismaClient);
+
+/**
+ * Get latest active agreement for a specific host by hostXid.
+ * Accessible for Minglar Admin / Host Admin using admin-host token.
+ */
+export const handler = safeHandler(async (
+  event: APIGatewayProxyEvent,
+  context?: Context,
+): Promise<APIGatewayProxyResult> => {
+  const token = event.headers['x-auth-token'] || event.headers['X-Auth-Token'];
+  if (!token) {
+    throw new ApiError(400, 'This is a protected route. Please provide a valid token.');
+  }
+
+  // Validate admin/host admin token
+  await verifyMinglarAdminHostToken(token);
+
+  const hostXidParam =
+    event.queryStringParameters?.hostXid ?? event.queryStringParameters?.host_xid;
+
+  const hostXid = Number(hostXidParam);
+
+  if (!hostXidParam) {
+    throw new ApiError(400, 'hostXid is required');
+  }
+
+  if (Number.isNaN(hostXid)) {
+    throw new ApiError(400, 'Invalid hostXid format');
+  }
+
+  const agreement = await hostService.getLatestHostAgreement(hostXid);
+
+  return {
+    statusCode: 200,
+    headers: {
+      'Content-Type': 'application/json',
+      'Access-Control-Allow-Origin': '*',
+    },
+    body: JSON.stringify({
+      success: true,
+      message: 'Latest host agreement retrieved successfully',
+      data: agreement,
+    }),
+  };
+});
+

src/modules/host/handlers/getStepper.ts

@@ -39,6 +39,7 @@ export const handler = safeHandler(async (
       data: {
         stepper: host?.host?.stepper || null,
         emailAddress: host.user?.emailAddress || null,
+        hostId: host.user?.userRefNumber || null,
       },
     }),
   };

src/modules/host/services/host.service.ts

@@ -415,8 +415,8 @@ export class HostService {
     });
 
     const user = await this.prisma.user.findUnique({
-      where: { id: user_xid },
-      select: { id: true, emailAddress: true },
+      where: { id: user_xid, isActive: true },
+      select: { id: true, emailAddress: true, userRefNumber: true },
     });
     return { host, user };
   }
@@ -970,6 +970,47 @@ export class HostService {
     });
   }
 
+  /**
+   * Get the latest (active) agreement for a specific host by hostXid.
+   */
+  async getLatestHostAgreement(hostXid: number) {
+    if (!hostXid || Number.isNaN(hostXid)) {
+      throw new ApiError(400, 'Valid hostXid is required');
+    }
+
+    const agreement = await this.prisma.hostAgreement.findFirst({
+      where: { hostXid, isActive: true },
+      orderBy: { createdAt: 'desc' },
+      select: {
+        id: true,
+        hostXid: true,
+        filePath: true,
+        versionNumber: true,
+        createdAt: true,
+        updatedAt: true,
+      },
+    });
+
+    if (!agreement) {
+      throw new ApiError(404, 'No active agreement found for this host');
+    }
+
+    const filePath = agreement.filePath;
+
+    // If full URL is saved, extract only S3 key part
+    const key = filePath.startsWith('http')
+      ? filePath.split('.com/')[1]
+      : filePath;
+
+    const bucket = config.aws.bucketName;
+    const presignedUrl = await getPresignedUrl(bucket, key);
+
+    return {
+      ...agreement,
+      presignedUrl,
+    };
+  }
+
   async getPQQQuestionDetail(question_xid: number, activity_xid: number) {
     const detailsOfQuestion = await this.prisma.activityPQQheader.findFirst({
       where: {
@@ -2374,15 +2415,9 @@ export class HostService {
           },
           select: {
             id: true,
+            navigationModeName: true,
             isInActivityChargeable: true,
             navigationModesTotalPrice: true,
-            navigationMode: {
-              select: {
-                id: true,
-                navigationModeName: true,
-                navigationModeIcon: true,
-              },
-            },
           },
         },
         equipmentAvailable: true,
@@ -3706,7 +3741,7 @@ export class HostService {
           const navMode = await tx.activityNavigationModes.create({
             data: {
               activityXid,
-              navigationModeXid: mode.navigationModeXid,
+              navigationModeName: mode.navigationModeName,
               isInActivityChargeable: isChargeable,
               navigationModesBasePrice: basePrice,
               navigationModesTotalPrice: totalPrice,

src/modules/prepopulate/handlers/getCityByState.ts

@@ -27,15 +27,21 @@ export const handler = safeHandler(async (
     // 2) Authenticate user
     await verifyMinglarAdminHostToken(token);
 
-    // 3) Get bankXid from query params
+    // 3) Get stateXid and optional search term from query params
     const stateXid = Number(event.queryStringParameters?.stateXid);
+    const search = event.queryStringParameters?.search?.trim();
 
     if (!stateXid || isNaN(stateXid)) {
         throw new ApiError(400, "Valid stateXid is required in query params.");
     }
 
-    // 4) Fetch branches for the bank
-    const branches = await prePopulateService.getCityByStateId(stateXid);
+    // If search is provided, enforce minimum 3 characters
+    if (search && search.length < 3) {
+        throw new ApiError(400, "Search term must be at least 3 characters long.");
+    }
+
+    // 4) Fetch cities for the state (optionally filtered by search)
+    const branches = await prePopulateService.getCityByStateId(stateXid, search);
 
     return {
         statusCode: 200,

src/modules/prepopulate/services/prepopulate.service.ts

@@ -39,12 +39,20 @@ export class PrePopulateService {
   }
 
 
-  async getCityByStateId(stateXid: number) {
+  async getCityByStateId(stateXid: number, search?: string) {
     return await this.prisma.cities.findMany({
       where: {
         stateXid,
         isActive: true,
-        deletedAt: null
+        deletedAt: null,
+        ...(search && search.length >= 3
+          ? {
+            cityName: {
+              contains: search,
+              mode: 'insensitive',
+            },
+          }
+          : {}),
       },
       select: {
         id: true,
@@ -153,7 +161,6 @@ export class PrePopulateService {
       foodType,
       cuisineDetails,
       vehicleType,
-      navigationMode,
       taxDetails,
       energyLevel,
       aminitiesDetails,
@@ -171,9 +178,6 @@ export class PrePopulateService {
         this.prisma.transportModes.findMany({
           where: { isActive: true },
         }),
-        this.prisma.navigationModes.findMany({
-          where: { isActive: true },
-        }),
         this.prisma.taxes.findMany({
           where: { isActive: true },
         }),
@@ -215,7 +219,6 @@ export class PrePopulateService {
       foodType,
       cuisineDetails,
       vehicleType,
-      navigationMode,
       taxDetails,
       energyLevel,
       aminitiesDetails,

src/modules/user/handlers/activities/addToBucketInterested.ts

@@ -0,0 +1,72 @@
+import { APIGatewayProxyEvent, APIGatewayProxyResult, Context } from 'aws-lambda';
+import { prismaClient } from '../../../../common/database/prisma.lambda.service';
+import { verifyUserToken } from '../../../../common/middlewares/jwt/authForUser';
+import { safeHandler } from '../../../../common/utils/handlers/safeHandler';
+import ApiError from '../../../../common/utils/helper/ApiError';
+import { UserService } from '../../services/user.service';
+
+const userService = new UserService(prismaClient);
+
+export const handler = safeHandler(async (
+    event: APIGatewayProxyEvent,
+    context?: Context
+): Promise<APIGatewayProxyResult> => {
+    // Extract token from headers
+    const token = event.headers['x-auth-token'] || event.headers['X-Auth-Token']
+    if (!token) {
+        throw new ApiError(400, 'This is a protected route. Please provide a valid token.');
+    }
+
+    // Authenticate user using verifyUserToken
+    const userInfo = await verifyUserToken(token);
+    const userId = userInfo.id;
+
+    if (Number.isNaN(userId)) {
+        throw new ApiError(400, 'User id must be a number');
+    }
+
+    const user = await userService.getUserById(userId);
+    if (!user) {
+        throw new ApiError(404, 'User not found');
+    }
+
+    // Parse request body
+    let body: { activityXid: number; isBucket: boolean; bucketTypeName: string; };
+
+    try {
+        body = event.body ? JSON.parse(event.body) : {};
+    } catch (error) {
+        throw new ApiError(400, 'Invalid JSON in request body');
+    }
+
+    const { activityXid, isBucket, bucketTypeName } = body;
+
+    // Validate required fields
+    if (
+        typeof activityXid !== 'number' ||
+        typeof isBucket !== 'boolean' ||
+        !bucketTypeName
+    ) {
+        throw new ApiError(400, 'Required fields missing or invalid');
+    }
+
+
+    // Set the passcode
+    const counts = await userService.addToBucketInterested(userId, isBucket, bucketTypeName, activityXid);
+
+    return {
+        statusCode: 200,
+        headers: {
+            'Content-Type': 'application/json',
+            'Access-Control-Allow-Origin': '*',
+        },
+        body: JSON.stringify({
+            success: true,
+            message: `Activity added to ${isBucket ? 'bucket' : 'interested'} successfully`,
+            data: {
+                bucketCount: counts.bucketCount,
+                interestedCount: counts.interestedCount,
+            }
+        }),
+    };
+});

src/modules/user/services/user.service.ts

@@ -709,6 +709,29 @@ export class UserService {
         };
       }
 
+      const userBucketInterested = await tx.userBucketInterested.findMany({
+        where: {
+          userXid: userId,
+          isActive: true,
+        },
+        select: {
+          activityXid: true,
+          isBucket: true,
+        },
+      });
+
+      const userBucketActivityIds = userBucketInterested
+        .filter(u => u.isBucket)
+        .map(u => u.activityXid);
+
+      const userInterestedActivityIds = userBucketInterested
+        .filter(u => !u.isBucket)
+        .map(u => u.activityXid);
+
+      const allUserExcludedActivityIds = userBucketInterested.map(
+        u => u.activityXid,
+      );
+
       const userConnectionDetails = await tx.connectDetails.findMany({
         where: { userXid: userId, isActive: true },
         select: {
@@ -762,6 +785,11 @@ export class UserService {
           activityTypeXid: {
             in: activitiyTypesOfUserInterests.map((at) => at.id),
           },
+          id: {
+            notIn: allUserExcludedActivityIds.length
+              ? allUserExcludedActivityIds
+              : [-1], // prevent empty notIn issue
+          },
         },
         skip,
         take: limit,
@@ -842,7 +870,12 @@ export class UserService {
       // IF user wants the standard 4-step ranking applied TO the most hyped items:
       const mostHypedActivitiesRaw = await tx.activities.findMany({
         where: {
-          id: { in: mostHypedActivityIds },
+          id: {
+            in: mostHypedActivityIds,
+            notIn: allUserExcludedActivityIds.length
+              ? allUserExcludedActivityIds
+              : [-1],
+          },
           isActive: true,
           activityInternalStatus: ACTIVITY_INTERNAL_STATUS.ACTIVITY_LISTED,
           amInternalStatus: ACTIVITY_AM_INTERNAL_STATUS.ACTIVITY_LISTED,
@@ -966,6 +999,11 @@ export class UserService {
         isActive: true,
         activityInternalStatus: ACTIVITY_INTERNAL_STATUS.ACTIVITY_LISTED,
         amInternalStatus: ACTIVITY_AM_INTERNAL_STATUS.ACTIVITY_LISTED,
+        id: {
+          notIn: allUserExcludedActivityIds.length
+            ? allUserExcludedActivityIds
+            : [-1], // prevent empty notIn issue
+        },
         createdAt: { gte: new Date(Date.now() - 31 * 24 * 60 * 60 * 1000) },
       };
 
@@ -984,6 +1022,11 @@ export class UserService {
         isActive: true,
         activityInternalStatus: ACTIVITY_INTERNAL_STATUS.ACTIVITY_LISTED,
         amInternalStatus: ACTIVITY_AM_INTERNAL_STATUS.ACTIVITY_LISTED,
+        id: {
+          notIn: allUserExcludedActivityIds.length
+            ? allUserExcludedActivityIds
+            : [-1], // prevent empty notIn issue
+        },
       };
 
       if (effectiveCountryXid) {
@@ -1010,6 +1053,11 @@ export class UserService {
           activityInternalStatus: ACTIVITY_INTERNAL_STATUS.ACTIVITY_LISTED,
           amInternalStatus: ACTIVITY_AM_INTERNAL_STATUS.ACTIVITY_LISTED,
           deletedAt: null,
+          id: {
+            notIn: allUserExcludedActivityIds.length
+              ? allUserExcludedActivityIds
+              : [-1], // prevent empty notIn issue
+          },
         },
       });
 
@@ -1034,6 +1082,11 @@ export class UserService {
                 amInternalStatus:
                   ACTIVITY_AM_INTERNAL_STATUS.ACTIVITY_LISTED,
                 deletedAt: null,
+                id: {
+                  notIn: allUserExcludedActivityIds.length
+                    ? allUserExcludedActivityIds
+                    : [-1], // prevent empty notIn issue
+                },
               },
               select: {
                 id: true,
@@ -1076,6 +1129,11 @@ export class UserService {
         isActive: true,
         activityInternalStatus: ACTIVITY_INTERNAL_STATUS.ACTIVITY_LISTED,
         amInternalStatus: ACTIVITY_AM_INTERNAL_STATUS.ACTIVITY_LISTED,
+        id: {
+          notIn: allUserExcludedActivityIds.length
+            ? allUserExcludedActivityIds
+            : [-1], // prevent empty notIn issue
+        },
       };
 
       if (effectiveCountryXid) {
@@ -1152,6 +1210,8 @@ export class UserService {
         loggedInNetworkCount: 0,
         citiesInNetworkCount: 0,
         rating: 0,
+        interestedCount: userInterestedActivityIds.length,
+        bucketCount: userBucketActivityIds.length,
         pagination: {
           page,
           limit,
@@ -1237,6 +1297,32 @@ export class UserService {
 
       const skip = (page - 1) * limit;
 
+      const userBucketInterested = await tx.userBucketInterested.findMany({
+        where: {
+          userXid: userId,
+          isActive: true,
+        },
+        select: {
+          activityXid: true,
+          isBucket: true,
+        },
+      });
+
+      const bucketActivityIds = userBucketInterested
+        .filter(u => u.isBucket)
+        .map(u => u.activityXid);
+
+      const interestedActivityIds = userBucketInterested
+        .filter(u => !u.isBucket)
+        .map(u => u.activityXid);
+
+      const excludedActivityIds = userBucketInterested.map(
+        u => u.activityXid,
+      );
+
+      const safeExcludedIds =
+        excludedActivityIds.length > 0 ? excludedActivityIds : [-1];
+
       /* =====================================================
      CONNECTION INTEREST MAP
 ===================================================== */
@@ -1270,7 +1356,6 @@ export class UserService {
           where: {
             userXid: { in: connectionUserIds },
             isActive: true,
-            isBucket: true,
           },
           _count: { activityXid: true },
         });
@@ -1302,6 +1387,9 @@ export class UserService {
       const otherInterestActivities = await tx.activities.findMany({
         where: {
           isActive: true,
+          activityInternalStatus: ACTIVITY_INTERNAL_STATUS.ACTIVITY_LISTED,
+          amInternalStatus: ACTIVITY_AM_INTERNAL_STATUS.ACTIVITY_LISTED,
+          id: { notIn: safeExcludedIds },
           ...excludeUserInterestCondition,
         },
         skip,
@@ -1388,7 +1476,16 @@ export class UserService {
       ).length;
 
       const hypedActivities = await tx.activities.findMany({
-        where: { id: { in: mostHypedGrouped.map((h) => h.activityXid) } },
+        where: {
+          id: {
+            in: mostHypedGrouped.map((h) => h.activityXid),
+            notIn: safeExcludedIds,
+          },
+          activityInternalStatus: ACTIVITY_INTERNAL_STATUS.ACTIVITY_LISTED,
+          amInternalStatus: ACTIVITY_AM_INTERNAL_STATUS.ACTIVITY_LISTED,
+          isActive: true,
+
+        },
         select: {
           id: true,
           activityTitle: true,
@@ -1427,7 +1524,10 @@ export class UserService {
                5️⃣ NEW ARRIVALS
             ===================================================== */
       const newArrivalsWhere = {
+        id: { notIn: safeExcludedIds },
         isActive: true,
+        activityInternalStatus: ACTIVITY_INTERNAL_STATUS.ACTIVITY_LISTED,
+        amInternalStatus: ACTIVITY_AM_INTERNAL_STATUS.ACTIVITY_LISTED,
         createdAt: { gte: new Date(Date.now() - 31 * 24 * 60 * 60 * 1000) },
         ...excludeUserInterestCondition,
       };
@@ -1457,6 +1557,9 @@ export class UserService {
             ===================================================== */
       const otherStatesWhere: any = {
         isActive: true,
+        id: { notIn: safeExcludedIds },
+        activityInternalStatus: ACTIVITY_INTERNAL_STATUS.ACTIVITY_LISTED,
+        amInternalStatus: ACTIVITY_AM_INTERNAL_STATUS.ACTIVITY_LISTED,
         ...excludeUserInterestCondition,
       };
       if (effectiveCountryXid)
@@ -1466,6 +1569,9 @@ export class UserService {
 
       const overseasWhere: any = {
         isActive: true,
+        id: { notIn: safeExcludedIds },
+        activityInternalStatus: ACTIVITY_INTERNAL_STATUS.ACTIVITY_LISTED,
+        amInternalStatus: ACTIVITY_AM_INTERNAL_STATUS.ACTIVITY_LISTED,
         ...excludeUserInterestCondition,
       };
       if (effectiveCountryXid)
@@ -1513,6 +1619,8 @@ export class UserService {
       return {
         pagination: { page, limit },
         interests: interestsWithActivities,
+        interestedCount: interestedActivityIds.length,
+        bucketCount: bucketActivityIds.length,
 
         mostHypedActivities: {
           page,
@@ -1743,14 +1851,7 @@ export class UserService {
             where: { isActive: true },
             select: {
               id: true,
-              navigationModeXid: true,
-              navigationMode: {
-                select: {
-                  id: true,
-                  navigationModeName: true,
-                  navigationModeIcon: true,
-                },
-              },
+              navigationModeName: true,
               isInActivityChargeable: true,
               navigationModesTotalPrice: true,
             },
@@ -1951,13 +2052,6 @@ export class UserService {
 
       const connectionUserIds = connectionUsers.map((u) => u.userXid);
 
-      const interestedCount = await tx.userBucketInterested.count({
-        where: {
-          activityXid,
-          isBucket: false,
-          isActive: true,
-        },
-      });
 
       const connectionInterestedCount = connectionUserIds.length
         ? await tx.userBucketInterested.count({
@@ -1979,6 +2073,50 @@ export class UserService {
         (v) => v.venueCapacity ?? 0,
       ).reduce((sum, capacity) => sum + capacity, 0);
 
+      const interestedCount = await tx.userBucketInterested.count({
+        where: {
+          activityXid,
+          isBucket: false,
+          isActive: true,
+        },
+      });
+
+      const interestedUsers = await tx.userBucketInterested.findMany({
+        where: {
+          activityXid,
+          isBucket: false,
+          isActive: true,
+          user: {
+            isActive: true,
+          },
+        },
+        select: {
+          user: {
+            select: {
+              profileImage: true,
+            },
+          },
+        },
+      });
+
+      const shuffledUsers = interestedUsers.sort(() => 0.5 - Math.random());
+      const randomFive = shuffledUsers.slice(0, 5);
+
+      const interestedUserImages: string[] = [];
+
+      for (const item of randomFive) {
+        const profileImage = item.user.profileImage;
+
+        if (profileImage) {
+          const key = profileImage.startsWith('http')
+            ? new URL(profileImage).pathname.replace(/^\/+/, '')
+            : profileImage;
+
+          const presignedUrl = await getPresignedUrl(bucket, key);
+          interestedUserImages.push(presignedUrl);
+        }
+      }
+
       return {
         activity,
         interestedCount,
@@ -1987,6 +2125,7 @@ export class UserService {
         totalCapacity,
         rating: 0, // ⭐ Placeholder, implement rating logic as needed
         distance: 0,
+        interestedUserImages
       };
     });
   }
@@ -3500,4 +3639,59 @@ export class UserService {
     });
   }
 
+  async addToBucketInterested(
+    userXid: number,
+    isBucket: boolean,
+    bucketTypeName: string,
+    activityXid: number
+  ) {
+    const activityExists = await this.prisma.activities.findFirst({
+      where: { id: activityXid, isActive: true },
+    });
+
+    if (!activityExists) {
+      throw new ApiError(404, 'Activity not found');
+    }
+
+    const existing = await this.prisma.userBucketInterested.findFirst({
+      where: { userXid, activityXid },
+    });
+
+    if (existing) {
+      throw new ApiError(400, 'Activity already added');
+    }
+
+    await this.prisma.userBucketInterested.create({
+      data: {
+        userXid,
+        activityXid,
+        isBucket,
+        bucketTypeName,
+      },
+    });
+
+    // ✅ Get updated counts
+    const [bucketCount, interestedCount] = await Promise.all([
+      this.prisma.userBucketInterested.count({
+        where: {
+          userXid,
+          isBucket: true,
+          isActive: true,
+        },
+      }),
+      this.prisma.userBucketInterested.count({
+        where: {
+          userXid,
+          isBucket: false,
+          isActive: true,
+        },
+      }),
+    ]);
+
+    return {
+      bucketCount,
+      interestedCount,
+    };
+  }
+
 }