How to use the typeorm.getRepository function in typeorm

await transactionalEntityManager.query('SET FOREIGN_KEY_CHECKS=0;');
          }
          for (const metadata of metadatas) {
            if (['mysql'].includes((await getManager()).connection.options.type)) {
              await transactionalEntityManager.query(`TRUNCATE TABLE ${metadata.tableName}`);
            } else {
              await transactionalEntityManager.query(`TRUNCATE "${metadata.tableName}" CASCADE`);
            }
          }
          if (['mysql'].includes((await getManager()).connection.options.type)) {
            await transactionalEntityManager.query('SET FOREIGN_KEY_CHECKS=1;');
          }
        });
      } else {
        for (const entity of entities) {
          await getRepository(entity).clear();
        }
      }

      debug('test', chalk.bgRed('*** Cleaned successfully ***'));

      await permissions.ensurePreservedPermissionsInDb(); // re-do core permissions

      oauth.generalChannel = 'soge__';
      oauth.generalOwners = ['soge__', '__owner__'];
      oauth.broadcasterUsername = 'broadcaster';
      oauth.botUsername = 'bot';
      oauth.botId = '12345';

      oauth.broadcasterId = '54321';
      tmi.ignorelist = [];

clusteredChatIn(`${message} [${sender.username}]`);
    }

    const isModerated = await parse.isModerated();
    if (!isModerated && !isIgnored(sender)) {
      if (!skip && !isNil(sender.username)) {
        const subCumulativeMonths = function(senderObj) {
          if (typeof senderObj.badgeInfo === 'string' && senderObj.badgeInfo.includes('subscriber')) {
            const match = senderObj.badgeInfo.match(/subscriber\/(\d+)/);
            if (match) {
              return Number(match[1]);
            }
          }
          return undefined; // undefined will not change any values
        };
        const user = await getRepository(User).findOne({
          where: {
            userId: sender.userId,
          },
        }) || new User();
        user.userId = Number(sender.userId);
        user.username = sender.username;
        if (!user.isOnline) {
          joinpart.send({ users: [sender.username], type: 'join' });
        }
        user.isOnline = true;
        user.isVIP = typeof sender.badges.vip !== 'undefined';
        user.isFollower = user.isFollower ?? false;
        user.isModerator = user.isModerator ?? typeof sender.badges.moderator !== 'undefined';
        user.isSubscriber = user.isSubscriber ?? typeof sender.badges.subscriber !== 'undefined';
        user.messages = user.messages ?? 0;
        user.subscribeTier = String(typeof sender.badges.subscriber !== 'undefined' ? 0 : user.subscribeTier);

async list (opts) {
    const alias = await getRepository(AliasEntity).find({ visible: true, enabled: true });
    const output = (alias.length === 0 ? translate('alias.list-is-empty') : translate('alias.list-is-not-empty').replace(/\$list/g, (_.map(_.orderBy(alias, 'alias'), 'alias')).join(', ')));
    sendMessage(output, opts.sender, opts.attr);
  }

const data: TaskInput[] = ctx.request.body;

  const response: OperationResult[] = [];

  for await (const item of data) {
    try {
      if (item.descriptionUrl) {
        try {
          new url.URL(item.descriptionUrl);
        } catch (e) {
          const message = `[${item.descriptionUrl}] is not url`;
          response.push({ status: 'failed', value: message });
          continue;
        }
      }
      const result = await getRepository(Task).save(item);
      response.push({ status: 'created', value: result.id });
    } catch (e) {
      logger.error(e);
      response.push({ status: 'failed', value: item.name });
    }
  }

  setResponse(ctx, OK, response);
};

type: match.type as 'global' | 'user',
      },
    });
    if (!cooldown) {
      const message = await prepare('cooldowns.cooldown-not-found', { command: match.command });
      sendMessage(message, opts.sender, opts.attr);
      return false;
    }

    if (type === 'type') {
      cooldown[type] = cooldown[type] === 'global' ? 'user' : 'global';
    } else {
      cooldown[type] = !cooldown[type];
    }

    await getRepository(CooldownEntity).save(cooldown);

    let path = '';
    const status = cooldown[type] ? 'enabled' : 'disabled';

    if (type === 'isModeratorAffected') {
      path = '-for-moderators';
    }
    if (type === 'isOwnerAffected') {
      path = '-for-owners';
    }
    if (type === 'isSubscriberAffected') {
      path = '-for-subscribers';
    }
    if (type === 'isFollowerAffected') {
      path = '-for-followers';
    }

