tracking code

src/app.module.ts

@@ -4,13 +4,10 @@ import { AppService } from './app.service';
 import { PropertyModule } from './modules/property/property.module';
 import { AuthModule } from './modules/auth/auth.module';
 import { UserModule } from './modules/user/user.module';
+import { ActivityModule } from './modules/activity/activity.module';
 
 @Module({
-  imports: [
-    PropertyModule,
-    AuthModule,
-    UserModule,
-  ],
+  imports: [PropertyModule, AuthModule, UserModule, ActivityModule],
   controllers: [AppController],
   providers: [AppService],
 })

src/constants/collections.constant.ts

@@ -1,2 +1,3 @@
 export const PROPERTIE = 'propertie';
 export const USERS = 'users';
+export const ACTIVITY = 'activity';

src/constants/repository.constant.ts

@@ -1,2 +1,3 @@
 export const PROPERTY_REPOSITORY = 'PROPERTY_REPOSITORY';
 export const USER_REPOSITORY = 'USER_REPOSITORY';
+export const ACTIVITY_REPOSITORY = 'ACTIVITY_REPOSITORY';

src/modules/activity/activity.controller.ts

@@ -0,0 +1,145 @@
+import {
+  Body,
+  Controller,
+  Get,
+  HttpStatus,
+  Patch,
+  Post,
+  Query,
+  Req,
+  Res,
+  UseGuards,
+} from '@nestjs/common';
+import { Response } from 'express';
+import { CommonServices } from '../shared/common.service';
+import { ActivityService } from './activity.service';
+import { JwtAuthGuard } from '../auth/jwt-auth.guard';
+import { PropertyService } from '../property/property.service';
+
+@Controller('activity')
+export class ActivityController extends CommonServices {
+  constructor(
+    private readonly activityService: ActivityService,
+    private readonly propertyService: PropertyService,
+  ) {
+    super();
+  }
+
+  @Post('create')
+  @UseGuards(JwtAuthGuard)
+  async createActivity(@Body() body: any, @Res() res: Response, @Req() req) {
+    try {
+      const payload = {
+        ...body,
+        userId: req.user.userId,
+      };
+      const activity = await this.activityService.sharedCreate(payload);
+
+      // update views
+      if (body.action == 'view')
+        await this.propertyService.sharedFindOneAndUpdate(
+          { _id: body.propertyId },
+          {
+            $inc: { views: 1 }, // Increment views and add duration
+          },
+          {},
+        );
+
+      //update duration/ time spend
+      if (body.action == 'time_spent')
+        await this.propertyService.sharedFindOneAndUpdate(
+          { _id: body.propertyId },
+          {
+            $inc: { total_time_spent: body.duration || 0 }, // Increment views and add duration
+          },
+          {},
+        );
+
+      return this.sendResponse(
+        this.messages.Success,
+        activity,
+        HttpStatus.OK,
+        res,
+      );
+    } catch (error) {
+      console.log(error);
+      return this.sendResponse(
+        'Error',
+        {},
+        HttpStatus.INTERNAL_SERVER_ERROR,
+        res,
+      );
+    }
+  }
+
+  @Get('')
+  async getActivityListings(@Res() res: Response, @Req() req): Promise<any> {
+    try {
+      const response = await this.activityService.sharedFind({});
+      return this.sendResponse(
+        this.messages.Success,
+        response,
+        HttpStatus.OK,
+        res,
+      );
+    } catch (error) {
+      return this.sendResponse(
+        'Internal server Error',
+        {},
+        HttpStatus.INTERNAL_SERVER_ERROR,
+        res,
+      );
+    }
+  }
+
+  // New Update API to modify existing activity
+  @Patch('update')
+  @UseGuards(JwtAuthGuard)
+  async updateActivity(
+    @Body() body: any, // should include { userId, propertyId, action, duration (optional) }
+    @Res() res: Response,
+    @Req() req,
+  ) {
+    try {
+      // Check if the activity exists for the user and property
+      const existingActivity = await this.activityService.sharedFindOne({
+        userId: body.userId,
+        propertyId: body.propertyId,
+        action: body.action, // Example: 'click' or 'view'
+      });
+
+      if (existingActivity) {
+        // If activity exists, update it
+        const updatedActivity = await this.activityService.sharedUpdate(
+          { _id: existingActivity._id },
+          {
+            duration: body.duration ? body.duration : existingActivity.duration,
+            timestamp: new Date(), // update the timestamp to the latest interaction
+          },
+        );
+
+        return this.sendResponse(
+          this.messages.Success,
+          updatedActivity,
+          HttpStatus.OK,
+          res,
+        );
+      } else {
+        // If no activity exists, return a not found response
+        return this.sendResponse(
+          'Activity not found',
+          {},
+          HttpStatus.NOT_FOUND,
+          res,
+        );
+      }
+    } catch (error) {
+      return this.sendResponse(
+        'Internal server Error',
+        {},
+        HttpStatus.INTERNAL_SERVER_ERROR,
+        res,
+      );
+    }
+  }
+}

