jurong_circle_program_black/src/service/program.service.ts

import {Injectable} from "@nestjs/common";
import {ProgramEntity, ProgramGroupEntity, UsersEntity, ProgramCollectEntity} from "../entity";
import {Repository} from "typeorm";
import {InjectRepository} from '@nestjs/typeorm';
import {ResultData} from "../const/result";

@Injectable()
export class ProgramService {

    constructor(
        @InjectRepository(ProgramEntity) private readonly programRepository: Repository<ProgramEntity>,
        @InjectRepository(ProgramGroupEntity) private readonly groupRepository: Repository<ProgramGroupEntity>,
        @InjectRepository(ProgramCollectEntity) private readonly collectRepository: Repository<ProgramCollectEntity>,
    ) {
    }

    async getList(program: ProgramEntity) {
        try {
            program.page = program.page || 1;
            program.size = program.size || 10;
            const offset = (program.page - 1) * program.size;

            const queryBuilder = this.programRepository.createQueryBuilder('program');
            // 关联用户
            queryBuilder.leftJoinAndMapOne(
                'program.user',
                UsersEntity,
                'users',
                'users.id = program.linkman_id'
            );

            if (program.keyword) {
                queryBuilder.orWhere('program.name like :name', {name: `%${program.keyword}%`});
                queryBuilder.orWhere('program.company like :company', {company: `%${program.keyword}%`});
                queryBuilder.orWhere('program.address like :address', {address: `%${program.keyword}%`});
            }

            if (program.linkmanId) {
                queryBuilder.orWhere('program.linkmanId like :linkmanId', {linkmanId: `%${program.linkmanId}%`});
            }

            queryBuilder
                .orderBy('program.createDate', 'DESC')
                .take(program.size || 10)
                .skip(offset || 0);

            const [items, total] = await queryBuilder.getManyAndCount();

            let data = {
                list: items,
                total,
                page: program.page || 1,
                size: program.size || 10,
                pages: Math.ceil(total / (program.size || 10))
            }
            return ResultData.success(data);
        } catch (err) {
            return ResultData.fail(500, err.message);
        }
    }

    async add(program: ProgramEntity) {
        try {
            let result = await this.programRepository.save(program)
            return result != null ? ResultData.success() : ResultData.fail();
        } catch (err) {
            return ResultData.fail(500, err);
        }
    }


    async getById(id: number) {
        try {
            let result = await this.programRepository.createQueryBuilder('program')
                .leftJoinAndMapOne(
                    'program.user',
                    UsersEntity,
                    'users',
                    'users.id = program.linkman_id'
                ).where('program.id = :id', {id: id}).getOne()


            return result != null ? ResultData.success(result) : ResultData.fail();
        } catch (err) {
            return ResultData.fail(500, err);
        }
    }

    async update(program: ProgramEntity) {
        try {
            let data = await this.programRepository.update(program.id, program)
            return (data.affected != null && data.affected > 0) ? ResultData.success() : ResultData.fail(500, "修改失败");
        } catch (err) {
            return ResultData.fail(500, err);
        }
    }

    async delete(id: number) {
        try {
            let data = await this.programRepository.delete(id)
            return (data.affected != null && data.affected > 0) ? ResultData.success() : ResultData.fail(500, "删除失败");
        } catch (err) {
            return ResultData.fail(500, err);
        }
    }

    // 是否进行聊天
    async isChat(group: ProgramGroupEntity) {
        try {
            let result = await this.groupRepository.findOne({
                where: {
                    programId: group.programId,
                    userId: group.userId
                }
            })
            return ResultData.success({isChat: result != null}, "success")
        } catch (err) {
            return ResultData.fail(500, err.message);
        }
    }

    // 收藏项目
    async collect(collect: ProgramCollectEntity) {
        try {
            // 判断参数
            if (!collect.programId || !collect.userId) {
                throw new Error("参数错误");
            }

            // 判断是否已收藏
            let collectSearchResult = await this.collectRepository.findOne({
                where: {
                    programId: collect.programId,
                    userId: collect.userId
                }
            })
            if (collectSearchResult != null) {
                throw new Error("该项目已收藏");
            }
            // 没有记录则进行添加收藏
            let result = await this.collectRepository.save(collect)
            return result != null ? ResultData.success() : ResultData.fail(500, "收藏失败");
        } catch (err) {
            return ResultData.fail(500, err.message);
        }
    }

    // 取消收藏项目
    async uncollect(collect: ProgramCollectEntity) {
        try {
            // 判断参数
            if (!collect.programId || !collect.userId) {
                throw new Error("参数错误");
            }
            const result = await this.collectRepository.delete(collect)
            return (result.affected != null && result.affected > 0) ? ResultData.success() : ResultData.fail(500, "取消收藏失败");
        } catch (err) {
            return ResultData.fail(500, err.message);
        }
    }

    // 收藏列表
    async collectList(collect: ProgramCollectEntity) {
        try {
            collect.page = collect.page || 1;
            collect.size = collect.size || 10;
            const offset = (collect.page - 1) * collect.size;
            const queryBuilder = this.programRepository.createQueryBuilder('collect');
            queryBuilder.leftJoinAndMapOne(
                'collect.program',
                ProgramEntity,
                'program',
                'program.id = collect.program_id'
            )
            queryBuilder.leftJoinAndMapOne(
                'collect.user',
                UsersEntity,
                'users',
                'users.id = collect.user_id'
            )
            queryBuilder.where('collect.user_id = :userId', {userId: collect.userId});

            queryBuilder
                .orderBy('program.createDate', 'DESC')
                .take(collect.size || 10)
                .skip(offset || 0);

            const [items, total] = await queryBuilder.getManyAndCount();

            let data = {
                list: items,
                total,
                page: collect.page || 1,
                size: collect.size || 10,
                pages: Math.ceil(total / (collect.size || 10))
            }
            return ResultData.success(data);
        } catch (err) {
            return ResultData.fail(500, err.message);
        }
    }

    // 是否已收藏
    async isCollect(collect: ProgramCollectEntity) {
        try {
            // 判断参数
            if (!collect.programId || !collect.userId) {
                throw new Error("参数错误");
            }
            // 是否存在数据
            let result = await this.collectRepository.findOne({
                where: {
                    programId: collect.programId,
                    userId: collect.userId
                }
            })
            return ResultData.success({isCollect: result != null}, "success")
        } catch (err) {
            return ResultData.fail(500, err.message);
        }
    }

    async random(collect: ProgramCollectEntity) {
        try {
            if (!collect.userId || !collect.programId){
                throw new Error("参数错误");
            }
            const queryBuilder = this.programRepository.createQueryBuilder("program")
            const result = await queryBuilder
                .leftJoin(
                    ProgramCollectEntity, // 收藏表实体名称
                    "favorite",
                    "favorite.program_id = program.id AND favorite.user_id = :userId",
                    { userId: collect.userId }
                )
                .where("favorite.id IS NULL") // 没有收藏记录
                .andWhere("program.id != :programId", { programId: collect.programId })
                .orderBy("RAND()")
                .select("program.id", "id") // 选择ID字段
                .getRawOne()
            if (result == null) {
                return ResultData.fail(500, "没有更多项目");
            }
            return ResultData.success(result);
        }catch (err){
            return ResultData.fail(500, err.message);
        }
    }
}