@solidstarters/solid-core 1.2.124 → 1.2.127

package/src/services/user.service.ts.bkp

@@ -1,311 +0,0 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
-
-import { Repository, SelectQueryBuilder } from 'typeorm';
-import { InjectRepository } from '@nestjs/typeorm';
-import { User } from '../entities/user.entity';
-import { OauthUserDto } from '../dtos/oauth-user-dto';
-import { UpdateUserDto } from '../dtos/update-user.dto';
-import { BasicFilterDto } from 'src/dtos/basic-filters.dto';
-import { CrudHelperService } from 'src/services/crud-helper.service';
-import { RoleMetadata } from '../entities/role-metadata.entity';
-
-
-@Injectable()
-export class UserService {
-
-    constructor(
-        readonly crudHelperService: CrudHelperService,
-        @InjectRepository(User)
-        private readonly userRepository: Repository<User>,
-        @InjectRepository(RoleMetadata)
-        private readonly roleRepository: Repository<RoleMetadata>,
-    ) { }
-
-    async findMany(basicFilterDto: BasicFilterDto) {
-        const alias = 'user';
-        // Extract the required keys from the input query
-        let { limit, offset} = basicFilterDto;
- 
-        // Create above query on pincode table using query builder
-        var qb: SelectQueryBuilder<User> = this.userRepository.createQueryBuilder(alias)
-        qb = await this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
-
-        // Get the records and the count
-        const [entities, count] = await qb.getManyAndCount();
-
-        const currentPage = Math.floor(offset / limit) + 1;
-        const totalPages = Math.ceil(count / limit);
-
-        const nextPage = currentPage < totalPages ? currentPage + 1 : null;
-        const prevPage = currentPage > 1 ? currentPage - 1 : null;
-
-        const r = {
-            meta: {
-                totalRecords: count,
-                currentPage: currentPage,
-                nextPage: nextPage,
-                prevPage: prevPage,
-                totalPages: totalPages,
-                perPage: +limit,
-            },
-            records: entities
-        };
-        return r
-    }
-
-
-    async findOne(id: number) {
-        const entity = await this.userRepository.findOne({
-            where: {
-                id: id
-            },
-            relations: {
-                roles: true
-            }
-        });
-        if (!entity) {
-            throw new NotFoundException(`entity #${id} not found`);
-        }
-        return entity;
-    }
-
-    async findOneByEmail(email: string): Promise<User> {
-        return await this.userRepository.findOne({
-            where: {
-                email: email
-            },
-            relations: {}
-        });
-        // if (!entity) {
-        //     throw new NotFoundException(`user with email #${email} not found`);
-        // }
-        // return entity;
-    }
-
-    async findOneByAccessCode(accessCode: string): Promise<User> {
-        return await this.userRepository.findOne({
-            where: {
-                accessCode: accessCode
-            },
-            relations: {}
-        });
-    }
-
-    async findOneByUsername(username: string): Promise<User> {
-        return await this.userRepository.findOne({
-            where: {
-                username: username
-            },
-            relations: {}
-        });
-        // if (!entity) {
-        //     throw new NotFoundException(`user with username ${username} not found`);
-        // }
-        // return entity;
-    }
-
-    async addRoleToUser(username: string, roleName: string): Promise<User> {
-        // Find the role, find the user and populate the many 2 many table.
-        const user = await this.userRepository.findOne({
-            where: { username: username },
-            relations: {
-                roles: true
-            }
-        });
-        if (!user) {
-            throw new Error(`User with username '${username}' not found.`);
-        }
-        const role = await this.roleRepository.findOne({ where: { name: roleName } });
-        if (!role) {
-            throw new Error(`Role '${roleName}' not found.`);
-        }
-
-        if (user.roles && user.roles.length > 0) {
-            user.roles.push(role);
-        }
-        else {
-            user.roles = [role];
-        }
-
-        return await this.userRepository.save(user);
-    }
-
-    async addRolesToUser(username: string, roleNames: string[]): Promise<User> {
-        const user = await this.userRepository.findOne({
-            where: { username: username },
-            relations: { roles: true }
-        });
-
-        if (!user) {
-            throw new Error(`User with username '${username}' not found.`);
-        }
-
-        const roles = await this.roleRepository.find({
-            where: roleNames.map(roleName => ({ name: roleName }))
-        });
-
-        if (roles.length !== roleNames.length) {
-            const foundRoleNames = roles.map(role => role.name);
-            const missingRoles = roleNames.filter(roleName => !foundRoleNames.includes(roleName));
-            throw new Error(`The following roles were not found: ${missingRoles.join(', ')}`);
-        }
-
-        const currentRoles = user.roles.map(role => role.name);
-
-        const rolesToAdd = roles.filter(role => !currentRoles.includes(role.name));
-
-        const rolesToRemove = user.roles.filter(role => !roleNames.includes(role.name));
-
-        if (rolesToAdd.length > 0) {
-            user.roles.push(...rolesToAdd);
-        }
-
-        if (rolesToRemove.length > 0) {
-            user.roles = user.roles.filter(role => !rolesToRemove.includes(role));
-        }
-
-        return await this.userRepository.save(user);
-    }
-
-
-    async removeRoleFromUser(username: string, roleName: string): Promise<User> {
-
-        // load the role with the respective permissions.
-        const user = await this.userRepository.findOne({
-            where: {
-                username: username
-            },
-            relations: {
-                roles: true
-            }
-        });
-
-        if (!user) {
-            throw new Error(`User with username '${username}' not found.`);
-        }
-
-        // modify the permissions array.
-        user.roles = user.roles.filter(role => role.name !== roleName);
-
-        return await this.userRepository.save(user);
-    }
-
-    // PROVIDER SPECIFIC CODE
-    async resolveUserOnOauthGoogle(oauthUserDto: OauthUserDto): Promise<User> {
-        const user = await this.userRepository.findOne({
-            where: {
-                email: oauthUserDto.email,
-            },
-            relations: {
-                roles: true
-            }
-        });
-
-        // if we are unable to find a user then we need to create one. 
-        if (!user) {
-            const user = new User();
-            user.username = oauthUserDto.email;
-            user.email = oauthUserDto.email;
-            user.lastLoginProvider = oauthUserDto.provider;
-            user.accessCode = oauthUserDto.accessCode;
-            user.googleAccessToken = oauthUserDto.accessToken;
-            user.googleId = oauthUserDto.providerId;
-            user.googleProfilePicture = oauthUserDto.picture;
-
-            return await this.userRepository.save(user);
-        }
-        // else we update the user and store the generated code & access token. 
-        else {
-            const entity = await this.userRepository.preload({
-                id: user.id,
-                lastLoginProvider: oauthUserDto.provider,
-                accessCode: oauthUserDto.accessCode,
-                googleAccessToken: oauthUserDto.accessToken,
-                googleId: oauthUserDto.providerId,
-                googleProfilePicture: oauthUserDto.picture,
-            });
-
-            await this.userRepository.save(entity);
-        }
-
-        return user;
-    }
-
-    // async addPermissionToUser(userEmail: string, permissionName: string) {
-    //     // TODO: Find the role, find the permission and add them all to the specified userid.
-    // }
-
-    // async removePermissionFromUser(userEmail: string, permissionName: string) {
-    //     // TODO: Find the role, find the permission and remove them all to the specified userid.
-    // }
-
-    async updateUser(id: number, userDetails: UpdateUserDto) {
-        if (!id) {
-            throw new Error('User id is required');
-        }
-        const user = await this.findOne(id);
-        const savedUser = this.userRepository.merge(user, userDetails);
-        return await this.userRepository.save(savedUser);
-    }
-
-    async findUsersByRole(roleName: string, relations: any = {}): Promise<User[]> {
-        return await this.userRepository.find({
-            where: {
-                roles: {
-                    name: roleName
-                }
-            },
-            relations: relations
-        });
-    }
-    async remove(id: number) {
-        if (!id) {
-            throw new Error(`Id Not Found`);
-        }
-        const entity = await this.findOne(id);
-        if (!entity) {
-            throw new Error(`Entity with id ${id} not found`);
-        }
-
-        return this.userRepository.remove(entity);
-    }
-
-    async deleteMany(ids: number[]): Promise<any> {
-        if (!ids || ids.length === 0) {
-            throw new Error('At least one ID is required for deletion');
-        }
-        const removedEntities = [];
-        for (let i = 0; i < ids.length; i++) {
-            const id = ids[i]
-            const entity = await this.userRepository.findOne({
-                where: {
-                    //@ts-ignore
-                    id: id,
-                }
-            });
-            // if (!entity) {
-            //     throw new Error(`Entity with id ${id} not found`);
-            // }
-            removedEntities.push(await this.userRepository.remove(entity));
-        }
-
-        return removedEntities
-    }
-
-
-    private buildFilterConditions(filters: Record<string, any>) {
-        const conditions: Record<string, any> = {};
-
-        Object.keys(filters).forEach((key) => {
-            let value = filters[key];
-
-            if (Array.isArray(value)) {
-                conditions[key] = { $in: value };
-            } else {
-                conditions[key] = { $containsi: value };
-            }
-        });
-
-        return conditions;
-    }
-}