backend/src/community/services/community.service.ts

import { GetCommunityChildDto } from './../dtos/get.community.dto';
import { SpaceTypeRepository } from './../../../libs/common/src/modules/space-type/repositories/space.type.repository';
import {
  Injectable,
  HttpException,
  HttpStatus,
  BadRequestException,
} from '@nestjs/common';
import { SpaceRepository } from '@app/common/modules/space/repositories';
import { AddCommunityDto } from '../dtos';
import {
  CommunityChildInterface,
  GetCommunityByUuidInterface,
  RenameCommunityByUuidInterface,
} from '../interface/community.interface';
import { SpaceEntity } from '@app/common/modules/space/entities';
import { UpdateCommunityNameDto } from '../dtos/update.community.dto';

@Injectable()
export class CommunityService {
  constructor(
    private readonly spaceRepository: SpaceRepository,
    private readonly spaceTypeRepository: SpaceTypeRepository,
  ) {}

  async addCommunity(addCommunityDto: AddCommunityDto) {
    try {
      const spaceType = await this.spaceTypeRepository.findOne({
        where: {
          type: 'community',
        },
      });

      await this.spaceRepository.save({
        spaceName: addCommunityDto.communityName,
        spaceType: { uuid: spaceType.uuid },
      });
    } catch (err) {
      throw new HttpException(err.message, HttpStatus.INTERNAL_SERVER_ERROR);
    }
  }

  async getCommunityByUuid(
    communityUuid: string,
  ): Promise<GetCommunityByUuidInterface> {
    try {
      const community = await this.spaceRepository.findOne({
        where: {
          uuid: communityUuid,
          spaceType: {
            type: 'community',
          },
        },
        relations: ['spaceType'],
      });
      if (!community) {
        throw new HttpException('Community not found', HttpStatus.NOT_FOUND);
      }
      return {
        uuid: community.uuid,
        createdAt: community.createdAt,
        updatedAt: community.updatedAt,
        name: community.spaceName,
        type: community.spaceType.type,
      };
    } catch (err) {
      throw new HttpException(
        err.message,
        err.status || HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }
  async getCommunityChildByUuid(
    communityUuid: string,
    getCommunityChildDto: GetCommunityChildDto,
  ): Promise<CommunityChildInterface> {
    const { includeSubSpaces, page, pageSize } = getCommunityChildDto;

    const space = await this.spaceRepository.findOneOrFail({
      where: { uuid: communityUuid },
      relations: ['children', 'spaceType'],
    });

    if (space.spaceType.type !== 'community') {
      throw new HttpException('Community not found', HttpStatus.NOT_FOUND);
    }
    const totalCount = await this.spaceRepository.count({
      where: { parent: { uuid: space.uuid } },
    });
    const children = await this.buildHierarchy(
      space,
      includeSubSpaces,
      page,
      pageSize,
    );
    return {
      uuid: space.uuid,
      name: space.spaceName,
      type: space.spaceType.type,
      totalCount,
      children,
    };
  }

  private async buildHierarchy(
    space: SpaceEntity,
    includeSubSpaces: boolean,
    page: number,
    pageSize: number,
  ): Promise<CommunityChildInterface[]> {
    const children = await this.spaceRepository.find({
      where: { parent: { uuid: space.uuid } },
      relations: ['spaceType'],
      skip: (page - 1) * pageSize,
      take: pageSize,
    });

    if (!children || children.length === 0 || !includeSubSpaces) {
      return children
        .filter((child) => child.spaceType.type !== 'community') // Filter remaining community type
        .map((child) => ({
          uuid: child.uuid,
          name: child.spaceName,
          type: child.spaceType.type,
        }));
    }

    const childHierarchies = await Promise.all(
      children
        .filter((child) => child.spaceType.type !== 'community') // Filter remaining community type
        .map(async (child) => ({
          uuid: child.uuid,
          name: child.spaceName,
          type: child.spaceType.type,
          children: await this.buildHierarchy(child, true, 1, pageSize),
        })),
    );

    return childHierarchies;
  }
  async renameCommunityByUuid(
    communityUuid: string,
    updateCommunityDto: UpdateCommunityNameDto,
  ): Promise<RenameCommunityByUuidInterface> {
    try {
      const community = await this.spaceRepository.findOneOrFail({
        where: { uuid: communityUuid },
        relations: ['spaceType'],
      });

      if (
        !community ||
        !community.spaceType ||
        community.spaceType.type !== 'community'
      ) {
        throw new BadRequestException('Invalid community UUID');
      }

      await this.spaceRepository.update(
        { uuid: communityUuid },
        { spaceName: updateCommunityDto.communityName },
      );

      // Fetch the updated community
      const updatedCommunity = await this.spaceRepository.findOneOrFail({
        where: { uuid: communityUuid },
        relations: ['spaceType'],
      });

      return {
        uuid: updatedCommunity.uuid,
        name: updatedCommunity.spaceName,
        type: updatedCommunity.spaceType.type,
      };
    } catch (err) {
      if (err instanceof BadRequestException) {
        throw err; // Re-throw BadRequestException
      } else {
        throw new HttpException('Community not found', HttpStatus.NOT_FOUND);
      }
    }
  }
}