Merge pull request #17 from Xitija/main

PS-1588 : Minor fixes , Code Cleanup and Refactor for response body

src/common/utils/transformer/date.transformer.ts

@@ -1,3 +1,4 @@
+import { BadRequestException } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { getTimezoneDateString } from 'src/common/utils/pipe.util';
 import { ValueTransformer } from 'typeorm';
@@ -16,6 +17,17 @@ export class TimeZoneTransformer implements ValueTransformer {
   // From DB: Convert the date from UTC to the desired time zone after fetching
   from(databaseValue: Date): string {
     if (!databaseValue) return databaseValue.toISOString();
+    if (
+      !(
+        this.configService.get<number>('TIMEZONE_OFFSET') &&
+        this.configService.get<string>('TIMEZONE') &&
+        this.configService.get<string>('TIMEZONE_OFFSET_STRING')
+      )
+    ) {
+      const errmsg =
+        'TIMEZONE_OFFSET, TIMEZONE and TIMEZONE_OFFSET_STRING unavailable';
+      throw new BadRequestException(errmsg);
+    }
     return getTimezoneDateString(
       this.configService.get<number>('TIMEZONE_OFFSET'),
       this.configService.get<string>('TIMEZONE'),

src/common/utils/types.ts

@@ -16,6 +16,23 @@ export enum Frequency {
   yearly = 'yearly',
 }
 
+export type RepetitionDetail = {
+  onlineDetails:
+    | {
+        id: string;
+        url: string;
+        password: string;
+        occurenceId: string;
+        providerGenerated: boolean;
+      }
+    | {}
+    | null;
+  metadata: any;
+  eventRepetitionId: string;
+  startDateTime: Date;
+  endDateTime: Date;
+};
+
 export type MeetingDetails = {
   id: string;
   url: string;

src/modules/event/dto/create-event.dto.ts

@@ -288,6 +288,7 @@ export class CreateEventDto {
   })
   @IsInt()
   @Min(0)
+  @IsOptional()
   maxAttendees: number;
 
   @ApiProperty({
@@ -306,6 +307,7 @@ export class CreateEventDto {
   @Type(() => String)
   @ArrayMaxSize(200)
   @IsUUID('4', { each: true })
+  @IsOptional()
   attendees: string[];
 
   @ApiProperty({
@@ -314,6 +316,7 @@ export class CreateEventDto {
     example: { url: 'https://example.com/recording' },
   })
   @IsObject()
+  @IsOptional()
   recordings: any;
 
   @ApiProperty({
@@ -348,6 +351,7 @@ export class CreateEventDto {
     description: 'idealTime',
     example: 120,
   })
+  @IsOptional()
   idealTime: number;
 
   @ApiProperty({

src/modules/event/event.controller.ts

@@ -70,10 +70,7 @@ export class EventController {
     @Body() createEventDto: CreateEventDto,
     @Res() response: Response,
   ) {
-    const userId = '016badad-22b0-4566-88e9-aab1b35b1dfc'; // later come from JWT-token
-    this.configService;
-    console.log('createEventDtocontr', createEventDto);
-    return this.eventService.createEvent(createEventDto, userId, response);
+    return this.eventService.createEvent(createEventDto, response);
   }
 
   @UseFilters(new AllExceptionsFilter(API_ID.GET_EVENTS))

src/modules/event/event.service.ts

@@ -21,9 +21,10 @@ import {
   DaysOfWeek,
   EventTypes,
   RecurrencePattern,
+  RepetitionDetail,
 } from 'src/common/utils/types';
 import { ConfigService } from '@nestjs/config';
-import { DeleteResult } from 'typeorm';
+import { DeleteResult, InsertResult } from 'typeorm';
 @Injectable()
 export class EventService {
   private eventCreationLimit: number;
@@ -45,7 +46,6 @@ export class EventService {
 
   async createEvent(
     createEventDto: CreateEventDto,
-    userId: string,
     response: Response,
   ): Promise<Response> {
     const apiId = 'api.create.event';
@@ -56,13 +56,6 @@ export class EventService {
       if (createEventDto.isRestricted === true) {
         // private event
         createdEvent = await this.createOfflineOrOnlineEvent(createEventDto);
-        // if (createEventDto.eventType === 'online') {
-        //   // create online event
-        //   createdEvent = await this.createOnlineEvent(createEventDto);
-        // } else if (createEventDto.eventType === 'offline') {
-        //   // create offline event
-        //   createdEvent = await this.createOfflineEvent(createEventDto);
-        // }
 
         // if event is private then invitees are required
         // add invitees to attendees table
@@ -240,8 +233,6 @@ export class EventService {
     return finalquery;
   }
 
-  async createEvents(createEventDto, response) {}
-
   async createEventDetailDB(
     createEventDto: CreateEventDto,
   ): Promise<EventDetail> {
@@ -255,17 +246,17 @@ export class EventService {
     eventDetail.longitude = createEventDto.longitude;
     eventDetail.latitude = createEventDto.latitude;
     eventDetail.onlineProvider = createEventDto.onlineProvider;
-    eventDetail.maxAttendees = createEventDto.maxAttendees;
-    eventDetail.recordings = createEventDto.recordings;
+    eventDetail.maxAttendees = createEventDto?.maxAttendees;
+    eventDetail.recordings = createEventDto?.recordings;
     eventDetail.status = createEventDto.status;
-    eventDetail.attendees = createEventDto.attendees.length
+    eventDetail.attendees = createEventDto?.attendees?.length
       ? createEventDto.attendees
       : null;
     eventDetail.meetingDetails = createEventDto.meetingDetails;
-    eventDetail.idealTime = createEventDto.idealTime
+    eventDetail.idealTime = createEventDto?.idealTime
       ? createEventDto.idealTime
       : null;
-    eventDetail.metadata = createEventDto.metaData;
+    eventDetail.metadata = createEventDto?.metaData;
     eventDetail.createdBy = createEventDto.createdBy;
     eventDetail.updatedBy = createEventDto.updatedBy;
     eventDetail.createdAt = new Date();
@@ -357,27 +348,41 @@ export class EventService {
         createEventDto.meetingDetails.occurenceId = '';
       }
 
-      const eventDetail = await this.createEventDetailDB(createEventDto);
+      const createdEventDetailDB =
+        await this.createEventDetailDB(createEventDto);
+
+      const createdEventDB = await this.createEventDB(
+        createEventDto,
+        createdEventDetailDB,
+      );
 
-      const event = await this.createEventDB(createEventDto, eventDetail);
+      let erep: EventRepetition | InsertResult;
 
       if (createEventDto.isRecurring) {
-        const erep = await this.createRecurringEvents(
+        erep = await this.createRecurringEvents(
           createEventDto,
-          event.eventId,
-          eventDetail.eventDetailId,
+          createdEventDB.eventId,
+          createdEventDetailDB.eventDetailId,
         );
 
-        return erep?.generatedMaps;
+        return this.generateEventResponse(
+          createdEventDB,
+          erep?.generatedMaps[0],
+          erep?.generatedMaps.length,
+        );
       } else {
         // this.createNonRecurringEvent(createEventDto);
-        const erep = await this.createEventRepetitionDB(
+        erep = await this.createEventRepetitionDB(
           createEventDto,
-          event,
-          eventDetail,
+          createdEventDB,
+          createdEventDetailDB,
         );
-        return erep;
+        const { event, eventDetail, ...repetitionDtl } = erep;
+
+        return this.generateEventResponse(event, repetitionDtl);
       }
+
+      // generate and return response body
     } catch (error) {
       console.log(error, 'error');
       throw error;
@@ -389,11 +394,6 @@ export class EventService {
     eventId: string,
     eventDetailId: string,
   ) {
-    // const eventOccurrences = this.generateEventOccurrences(createEventDto);
-    // eventOccurrences.forEach((eventOccurrence) => {
-    //   // Save event occurrence
-    //   this.eventOccurrenceRepository.save(eventOccurrence);
-    // });
     const eventOccurences = this.generateEventOccurences(
       createEventDto,
       eventDetailId,
@@ -413,20 +413,42 @@ export class EventService {
       await this.removePartiallyCreatedData(eventId, eventDetailId);
       throw new BadRequestException('Event recurrence period insufficient');
     } else {
-      const insertedOccurences =
-        await this.eventRepetitionRepository.insert(eventOccurences);
+      const insertedOccurences = await this.eventRepetitionRepository
+        .createQueryBuilder()
+        .insert()
+        .into('EventRepetition')
+        .values(eventOccurences)
+        .returning(['onlineDetails'])
+        .execute();
+      // const insertedOccurences =
+      //   await this.eventRepetitionRepository.insert(eventOccurences);
       return insertedOccurences;
     }
   }
 
-  createNonRecurringEvent(createEventDto: CreateEventDto) {}
+  generateEventResponse(
+    event: Events,
+    repetitionDtl: Partial<RepetitionDetail>,
+    createdEventCount: number = 1,
+  ) {
+    const { eventDetail, ...other } = event;
+
+    const repetitionDetail = {};
+    repetitionDetail['eventRepetitionId'] = repetitionDtl.eventRepetitionId;
+    repetitionDetail['startDateTime'] = repetitionDtl.startDateTime;
+    repetitionDetail['endDateTime'] = repetitionDtl.endDateTime;
+    repetitionDetail['onlineDetails'] = repetitionDtl.onlineDetails;
+
+    const response = Object.assign(eventDetail, other, repetitionDetail, {
+      createdEventCount,
+    });
+
+    return response;
+  }
 
   async getEventOccurrences(eventId: string): Promise<EventRepetition[]> {
     return this.eventRepetitionRepository.find({ where: { eventId: eventId } });
   }
-  // async getEventOccurrences(eventId: string): Promise<EventOccurrence[]> {
-  //   return this.eventOccurrenceRepository.find({ where: { event: eventId } });
-  // }
 
   generateEventOccurences(
     createEventDto: CreateEventDto,