chore: add landing module

src/modules/sliders/entities/slider.entity.ts

@@ -14,7 +14,7 @@ export class Slider extends BaseEntity {
   imageUrl: string;
 
   @Column({ length: 255, nullable: true })
-  link: string;
+  link?: string;
 
   @Column({ default: 0 })
   order: number;

src/modules/sliders/providers/slider.service.ts

@@ -1,48 +0,0 @@
-import { Injectable, NotFoundException } from "@nestjs/common";
-import { InjectRepository } from "@nestjs/typeorm";
-import { Repository } from "typeorm";
-
-import { SliderMessage } from "../../../common/enums/message.enum";
-import { CreateSliderDto } from "../DTO/create-slider.dto";
-import { UpdateSliderDto } from "../DTO/update-slider.dto";
-import { Slider } from "../entities/slider.entity";
-
-@Injectable()
-export class SliderService {
-  constructor(
-    @InjectRepository(Slider)
-    private readonly sliderRepository: Repository<Slider>,
-  ) {}
-
-  async create(createSliderDto: CreateSliderDto): Promise<Slider> {
-    const slider = this.sliderRepository.create(createSliderDto);
-    return await this.sliderRepository.save(slider);
-  }
-
-  async findAll(): Promise<Slider[]> {
-    return await this.sliderRepository.find({
-      order: {
-        order: "ASC",
-      },
-    });
-  }
-
-  async getSliderById(id: string): Promise<Slider> {
-    const slider = await this.sliderRepository.findOne({ where: { id } });
-    if (!slider) {
-      throw new NotFoundException(SliderMessage.SLIDER_NOT_FOUND);
-    }
-    return slider;
-  }
-
-  async update(id: string, updateSliderDto: UpdateSliderDto): Promise<Slider> {
-    const slider = await this.getSliderById(id);
-    Object.assign(slider, updateSliderDto);
-    return await this.sliderRepository.save(slider);
-  }
-
-  async remove(id: string): Promise<void> {
-    const slider = await this.getSliderById(id);
-    await this.sliderRepository.remove(slider);
-  }
-}

src/modules/sliders/providers/sliders.service.ts

@@ -0,0 +1,73 @@
+import { Injectable, NotFoundException } from "@nestjs/common";
+
+import { PaginationDto } from "../../../common/DTO/pagination.dto";
+import { CommonMessage, SliderMessage } from "../../../common/enums/message.enum";
+import { CreateSliderDto } from "../DTO/create-slider.dto";
+import { UpdateSliderDto } from "../DTO/update-slider.dto";
+import { SlidersRepository } from "../repositories/sliders.repository";
+@Injectable()
+export class SlidersService {
+  constructor(private readonly slidersRepository: SlidersRepository) {}
+
+  async create(createSliderDto: CreateSliderDto) {
+    const slider = this.slidersRepository.create(createSliderDto);
+    await this.slidersRepository.save(slider);
+    return {
+      message: CommonMessage.CREATED,
+      slider,
+    };
+  }
+  //*************************** */
+  async getSlidersList(queryDto: PaginationDto) {
+    const [sliders, count] = await this.slidersRepository.getSlidersListForAdmin(queryDto);
+    return {
+      sliders,
+      count,
+      paginate: true,
+    };
+  }
+  //************************* */
+  async getSliderById(id: string) {
+    const slider = await this.slidersRepository.findOne({ where: { id } });
+    if (!slider) throw new NotFoundException(SliderMessage.SLIDER_NOT_FOUND);
+
+    return {
+      slider,
+    };
+  }
+  //****************** */
+  async update(id: string, updateSliderDto: UpdateSliderDto) {
+    const { slider } = await this.getSliderById(id);
+
+    await this.slidersRepository.save({ ...slider, ...updateSliderDto });
+    return {
+      message: CommonMessage.UPDATE_SUCCESS,
+    };
+  }
+  //****************** */
+  async remove(id: string) {
+    const { slider } = await this.getSliderById(id);
+    await this.slidersRepository.remove(slider);
+
+    return {
+      message: CommonMessage.DELETED,
+    };
+  }
+  //****************** */
+
+  async toggleSliderStatus(id: string) {
+    const { slider } = await this.getSliderById(id);
+    slider.isActive = !slider.isActive;
+    await this.slidersRepository.save(slider);
+    return {
+      message: CommonMessage.UPDATE_SUCCESS,
+    };
+  }
+  //****************** */
+
+  async getSlidersListForLanding() {
+    const sliders = await this.slidersRepository.find({ where: { isActive: true } });
+    return sliders;
+  }
+  //****************** */
+}

src/modules/sliders/repositories/sliders.repository.ts

@@ -2,6 +2,8 @@ import { Injectable } from "@nestjs/common";
 import { InjectRepository } from "@nestjs/typeorm";
 import { Repository } from "typeorm";
 
+import { PaginationDto } from "../../../common/DTO/pagination.dto";
+import { PaginationUtils } from "../../utils/providers/pagination.utils";
 import { Slider } from "../entities/slider.entity";
 
 @Injectable()
@@ -9,4 +11,16 @@ export class SlidersRepository extends Repository<Slider> {
   constructor(@InjectRepository(Slider) repository: Repository<Slider>) {
     super(repository.target, repository.manager, repository.queryRunner);
   }
+
+  async getSlidersListForAdmin(queryDto: PaginationDto) {
+    const { skip, limit } = PaginationUtils(queryDto);
+
+    return this.findAndCount({
+      skip,
+      take: limit,
+      order: {
+        order: "ASC",
+      },
+    });
+  }
 }

src/modules/sliders/sliders.controller.ts

@@ -1,49 +1,53 @@
-import { Body, Controller, Delete, Get, Param, Patch, Post } from "@nestjs/common";
+import { Body, Controller, Delete, Get, Param, Patch, Post, Query } from "@nestjs/common";
 import { ApiOperation } from "@nestjs/swagger";
 
 import { CreateSliderDto } from "./DTO/create-slider.dto";
 import { UpdateSliderDto } from "./DTO/update-slider.dto";
-import { SliderService } from "./providers/slider.service";
+import { SlidersService } from "./providers/sliders.service";
+import { AdminRoute } from "../../common/decorators/admin.decorator";
 import { AuthGuards } from "../../common/decorators/auth-guard.decorator";
-import { SkipAuth } from "../../common/decorators/skip-auth.decorator";
+import { PaginationDto } from "../../common/DTO/pagination.dto";
 import { ParamDto } from "../../common/DTO/param.dto";
 // import { PermissionsDec } from "../../common/decorators/permission.decorator";
 
 @Controller("sliders")
 @AuthGuards()
-export class SliderController {
-  constructor(private readonly sliderService: SliderService) {}
+export class SlidersController {
+  constructor(private readonly slidersService: SlidersService) {}
 
   @ApiOperation({ summary: "create slider (admin route)" })
+  @AdminRoute()
   // @PermissionsDec(PermissionEnum.SLIDER)
   @Post()
   create(@Body() createSliderDto: CreateSliderDto) {
-    return this.sliderService.create(createSliderDto);
+    return this.slidersService.create(createSliderDto);
   }
 
   @ApiOperation({ summary: "Get all sliders" })
-  @SkipAuth()
+  @AdminRoute()
   @Get()
-  findAll() {
-    return this.sliderService.findAll();
+  getSlidersList(@Query() queryDto: PaginationDto) {
+    return this.slidersService.getSlidersList(queryDto);
   }
 
-  @Get(":id")
   @ApiOperation({ summary: "Get a slider by id" })
-  @SkipAuth()
+  @AdminRoute()
+  @Get(":id")
   getSliderById(@Param() paramDto: ParamDto) {
-    return this.sliderService.getSliderById(paramDto.id);
+    return this.slidersService.getSliderById(paramDto.id);
   }
 
   @ApiOperation({ summary: "Update a slider" })
+  @AdminRoute()
   @Patch(":id")
   update(@Param() paramDto: ParamDto, @Body() updateSliderDto: UpdateSliderDto) {
-    return this.sliderService.update(paramDto.id, updateSliderDto);
+    return this.slidersService.update(paramDto.id, updateSliderDto);
   }
 
   @ApiOperation({ summary: "Delete a slider" })
+  @AdminRoute()
   @Delete(":id")
   remove(@Param() paramDto: ParamDto) {
-    return this.sliderService.remove(paramDto.id);
+    return this.slidersService.remove(paramDto.id);
   }
 }

src/modules/sliders/sliders.module.ts

@@ -2,14 +2,14 @@ import { Module } from "@nestjs/common";
 import { TypeOrmModule } from "@nestjs/typeorm";
 
 import { Slider } from "./entities/slider.entity";
-import { SliderService } from "./providers/slider.service";
+import { SlidersService } from "./providers/sliders.service";
 import { SlidersRepository } from "./repositories/sliders.repository";
-import { SliderController } from "./slider.controller";
+import { SlidersController } from "./sliders.controller";
 
 @Module({
   imports: [TypeOrmModule.forFeature([Slider])],
-  controllers: [SliderController],
-  providers: [SliderService, SlidersRepository],
-  exports: [SliderService],
+  controllers: [SlidersController],
+  providers: [SlidersService, SlidersRepository],
+  exports: [SlidersService],
 })
-export class SliderModule {}
+export class SlidersModule {}