first

src/modules/media/DTO/display.dto.ts

@@ -0,0 +1,12 @@
+import { Expose } from "class-transformer";
+import { IsEnum, IsNotEmpty, IsOptional } from "class-validator";
+
+import { DisplayLocations } from "../../../common/enums/media.enum";
+
+export class DisplayQueryDTO {
+  @Expose()
+  @IsOptional()
+  @IsNotEmpty()
+  @IsEnum(DisplayLocations)
+  display?: DisplayLocations;
+}

src/modules/media/media.controller.ts

@@ -0,0 +1,48 @@
+import { inject } from "inversify";
+import { controller, httpGet, requestParam } from "inversify-express-utils";
+
+import { MediaService } from "./media.service";
+import { HttpStatus } from "../../common";
+import { BaseController } from "../../common/base/controller";
+import { ApiOperation, ApiParam, ApiResponse, ApiTags } from "../../common/decorator/swggerDocs";
+import { IOCTYPES } from "../../IOC/ioc.types";
+
+@controller("/medias")
+@ApiTags("Media")
+export class MediaController extends BaseController {
+  @inject(IOCTYPES.MediaService) mediaService: MediaService;
+
+  @ApiOperation("get all active sliders")
+  @ApiResponse("successful", HttpStatus.Ok)
+  @httpGet("/sliders")
+  async getSliders() {
+    const data = await this.mediaService.getSliders();
+    return this.response({ sliders: data });
+  }
+
+  @ApiOperation("get all active banners")
+  @ApiResponse("successful", HttpStatus.Ok)
+  @httpGet("/banners")
+  async getBanners() {
+    const data = await this.mediaService.getBanners();
+    return this.response({ banners: data });
+  }
+
+  @ApiOperation("Fetch a single slider by ID")
+  @ApiResponse("successful", HttpStatus.Ok)
+  @ApiParam("sliderId", "id of slider", true)
+  @httpGet("/sliders/:sliderId")
+  public async getSliderById(@requestParam("sliderId") sliderId: string) {
+    const data = await this.mediaService.getSliderById(sliderId);
+    return this.response(data);
+  }
+
+  @ApiOperation("Fetch a single banner by ID")
+  @ApiResponse("successful", HttpStatus.Ok)
+  @ApiParam("bannerId", "id of banner", true)
+  @httpGet("/banners/:bannerId")
+  public async getBannerById(@requestParam("bannerId") bannerId: string) {
+    const data = await this.mediaService.getBannerById(bannerId);
+    return this.response(data);
+  }
+}

src/modules/media/media.service.ts

@@ -0,0 +1,119 @@
+import { inject, injectable } from "inversify";
+import { isValidObjectId } from "mongoose";
+
+import { DisplayLocations } from "../../common/enums/media.enum";
+import { CommonMessage, MediaMessage } from "../../common/enums/message.enum";
+import { BadRequestError } from "../../core/app/app.errors";
+import { IOCTYPES } from "../../IOC/ioc.types";
+import { CreateBannerDTO, CreateSliderDTO, UpdateBannerDTO, UpdateSliderDTO } from "../admin/DTO/media.dto";
+import { BannerRepository, SliderRepository } from "../admin/repository/media";
+
+@injectable()
+export class MediaService {
+  @inject(IOCTYPES.BannerRepository) bannerRepo: BannerRepository;
+  @inject(IOCTYPES.SliderRepository) sliderRepo: SliderRepository;
+
+  async getSliders() {
+    return this.sliderRepo.model.find({ isActive: true });
+  }
+
+  async getSliderForMobile() {
+    return this.sliderRepo.model.find({ isActive: true, displayLocation: DisplayLocations.Mobile });
+  }
+
+  async getSliderForDesktop() {
+    return this.sliderRepo.model.find({ isActive: true, displayLocation: DisplayLocations.Desktop });
+  }
+
+  async getBanners() {
+    return this.bannerRepo.model.find({ isActive: true });
+  }
+
+  async getAllBannersForAdmin() {
+    return { banners: await this.bannerRepo.findAll() };
+  }
+  async getAllSlidersForAdmin() {
+    return { sliders: await this.sliderRepo.findAll() };
+  }
+
+  async createSlider(createSliderDto: CreateSliderDTO) {
+    const newSlider = await this.sliderRepo.model.create({
+      ...createSliderDto,
+    });
+    return {
+      message: MediaMessage.SliderCreated,
+      newSlider,
+    };
+  }
+
+  async createBanner(createBannerDto: CreateBannerDTO) {
+    const newBanner = await this.bannerRepo.model.create({
+      ...createBannerDto,
+    });
+    return {
+      message: MediaMessage.BannerCreated,
+      newBanner,
+    };
+  }
+
+  async updateSlider(sliderId: string, updateSliderDto: UpdateSliderDTO) {
+    await this.validateMedia(sliderId);
+    const updatedSlider = await this.sliderRepo.model.findByIdAndUpdate(sliderId, updateSliderDto, { new: true });
+    return {
+      message: CommonMessage.Updated,
+      updatedSlider,
+    };
+  }
+
+  async updateBanner(bannerId: string, updateBannerDto: UpdateBannerDTO) {
+    await this.validateMedia(bannerId);
+    const updatedBanner = await this.bannerRepo.model.findByIdAndUpdate(bannerId, updateBannerDto, { new: true });
+    return {
+      message: CommonMessage.Updated,
+      updatedBanner,
+    };
+  }
+
+  async deleteMedia(mediaId: string, type: "banner" | "slider") {
+    await this.validateMedia(mediaId);
+    if (type === "banner") await this.bannerRepo.delete(mediaId);
+    else if (type === "slider") await this.sliderRepo.delete(mediaId);
+    return {
+      message: CommonMessage.Deleted,
+    };
+  }
+
+  async activateMediaS(MediaId: string, isActive: boolean, type: "banner" | "slider") {
+    await this.validateMedia(MediaId);
+    if (type === "banner") await this.bannerRepo.model.findByIdAndUpdate(MediaId, { isActive }, { new: true });
+    else if (type === "slider") await this.sliderRepo.model.findByIdAndUpdate(MediaId, { isActive }, { new: true });
+    return {
+      message: MediaMessage.Activated,
+    };
+  }
+
+  async getSliderById(sliderId: string) {
+    await this.validateMedia(sliderId);
+    return {
+      slider: await this.sliderRepo.findById(sliderId),
+    };
+  }
+
+  async getBannerById(bannerId: string) {
+    await this.validateMedia(bannerId);
+    return {
+      slider: await this.bannerRepo.findById(bannerId),
+    };
+  }
+
+  //=======================================>
+  //=======================================>
+  //helper method
+
+  async validateMedia(mediaId: string) {
+    if (!isValidObjectId(mediaId)) throw new BadRequestError(CommonMessage.NotValidId);
+    const media = (await this.sliderRepo.findById(mediaId)) || (await this.bannerRepo.findById(mediaId));
+    if (!media) throw new BadRequestError(CommonMessage.NotValidId);
+    return media;
+  }
+}