Cricket Service and API

src/app.module.ts

@@ -21,6 +21,7 @@ import { TeamModule } from './services/apis/team/team.module';
 import { TeamPlayerModule } from './services/apis/teamPlayer/teamPlayer.module';
 import { GenerateOtpModule } from './services/apis/otp/generateOtp.module';
 import { MailerModule } from './services/apis/mailer/mailer.module';
+import { CricketModule } from './services/apis/cricket/cricket.module';
 
 @Module({
   imports: [
@@ -33,7 +34,7 @@ import { MailerModule } from './services/apis/mailer/mailer.module';
       connection: {
         host: process.env.REDIS_HOST,
         port: parseInt(process.env.REDIS_PORT),
-        password: process.env.REDIS_PASSWORD,
+        //password: process.env.REDIS_PASSWORD,
       },
     }),
     QueueModule,
@@ -57,6 +58,7 @@ import { MailerModule } from './services/apis/mailer/mailer.module';
     ReactionsModule,
     GenerateOtpModule,
     MailerModule,
+    CricketModule,
   ],
   controllers: [AppController],
   providers: [

src/services/apis/auth/auth.guard.ts

@@ -30,16 +30,19 @@ export class AuthGuard implements CanActivate {
     }
     const request = context.switchToHttp().getRequest();
     const token = this.extractTokenFromHeader(request);
+    console.log('token', token);
     if (!token) {
       throw new UnauthorizedException();
     }
     try {
       const payload = await this.jwtService.verifyAsync(token, {
         secret: jwtConstants.secret,
       });
+      console.log({ payload });
       const user = await this.usersService._get(payload.sub.id);
       // 💡 We're assigning the payload to the request object here
       // so that we can access it in our route handlers
+      console.log({ user });
       if (user) {
         request['user'] = user;
         return true;

src/services/apis/cricket/cricket.controller.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { CricketController } from './cricket.controller';
+
+describe('CricketController', () => {
+  let controller: CricketController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [CricketController],
+    }).compile();
+
+    controller = module.get<CricketController>(CricketController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

src/services/apis/cricket/cricket.controller.ts

@@ -0,0 +1,114 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  Patch,
+  Post,
+  Query,
+  UseGuards,
+} from '@nestjs/common';
+import { CricketService } from './cricket.service';
+import { ModifyBody, setCreatedBy } from 'src/decorators/ModifyBody.decorator';
+import { User } from '../users/decorator/user.decorator';
+import { CricketState } from './schemas/cricket.schema';
+import { CricketEvent } from './schemas/cricket.event.schema';
+import { Public } from '../auth/decorators/public.decorator';
+import {
+  updateCricketEeventDTO,
+  updateCricketEeventDTOType,
+} from './dto/cricket.event.dto';
+
+@Controller('cricket')
+export class CricketController {
+  constructor(private readonly cricketService: CricketService) {}
+
+  @Get()
+  async find(@Query() query: Record<string, any>) {
+    return await this.cricketService._find(query);
+  }
+
+  @Get('/:id?')
+  async get(@Query() query: Record<string, any>, @Param('id') id: string) {
+    return await this.cricketService._get(id, query);
+  }
+
+  @Post()
+  async create(@ModifyBody(setCreatedBy()) createCricketDto: CricketState) {
+    return await this.cricketService._create(createCricketDto);
+  }
+
+  @Post('/:matchid/event')
+  async createEvent(
+    @ModifyBody(setCreatedBy()) createCricketEventDTO: CricketEvent,
+    @Param('matchid') matchid: string,
+  ) {
+    const event = await this.cricketService.createEvent(
+      matchid,
+      createCricketEventDTO,
+    );
+    return event;
+  }
+
+  @Public()
+  @Get('/:matchid/event')
+  async getPreviousatestEvent(
+    @Query('id') prevEventID: string,
+    @Param('matchid') matchid: string,
+  ) {
+    const prevLatestEvent = await this.cricketService.getPreviousatestEvent(
+      matchid,
+      prevEventID,
+    );
+    return prevLatestEvent;
+  }
+
+  @Public()
+  @Get('/:matchid/event-series')
+  async getPreviousLatestEventSeries(
+    @Query('id') prevEventId: string,
+    @Param('matchid') matchid: string,
+  ) {
+    return await this.cricketService.getPreviousEventSeries(
+      matchid,
+      prevEventId,
+    );
+  }
+
+  @Public()
+  @Get('/:matchid/state')
+  async getLatestMatchState(@Param('matchid') matchid: string) {
+    const matchState = await this.cricketService.getLatestMatchState(matchid);
+    return matchState;
+  }
+
+  @Patch('/event/:eventID')
+  async updateEvent(
+    @Param('eventID') eventID: string,
+    @Body() updateEventDTO: updateCricketEeventDTOType,
+  ) {
+    updateEventDTO = updateCricketEeventDTO.parse(updateEventDTO);
+    return await this.cricketService.updateEvent(eventID, updateEventDTO);
+  }
+
+  @Delete('/event/:eventID')
+  async DeleteEvent(@Param('eventID') eventID: string) {
+    const result = await this.cricketService.deleteEvent(eventID);
+    return result;
+  }
+
+  @Patch('/:id?')
+  async patch(
+    @Query() query,
+    @Body() patchCricketDto: Partial<CricketState>,
+    @Param('id') id,
+  ) {
+    return await this.cricketService._patch(id, patchCricketDto, query);
+  }
+
+  @Delete('/:id?')
+  async delete(@Param('id') id, @Query() query, @User() user) {
+    return await this.cricketService._remove(id, query, user);
+  }
+}

src/services/apis/cricket/cricket.module.ts

@@ -0,0 +1,29 @@
+import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { CricketController } from './cricket.controller';
+import { CricketService } from './cricket.service';
+import { CricketState, CricketStateSchema } from './schemas/cricket.schema';
+import { MatchesModule } from '../matches/matches.module';
+import {
+  CricketEvent,
+  CricketEventSchema,
+} from './schemas/cricket.event.schema';
+import { ScoreUpdateGateway } from 'src/services/gateways/scoreUpdate/scoreUpdate';
+import { UsersModule } from '../users/users.module';
+
+@Module({
+  imports: [
+    MongooseModule.forFeature([
+      { name: CricketState.name, schema: CricketStateSchema },
+    ]),
+    MongooseModule.forFeature([
+      { name: CricketEvent.name, schema: CricketEventSchema },
+    ]),
+    MatchesModule,
+    UsersModule,
+  ],
+  controllers: [CricketController],
+  providers: [CricketService],
+  exports: [CricketService],
+})
+export class CricketModule {}

src/services/apis/cricket/cricket.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { CricketService } from './cricket.service';
+
+describe('CricketService', () => {
+  let service: CricketService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [CricketService],
+    }).compile();
+
+    service = module.get<CricketService>(CricketService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

src/services/apis/cricket/cricket.service.ts

@@ -0,0 +1,101 @@
+import { Injectable } from '@nestjs/common';
+import { GlobalService } from 'src/common/global-service';
+import { CricketState, CricketStateDocument } from './schemas/cricket.schema';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model, Types } from 'mongoose';
+import { CricketEvent } from './schemas/cricket.event.schema';
+import { EventType } from 'src/types/EventType';
+import { create } from 'lodash';
+import { updateCricketEeventDTOType } from './dto/cricket.event.dto';
+
+@Injectable()
+export class CricketService extends GlobalService<
+  CricketState,
+  CricketStateDocument
+> {
+  constructor(
+    @InjectModel(CricketState.name)
+    private readonly cricketStateModel: Model<CricketStateDocument>,
+    @InjectModel(CricketEvent.name)
+    private readonly cricketEventModel: Model<CricketEvent>,
+  ) {
+    super(cricketStateModel);
+  }
+
+  //Cricket class exclusive methods
+  async createEvent(matchid: string, createCricketEventDTO: CricketEvent) {
+    const event = await this.cricketEventModel.create({
+      match: matchid,
+      ...createCricketEventDTO,
+    });
+    return event;
+  }
+
+  async getLatestMatchState(matchid) {
+    console.log(matchid);
+    const objectid = new Types.ObjectId(matchid);
+    const matchStates = await this.cricketStateModel
+      .find({ match: objectid })
+      .sort({ createdAt: -1 });
+
+    matchStates.forEach((state) => {
+      console.log(state.matchoutcome[0]);
+    });
+
+    return matchStates[0];
+  }
+
+  async getPreviousatestEvent(matchID, prevEventID) {
+    const matchObjectID = new Types.ObjectId(matchID);
+    if (!prevEventID)
+      return await this.cricketEventModel
+        .find({ match: matchObjectID })
+        .sort({ createdAt: -1 });
+
+    const prevEventObjectID = new Types.ObjectId(prevEventID);
+    const TargetEvent: EventType = await this.cricketEventModel.findOne({
+      _id: prevEventObjectID,
+      match: matchObjectID,
+    });
+    const events = await this.cricketEventModel
+      .find({ match: matchObjectID, createdAt: { $lt: TargetEvent.createdAt } })
+      .sort({ createdAt: -1 });
+
+    return events[0];
+  }
+
+  async getPreviousEventSeries(matchID, prevEventID) {
+    const matchObjectId = new Types.ObjectId(matchID);
+    if (!prevEventID)
+      return await this.cricketEventModel
+        .find({ match: matchObjectId })
+        .sort({ createdAt: -1 });
+
+    const prevEventObjectID = new Types.ObjectId(prevEventID);
+    const TargetEvent: EventType = await this.cricketEventModel.findOne({
+      _id: prevEventObjectID,
+      match: matchObjectId,
+    });
+    const events = await this.cricketEventModel
+      .find({ match: matchObjectId, createdAt: { $lt: TargetEvent.createdAt } })
+      .sort({ createdAt: -1 });
+    return events;
+  }
+
+  async updateEvent(
+    id: string,
+    updateCricketEventDTO: updateCricketEeventDTOType,
+  ) {
+    return await this.cricketEventModel.findByIdAndUpdate(
+      id,
+      updateCricketEventDTO,
+    );
+  }
+
+  async deleteEvent(id: string) {
+    const result = await this.cricketEventModel.findByIdAndDelete(id);
+    return {
+      message: 'Deleted Successfully',
+    };
+  }
+}