17474164690

Committed 04 Sep 2025 07:08PM UTC coverage: 64.95% (-0.07%) from 65.017%

Build # 17474164690

Build Type

push

github

Committed by

bpatrik

Commit Message

Fix mysql error

Run Details

1237 of 2172 branches covered (56.95%)

Branch coverage included in aggregate %.

2 of 2 new or added lines in 1 file covered. (100.0%)

428 existing lines in 14 files now uncovered.

4626 of 6855 relevant lines covered (67.48%)

4444.94 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

27.69

/src/backend/model/database/UserManager.ts

import {UserDTO, UserRoles} from '../../../common/entities/UserDTO';
import {UserEntity} from './enitites/UserEntity';
import {SQLConnection} from './SQLConnection';
import {PasswordHelper} from '../PasswordHelper';
import {FindOptionsWhere} from 'typeorm';
import {UserSettingsDTO} from '../../../common/entities/UserSettingsDTO';
import {SearchQueryUtils} from '../../../common/SearchQueryUtils';

export class UserManager {


  public async findOne(filter: FindOptionsWhere<UserEntity>): Promise<UserEntity> {
    const connection = await SQLConnection.getConnection();
    const pass = filter.password as string;
    delete filter.password;
    const user = await connection.getRepository(UserEntity).findOneBy(filter);

    if (pass && !PasswordHelper.comparePassword(pass, user.password)) {
      throw new Error('No entry found');
    }
    return user;
  }

  public async find(filter: FindOptionsWhere<UserDTO>): Promise<UserEntity[]> {
    const connection = await SQLConnection.getConnection();
    return await connection.getRepository(UserEntity).findBy(filter);
  }

  public async createUser(user: UserDTO): Promise<UserEntity> {
    const connection = await SQLConnection.getConnection();
    // Validate search queries if provided
    if (user.allowQuery) {
      SearchQueryUtils.validateSearchQuery(user.allowQuery, 'User allowQuery');
    }
    if (user.blockQuery) {
      SearchQueryUtils.validateSearchQuery(user.blockQuery, 'User blockQuery');
    }
    user.password = PasswordHelper.cryptPassword(user.password);
    return connection.getRepository(UserEntity).save(user);
  }

  public async deleteUser(id: number): Promise<UserEntity> {
    const connection = await SQLConnection.getConnection();
    const user = await connection.getRepository(UserEntity).findOneBy({id});
    return await connection.getRepository(UserEntity).remove(user);
  }

  public async changeRole(id: number, newRole: UserRoles): Promise<UserEntity> {
    const connection = await SQLConnection.getConnection();
    const userRepository = connection.getRepository(UserEntity);
    const user = await userRepository.findOneBy({id});
    user.role = newRole;
    return userRepository.save(user);
  }

  public async updateSettings(id: number, settings: UserSettingsDTO): Promise<UserEntity> {
    const connection = await SQLConnection.getConnection();
    const userRepository = connection.getRepository(UserEntity);
    const user = await userRepository.findOneBy({id});

    if (!user) {
      throw new Error('User not found');
    }

    if (typeof settings.overrideAllowBlockList !== 'undefined') {
      user.overrideAllowBlockList = settings.overrideAllowBlockList;
    }

    if (typeof settings.allowQuery !== 'undefined') {
      if (settings.allowQuery) {
        SearchQueryUtils.validateSearchQuery(settings.allowQuery, 'User allowQuery');
      }
      user.allowQuery = settings.allowQuery ?? null;
    }

    if (typeof settings.blockQuery !== 'undefined') {
      if (settings.blockQuery) {
        SearchQueryUtils.validateSearchQuery(settings.blockQuery, 'User blockQuery');
      }
      user.blockQuery = settings.blockQuery ?? null;
    }

    if (settings.newPassword && settings.newPassword.length > 0) {
      user.password = PasswordHelper.cryptPassword(settings.newPassword);
    }

    return userRepository.save(user);
  }

}