export const update = async (ctx) => {
    try {
        const { id, category } = ctx.request.body
        if (!id) {
            throw new Error('id不能为空')
        }
        if (!category) {
            throw new Error('分类名不能为空')
        }
        const compCategoryRepository = getRepository(CompCategory)
        const compCategory = await compCategoryRepository.findOne(id)
        if (!compCategory) {
            throw new Error('分类不存在')
        }
        compCategory.category = category
        compCategory.updateUser = 'admin'

        await compCategoryRepository.save(compCategory)

        ctx.send({
            code: 0,
            message: 'success',
            data: ''
        })
    } catch (error) {
        ctx.send({

const roles: { [key: string]: 'student' | 'mentor' | 'coursemanager' } = {};
  result.students?.forEach(student => {
    roles[(student.course as Course).id] = 'student';
  });
  result.mentors?.forEach(mentor => {
    roles[(mentor.course as Course).id] = 'mentor';
  });

  const courseManagers = result.courseManagers as CourseManager[];
  courseManagers.forEach((courseManager: any) => {
    roles[(courseManager.course as Course).id] = 'coursemanager';
  });

  const userId = result.id!;
  const [taskOwner, courseUsers] = await Promise.all([
    getRepository(CourseTask)
      .createQueryBuilder('courseTask')
      .select('"courseTask"."id" AS "courseTaskId", "course"."id" AS "courseId"')
      .leftJoin(Stage, 'stage', '"stage"."id" = "courseTask"."stageId"')
      .leftJoin(Course, 'course', '"course"."id" = "stage"."courseId"')
      .leftJoin(User, 'user', '"user"."id" = "courseTask"."taskOwnerId"')
      .where(`"courseTask"."checker" = 'taskOwner' AND "user"."githubId" = '${id}'`)
      .getRawMany(),
    getRepository(CourseUser)
      .createQueryBuilder('courseUser')
      .where('"courseUser"."userId" = :userId', { userId })
      .getMany(),
  ] as const);

  const coursesRoles = flatMap(courseUsers, u => {
    const result = [];
    if (u.isJuryActivist) {

static async update(args: any, ctx: Context) {
    const article = new Article
    article.id = args.id
    article.title = args.title
    article.abstract = args.abstract
    article.description =  args.description
    article.typeId = args.typeId
    article.isTop = args.isTop
    article.tag = args.tag
    article.updatedAt = Date.now()
    article.updatedBy = ctx.state['CUR_USER'].id
    const result = await getRepository(Article).save(article)
    return result
  }

const errorMsg = 'Wrong payload: githubId courseId & type are required';

      handleError({ logger, errorMsg, ctx });
      return;
    }

    if (type === 'mentor' && (isNaN(maxStudentsLimit) || maxStudentsLimit < 2)) {
      const errorMsg = 'Incorrect maxStudentsLimit';
      handleError({ logger, errorMsg, ctx });
      return;
    }

    try {
      const [user, course, existingRegistry] = (await Promise.all([
        getRepository(User).findOne({ where: { githubId }, relations: ['mentors', 'students'] }),
        getRepository(Course).findOne(Number(courseId)),
        getRepository(Registry).findOne({ where: { userId, courseId: Number(courseId) } }),
      ])) as [User, Course, Registry];

      if (existingRegistry && existingRegistry.userId === userId) {
        setResponse(ctx, OK, existingRegistry);
        return;
      }

      let registryPayload: Partial = {
        comment,
        type,
        user,
        course,
        status: 'pending',
      };

users = users.sort(() => Math.random());
    } else {
      users = users.sort(o => -(new Date(o.createdAt).getTime()));
    }

    const toReturn: QueueEntity[] = [];
    let i = 0;
    for (const user of users) {
      const isNotFollowerEligible = !user.isFollower && (this.eligibilityFollowers);
      const isNotSubscriberEligible = !user.isSubscriber && (this.eligibilitySubscribers);
      if (isNotFollowerEligible && isNotSubscriberEligible) {
        continue;
      }

      if (i < opts.amount) {
        await getRepository(QueueEntity).remove(user);
        toReturn.push(user);
      } else {
        break;
      }
      i++;
    }
    return toReturn;
  }