psp_api/src/modules/admin/guilds/goods/goods.service.ts

import { UploadedFileTypes } from '@/common/enums/enums'
import { RedisKeyMaker } from '@/common/utils/redisKeyMaker'
import { GoodSelect, GoodWhereInput } from '@/generated/prisma/models'
import { AdminGuildCacheInvalidationService } from '@/modules/admin/guilds/cache/admin-guild-cache-invalidation.service'
import { UploaderService } from '@/modules/uploader/uploader.service'
import { PrismaService } from '@/prisma/prisma.service'
import { RedisService } from '@/redis/redis.service'
import { Injectable } from '@nestjs/common'
import { ResponseMapper } from 'common/response/response-mapper'
import { CreateGuildGoodDto, UpdateGuildGoodDto } from './dto/create-good.dto'

@Injectable()
export class GoodsService {
  constructor(
    private prisma: PrismaService,
    private readonly uploaderService: UploaderService,
    private readonly redisService: RedisService,
    private readonly cacheInvalidationService: AdminGuildCacheInvalidationService,
  ) {}

  private readonly listCacheTtlSeconds = 300

  private readonly defaultSelect: GoodSelect = {
    id: true,
    name: true,
    pricing_model: true,
    image_url: true,
    description: true,
    sku: {
      select: {
        id: true,
        name: true,
        code: true,
      },
    },
    measure_unit: {
      select: {
        id: true,
        name: true,
        code: true,
      },
    },
    category: {
      select: {
        id: true,
        name: true,
      },
    },
  }

  private readonly defaultWhere = (guild_id: string): GoodWhereInput => ({
    is_default_guild_good: true,
    category: {
      guild_id,
    },
  })

  async findAll(guildId: string) {
    const cacheKey = RedisKeyMaker.guildGoodsList(guildId)
    const cached = await this.redisService.getJson<{ goods: unknown[]; total: number }>(
      cacheKey,
    )
    if (cached) {
      return ResponseMapper.paginate(cached.goods, { total: cached.total })
    }

    const [goods, total] = await this.prisma.$transaction([
      this.prisma.good.findMany({
        where: this.defaultWhere(guildId),
        select: this.defaultSelect,
      }),
      this.prisma.good.count(),
    ])

    await this.redisService.setJson(cacheKey, { goods, total }, this.listCacheTtlSeconds)

    return ResponseMapper.paginate(goods, {
      total,
    })
  }

  async findOne(guild_id: string, id: string) {
    const good = await this.prisma.good.findUnique({
      where: {
        id,
        ...(this.defaultWhere(guild_id) as any),
      },
      select: this.defaultSelect,
    })

    return ResponseMapper.single(good)
  }

  async create(data: CreateGuildGoodDto, file: Express.Multer.File) {
    const { category_id, measure_unit_id, sku_id, ...rest } = data
    const category = await this.prisma.goodCategory.findUnique({
      where: { id: category_id },
      select: { guild_id: true },
    })

    const good = await this.prisma.$transaction(async tx => {
      let image_url = ''
      if (file) {
        const uploadedUrl = await this.uploaderService.uploadFile(
          file,
          UploadedFileTypes.GOOD,
        )
        image_url = uploadedUrl || ''
      }

      return await tx.good.create({
        data: {
          ...rest,
          is_default_guild_good: true,
          image_url,
          sku: {
            connect: {
              id: sku_id,
            },
          },
          measure_unit: {
            connect: {
              id: measure_unit_id,
            },
          },
          category: {
            connect: {
              id: category_id,
            },
          },
        },
        select: this.defaultSelect,
      })
    })

    if (category?.guild_id) {
      await this.cacheInvalidationService.invalidateGoodsList(category.guild_id)
    }

    return ResponseMapper.create(good)
  }

  async update(id: string, data: UpdateGuildGoodDto, file: Express.Multer.File) {
    const { category_id, measure_unit_id, sku_id, ...rest } = data
    const prevGood = await this.prisma.good.findUnique({
      where: { id },
      select: { category: { select: { guild_id: true } } },
    })
    const nextCategory = category_id
      ? await this.prisma.goodCategory.findUnique({
          where: { id: category_id },
          select: { guild_id: true },
        })
      : null

    const good = await this.prisma.$transaction(async tx => {
      let image_url = ''
      if (file) {
        const uploadedUrl = await this.uploaderService.uploadFile(
          file,
          UploadedFileTypes.GOOD,
        )
        image_url = uploadedUrl || ''
      }

      const prevImage = await tx.good.findUnique({
        where: { id },
        select: { image_url: true },
      })

      if (image_url && prevImage?.image_url) {
        this.uploaderService.deleteFile(prevImage.image_url, UploadedFileTypes.GOOD)
      }

      return await tx.good.update({
        where: { id },
        data: {
          ...rest,
          is_default_guild_good: true,
          image_url,
          sku: {
            connect: {
              id: sku_id,
            },
          },
          measure_unit: {
            connect: {
              id: measure_unit_id,
            },
          },
          category: {
            connect: {
              id: category_id,
            },
          },
        },
        select: this.defaultSelect,
      })
    })

    const cacheGuildIds = new Set<string>()
    if (prevGood?.category?.guild_id) {
      cacheGuildIds.add(prevGood.category.guild_id)
    }
    if (nextCategory?.guild_id) {
      cacheGuildIds.add(nextCategory.guild_id)
    }

    for (const guildId of cacheGuildIds) {
      await this.cacheInvalidationService.invalidateGoodsList(guildId)
    }

    return ResponseMapper.create(good)
  }
}