1	import {UserDTO, UserRoles} from '../../../common/entities/UserDTO';
2	import {UserEntity} from './enitites/UserEntity';	1✔
3	import {SQLConnection} from './SQLConnection';	1✔
4	import {PasswordHelper} from '../PasswordHelper';	1✔
5	import {FindOptionsWhere} from 'typeorm';
6	import {UserSettingsDTO} from '../../../common/entities/UserSettingsDTO';
7	import {SearchQueryUtils} from '../../../common/SearchQueryUtils';	1✔
8
9	export class UserManager {	1✔
10
11
12	public async findOne(filter: FindOptionsWhere<UserEntity>): Promise<UserEntity> {
13	const connection = await SQLConnection.getConnection();	3✔
14	const pass = filter.password as string;	3✔
15	delete filter.password;	3✔
16	const user = await connection.getRepository(UserEntity).findOneBy(filter);	3✔
17
18	if (pass && !PasswordHelper.comparePassword(pass, user.password)) {	3!
UNCOV 19	throw new Error('No entry found');	×
20	}
21	return user;	3✔
22	}
23
24	public async find(filter: FindOptionsWhere<UserDTO>): Promise<UserEntity[]> {
UNCOV 25	const connection = await SQLConnection.getConnection();	×
UNCOV 26	return await connection.getRepository(UserEntity).findBy(filter);	×
27	}
28
29	public async createUser(user: UserDTO): Promise<UserEntity> {
30	const connection = await SQLConnection.getConnection();	16✔
31	// Validate search queries if provided
32	if (user.allowQuery) {	16!
UNCOV 33	SearchQueryUtils.validateSearchQuery(user.allowQuery, 'User allowQuery');	×
34	}
35	if (user.blockQuery) {	16!
36	SearchQueryUtils.validateSearchQuery(user.blockQuery, 'User blockQuery');	×
37	}
38	user.password = PasswordHelper.cryptPassword(user.password);	16✔
39	return connection.getRepository(UserEntity).save(user);	16✔
40	}
41
42	public async deleteUser(id: number): Promise<UserEntity> {
43	const connection = await SQLConnection.getConnection();	×
44	const user = await connection.getRepository(UserEntity).findOneBy({id});	×
UNCOV 45	return await connection.getRepository(UserEntity).remove(user);	×
46	}
47
48	public async changeRole(id: number, newRole: UserRoles): Promise<UserEntity> {
UNCOV 49	const connection = await SQLConnection.getConnection();	×
UNCOV 50	const userRepository = connection.getRepository(UserEntity);	×
UNCOV 51	const user = await userRepository.findOneBy({id});	×
UNCOV 52	user.role = newRole;	×
UNCOV 53	return userRepository.save(user);	×
54	}
55
56	public async updateSettings(id: number, settings: UserSettingsDTO): Promise<UserEntity> {
UNCOV 57	const connection = await SQLConnection.getConnection();	×
UNCOV 58	const userRepository = connection.getRepository(UserEntity);	×
UNCOV 59	const user = await userRepository.findOneBy({id});	×
60
UNCOV 61	if (!user) {	×
UNCOV 62	throw new Error('User not found');	×
63	}
64
UNCOV 65	if (typeof settings.overrideAllowBlockList !== 'undefined') {	×
UNCOV 66	user.overrideAllowBlockList = settings.overrideAllowBlockList;	×
67	}
68
UNCOV 69	if (typeof settings.allowQuery !== 'undefined') {	×
UNCOV 70	if (settings.allowQuery) {	×
UNCOV 71	SearchQueryUtils.validateSearchQuery(settings.allowQuery, 'User allowQuery');	×
72	}
UNCOV 73	user.allowQuery = settings.allowQuery ?? null;	×
74	}
75
UNCOV 76	if (typeof settings.blockQuery !== 'undefined') {	×
UNCOV 77	if (settings.blockQuery) {	×
UNCOV 78	SearchQueryUtils.validateSearchQuery(settings.blockQuery, 'User blockQuery');	×
79	}
UNCOV 80	user.blockQuery = settings.blockQuery ?? null;	×
81	}
82
UNCOV 83	if (settings.newPassword && settings.newPassword.length > 0) {	×
UNCOV 84	user.password = PasswordHelper.cryptPassword(settings.newPassword);	×
85	}
86
UNCOV 87	return userRepository.save(user);	×
88	}
89
90	}

bpatrik / pigallery2 / 17474164690

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous