Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
import { Container } from 'typedi';
import { EntityRepository, Repository } from 'typeorm';
import { Role, RoleMapping, User } from '../entities';
import { RoleRepository } from '../repositories';
@EntityRepository(RoleMapping)
export class RoleMappingRepository extends Repository {
public async addRoleMapping(user: User, role: Role): Promise {
try {
if (role) {
const roleMapping = new RoleMapping(role, user);
const savedRoleMapping = await this.save(roleMapping);
delete savedRoleMapping.user; // remove the user property to avoid circular
return savedRoleMapping;
}
} catch (error) {
throw error;
}
}
}
import { OperatingSystem } from '@lxdhub/db';
import { Connection, EntityRepository, Repository } from 'typeorm';
@EntityRepository(OperatingSystem)
export class OperatingSystemRepository extends Repository { }
import { EntityRepository, getManager, SelectQueryBuilder } from 'typeorm';
import { ObjectType } from 'typeorm/common/ObjectType';
import { TypeOrmCommandRepository } from '../../../../common/database/type-orm/type-orm.command.repository';
import { UserCommandRepository } from '../../domain/user.command.repository';
import { User } from '../../domain/user';
@EntityRepository()
export class TypeOrmUserCommandRepository extends TypeOrmCommandRepository implements UserCommandRepository {
constructor() {
super(getManager());
}
/**
* @param {number} id
* @returns {Promise}
*/
public async byId(id: number): Promise {
return this.createQueryBuilder().andWhere('u.id = :id').setParameter('id', id).getOne();
}
/**
* @param {User} user
import { EntityRepository, getManager, SelectQueryBuilder } from 'typeorm';
import { ObjectType } from 'typeorm/common/ObjectType';
import { TypeOrmCommandRepository } from './type-orm.command.repository';
import { ProjectSkillCommandRepository } from '../../../../domains/project-skill/project-skill.command.repository';
import { ProjectSkill } from '../../../../domains/project-skill/project-skill';
@EntityRepository()
export class TypeOrmProjectSkillCommandRepository extends TypeOrmCommandRepository implements ProjectSkillCommandRepository {
constructor() {
super(getManager());
}
/**
* @param {number} id
* @returns {Promise}
*/
public async byId(id: number): Promise {
return this.createQueryBuilder().andWhere('ps.id = :id').setParameter('id', id).getOne();
}
/**
* @param {ProjectSkill} projectSkill
import { EntityRepository, getManager, SelectQueryBuilder } from 'typeorm';
import { ObjectType } from 'typeorm/common/ObjectType';
import { TypeOrmQueryRepository } from '../../../../../../common/database/type-orm/type-orm.query.repository';
import { ProjectCategory } from '../../domain/project-category';
import { ProjectCategoryNotFoundException } from '../../domain/project-category-not-found.exception';
@EntityRepository()
export class TypeOrmProjectCategoryQueryRepository extends TypeOrmQueryRepository implements TypeOrmProjectCategoryQueryRepository {
constructor() {
super(getManager('query'));
}
/**
* @returns {Promise}
*/
public getAll(): Promise {
return this.createQueryBuilder().getMany();
}
/**
* @param {number} id
* @returns {Promise}
import { Architecture } from '@lxdhub/db';
import { Connection, EntityRepository, Repository } from 'typeorm';
@EntityRepository(Architecture)
export class ArchitectureRepository extends Repository { }
exchange: MasterPairEntity['exchange'];
name: MasterPairEntity['name'];
baseAsset: MasterPairEntity['baseAsset'];
quoteAsset: MasterPairEntity['quoteAsset'];
amountPrecision: MasterPairEntity['amountPrecision'];
pricePrecision: MasterPairEntity['pricePrecision'];
maxOrderAmount: MasterPairEntity['maxOrderAmount'];
maxOrderPrice: MasterPairEntity['maxOrderPrice'];
}
export interface PairPrecision {
amountPrecision: MasterPairEntity['amountPrecision'];
pricePrecision: MasterPairEntity['pricePrecision'];
}
@EntityRepository(MasterPairEntity)
export class MasterPairRepository extends Repository {
async findByPair(pair: string): Promise {
return this.findOne({ where: { name: pair } });
}
async insertNewPair(params: MasterPairEntityCreateParams): Promise {
return this.save(params as MasterPairEntity, { reload: false });
}
async insertNewPairs(params: MasterPairEntityCreateParams[]): Promise {
return this.save(params as MasterPairEntity[], { reload: false });
}
async getPrecisionByPair(pair: string): Promise {
const rs = await this.createQueryBuilder()
.select('price_precision', 'pricePrecision')
import { EntityRepository, getManager, SelectQueryBuilder } from 'typeorm';
import { ObjectType } from 'typeorm/common/ObjectType';
import { Feedback } from '../../../../domains/feedback/feedback';
import { TypeOrmQueryRepository } from './type-orm.query.repository';
import { FeedbackQueryRepository } from '../../../../domains/feedback/feedback-query.repository';
import { FeedbackNotFoundException } from '../../../../domains/feedback/feedback-not-found.exception';
@EntityRepository()
export class TypeOrmFeedbackQueryRepository extends TypeOrmQueryRepository implements FeedbackQueryRepository {
constructor() {
super(getManager('query'));
}
/**
* @returns {Promise}
*/
public async getAll(): Promise {
return this.createQueryBuilder().getMany();
}
/**
* @param {number} id
* @returns {Promise}
import { User } from 'entities';
import { UserNotFoundException } from 'exceptions';
import { Logger } from 'services';
import { Inject, Service } from 'typedi';
import { EntityRepository } from 'typeorm';
import { RegisterInput } from 'types';
import { TokenHelper } from 'utils';
import { BaseRepository } from '../BaseRepository';
@Service()
@EntityRepository(User)
export class UserRepository extends BaseRepository {
@Inject()
private logger: Logger;
public async findByUsernameOrEmail({
username,
email
}: {
username?: string;
email?: string;
}): Promise {
let user;
if (username) {
user = await this.findOne({ where: { username } });
}
if (email) {
import { EntityRepository, getManager, SelectQueryBuilder } from 'typeorm';
import { ObjectType } from 'typeorm/common/ObjectType';
import { TypeOrmQueryRepository } from './type-orm.query.repository';
import { ProjectImageQueryRepository } from '../../../../domains/project-image/project-image.query.repository';
import { ProjectImage } from '../../../../domains/project-image/project-image';
import { ProjectImageNotFoundException } from '../../../../domains/project-image/project-image-not-found.exception';
@EntityRepository()
export class TypeOrmProjectImageQueryRepository extends TypeOrmQueryRepository implements ProjectImageQueryRepository {
constructor() {
super(getManager('query'));
}
/**
* @returns {Promise}
*/
public getAll(id: number): Promise {
return this.createQueryBuilder().andWhere('pi.projectId = :id').setParameter('id', id).getMany();
}
/**
* @param {number} id
* @returns {Promise}