src/modules/activity/activity.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { DatabaseModule } from '../database/database.module';
+import { ActivityController } from './activity.controller';
+import { ActivityService } from './activity.service';
+import { PropertyService } from '../property/property.service';
+
+@Module({
+  imports: [DatabaseModule],
+  controllers: [ActivityController],
+  providers: [ActivityService, PropertyService],
+  exports: [ActivityService, PropertyService],
+})
+export class ActivityModule {}

src/modules/activity/activity.provider.ts

@@ -0,0 +1,12 @@
+import { Connection } from 'mongoose';
+import { ACTIVITY, ACTIVITY_REPOSITORY } from 'src/constants';
+import { UserActivitySchema } from './activity.schema';
+
+export const activityProviders = [
+  {
+    provide: ACTIVITY_REPOSITORY,
+    useFactory: (connection: Connection) =>
+      connection.model(ACTIVITY, UserActivitySchema),
+    inject: ['DATABASE_CONNECTION'],
+  },
+];

src/modules/activity/activity.schema.ts

@@ -0,0 +1,35 @@
+import * as mongoose from 'mongoose';
+import { Document } from 'mongoose';
+import { IUserDocument } from '../user/user.schema';
+import { IPropertyDocument } from '../property/property.schema';
+
+export interface IUserActivityDocument extends Document {
+  userId: IUserDocument;
+  propertyId: IPropertyDocument;
+  action: string; // E.g., 'click', 'view', 'time_spent'
+  timestamp: Date;
+  duration?: number; // Store time spent in seconds for 'time_spent' action
+}
+
+const UserActivitySchema = new mongoose.Schema<IUserActivityDocument>(
+  {
+    userId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'User',
+      required: true,
+    },
+    propertyId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'propertie',
+      required: true,
+    },
+    action: { type: String, required: true }, // 'click', 'view', 'time_spent'
+    timestamp: { type: Date, default: Date.now },
+    duration: { type: Number }, // Only applicable for 'time_spent'
+  },
+  {
+    toJSON: { versionKey: false },
+  },
+);
+
+export { UserActivitySchema };

src/modules/activity/activity.service.ts

@@ -0,0 +1,23 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { Model, Types } from 'mongoose';
+import { sharedCrudService } from '../shared/sharedCrud.services';
+import { ACTIVITY_REPOSITORY } from 'src/constants';
+import { IUserActivityDocument } from './activity.schema';
+
+@Injectable()
+export class ActivityService extends sharedCrudService {
+  constructor(
+    @Inject(ACTIVITY_REPOSITORY)
+    readonly activityRepository: Model<IUserActivityDocument>,
+  ) {
+    super(activityRepository);
+  }
+
+  async activityLisitng(
+    page: number,
+    resPerPage: number,
+    search: string,
+  ): Promise<any> {
+    return 'Hello from Activity service.'
+  }
+}

src/modules/database/database.module.ts

@@ -2,9 +2,20 @@ import { Module } from '@nestjs/common';
 import { databaseProviders } from './database.provider';
 import { propertyProviders } from '../property/property.provider';
 import { usersProviders } from '../user/user.provider';
+import { activityProviders } from '../activity/activity.provider';
 
 @Module({
-  providers: [...databaseProviders, ...propertyProviders, ...usersProviders],
-  exports: [...databaseProviders, ...propertyProviders, ...usersProviders],
+  providers: [
+    ...databaseProviders,
+    ...propertyProviders,
+    ...usersProviders,
+    ...activityProviders,
+  ],
+  exports: [
+    ...databaseProviders,
+    ...propertyProviders,
+    ...usersProviders,
+    ...activityProviders,
+  ],
 })
 export class DatabaseModule {}

src/modules/property/property.schema.ts

@@ -10,6 +10,8 @@ export interface IPropertyDocument extends Document {
   features?: object;
   thumbnail_summary?: string;
   listing_url?: string;
+  views?: number; // Track the number of views
+  total_time_spent?: number; // Track total time spent on the property in seconds
   createdAt?: Date;
   updatedAt?: Date;
 }
@@ -23,6 +25,8 @@ const PropertySchema = new mongoose.Schema<IPropertyDocument>(
     features: { type: Object },
     listing_url: { type: String },
     imgs: [],
+    views: { type: Number, default: 0 }, // New field to store the number of views
+    total_time_spent: { type: Number, default: 0 }, // New field to store total time spent in seconds
     createdAt: { type: Date, default: Date.now },
     updatedAt: { type: Date, default: Date.now },
   },