Question

我正在尝试实现一种过滤具有多对多关系的表中数据的方法。

我有以下表格job，job_category和category。

到目前为止，我正在考虑使用job_id对job_category进行查询，然后使用该结果通过IN（）添加条件，但是我也找不到任何实现此选项的方法。

问题：

如何在Loopback 4中实现ManytoMany关系？
如何使用IN过滤查询？

PD 我可以使用$ inq作为问题编号2。

filter.where = {
   ...filter.where,
   id: {inq: [2, 7]},
};

Answer 1

您可以使用hasManyThrough关系在Loopback 4中实现多对多关系。 hasManyThrough关系是hasMany关系的扩展。

当前，此功能是一个等待接受的请求请求。

https://github.com/strongloop/loopback-next/pull/2359

但是，此请求请求的代码已打包，可以通过以下方式安装和使用。

npm install --save @loopback/repository@git+https://git@github.com/codejamninja/loopback-next.git#npm/codejamninja/has-many-through-using-has-many@1.11.0-rc.1

models / patient.model.ts

import { Entity, model, property, hasMany } from '@loopback/repository';
import { Appointment, Patient } from '../models';

@model()
export class Physician extends Entity {
  @property({
    type: 'string',
    id: true
  })
  id?: string;

  @hasMany(() => Patient, { through: () => Appointment })
  patients: Patient[];
}

repositories / Patient.repository.ts

import {
  DefaultCrudRepository,
  HasManyThroughRepositoryFactory,
  repository
} from '@loopback/repository';
import { inject, Getter } from '@loopback/core';
import { MemoryDataSource } from '../datasources';
import { Patient, Physician } from '../models';
import { AppointmentRepository, PhysicianRepository } from '../repositories';

export class PatientRepository extends DefaultCrudRepository<
  Patient,
  typeof Patient.prototype.id
> {
  public readonly physicians: HasManyThroughRepositoryFactory<
    Physician,
    typeof Patient.prototype.id
  >;

  constructor(
    @inject('datasources.memory')
    dataSource: MemoryDataSource,
    @repository.getter('AppointmentRepository')
    getAppointmentRepository: Getter<AppointmentRepository>,
    @repository.getter('PhysicianRepository')
    getPhysicianRepository: Getter<PhysicianRepository>
  ) {
    super(Patient, dataSource);
    this.physicians = this.createHasManyThroughRepositoryFactoryFor(
      'physicians',
      getPhysicianRepository,
      getAppointmentRepository // notice the through repository getter
    );
  }
}

下面的链接中有一个基本示例。

https://github.com/codejamninja/medical-practice-api

请注意，此API可能会在接受拉取请求之前更改。

您可以在以下链接中了解有关这种关系的更多信息。

https://loopback.io/doc/en/lb3/HasManyThrough-relations.html https://guides.rubyonrails.org/association_basics.html#the-has-many-through-association

Answer 2

根据问题的上下文，可以在lb4中实现多对多关系，如下所示。

工作模型（示例）-

@model({
  name: 'jobs',
})
export class Job extends Entity {
  @property({
    type: 'number',
    id: true,
  })
  id: number;

  @property({
    type: 'string',
    required: true,
  })
  name: string;

  // Other columns of the table.....

  constructor(data?: Partial<Job>) {
    super(data);
  }
}

类别模型（示例）-

@model({
  name: 'categories',
})
export class Category extends Entity {
  @property({
    type: 'number',
    id: true,
  })
  id: number;

  @property({
    type: 'string',
    required: true,
  })
  name: string;

  // Other columns of the table.....

  constructor(data?: Partial<Category>) {
    super(data);
  }
}

在“职位类别”关系模型中，我们将同时与“职位模型”和“类别”模型实现属于关系。这样可以确保m：n关系。

@model({
  name: 'job_categories',
})
export class JobCategory extends Entity {
  @property({
    type: 'number',
    id: true,
  })
  id: number;

  @belongsTo(() => Job)
  job_id: number;

  @belongsTo(() => Category)
  category_id: number;

  constructor(data?: Partial<JobCategory>) {
    super(data);
  }
}

现在，使用lb4 CLI，您可以为作业类别模型创建存储库和REST控制器，并在其中使用find方法来获取数据。不幸的是，lb4中尚未实现在find类的Filter类中包含参数。它仍然在制品。请参阅Loopback-next存储库中的this线程以获取更新。在此之前，您可能必须添加自定义逻辑t控制器或存储库类才能实现此目的。下面是我建议的两种方法。

配置属于存储库中的关系（请参阅文档here），并在控制器内使用它来获取对相关数据的响应（请参阅实现here）。您可能需要为此创建自己的响应模型。为此，我们创建了自己的DTO。您还可以返回“ any”类型作为对此的响应，但是不建议这样做。
如果需要，您可以执行自己的联接查询。那是本机查询方法。但是，不幸的是，尚未实现存储库类中的execute函数。参见here。它在dts中可用。因此，我们实施了一项工作，直到实施。我们创建了一个基本存储库类，该类将由应用程序中的所有存储库类继承（将所有 extends DefaultCrudRepository 替换为 extends AppDefaultCrudRepository ）。这是基本存储库的实现。

    export abstract class AppDefaultCrudRepository<
      T extends Entity,
      ID
    > extends DefaultCrudRepository<T, ID> {
      constructor(
        entityClass: typeof Entity & {
          prototype: T;
        },
        dataSource: AppDataSource,
      ) {
        super(entityClass, dataSource);
      }

      execute(
        command: Command,
        parameters: NamedParameters | PositionalParameters,
        options?: Options,
      ): Promise<AnyObject> {
        // Commented below statement until it is implemented in lb4
        // return super.execute(command, parameters, options);
        return this.dataSource.execute(command, parameters, options);
      }
    }

希望这对您的问题1有所帮助。对于问题2，您已经提到了该方法。可行。

环回4：多对多关系

2 个答案: