Angular Firestore&x2B；NgRx+；实体

我正在与Ngrx+Firestore进行斗争。我在我的应用程序中使用了a，一切都很完美。 当我想在CRUD操作中添加另一个“查询”操作时，问题就出现了。我已经设置好了一切（新动作和新效果），但我不知道如何处理减速机和

公开竞赛：Observable=this.contestStore.select（_fromcontest.selectAll）位

我的目标是一个查询获取所有文档，另一个查询仅获取符合条件的文档（过滤查询）

比赛的一部分

export const QUERY = '[contest] query contests';
export const QUERY_MINE = '[contest] query my contests';

[...]

// Initial Query
export class Query implements Action {
  readonly type = QUERY;
  constructor() {}
}

// Query only my contests
export class QueryMine implements Action {
  readonly type = QUERY_MINE;
  constructor() {}
}
[...]

export type contestActions =
  Query | QueryMine | Added | Modified | Removed | Update | Create | Delete | CreateSuccess | UpdateSuccess | DeleteSuccess | Failure ;
...

比赛的一部分

@Effect()
  query$: Observable<Action> = this.actions$.ofType(contestActions.QUERY).pipe(
    switchMap(action => {
      return this.afs.collection<IContest>('contests').stateChanges();
    }),
    mergeMap((actions: DocumentChangeAction[]) =>  actions),
    map( (action: DocumentChangeAction) => {
      return {
        type: `[contest] ${action.type}`,
        payload: {
          id: action.payload.doc.id,
          ...action.payload.doc.data()
        }
      };
    })
  );

  @Effect()
  queryMine$: Observable<Action> = this.actions$.ofType(contestActions.QUERY_MINE).pipe(
    switchMap(action => {
      return this.afs.collection<Icontest>('contests', ref => {
        return ref.where('owner', '==', this._auth.cachedUser.uid);
      }).stateChanges();
    }),
    mergeMap((actions: DocumentChangeAction[]) =>  actions),
    map( (action: DocumentChangeAction) => {
      return {
        type: `[contest] ${action.type}`,
        payload: {
          id: action.payload.doc.id,
          ...action.payload.doc.data()
        }
      };
    })
  );
...

@Effect（）
query$：Observable=this.actions$of type（contestActions.query）.pipe(
开关映射（操作=>{
返回此.afs.collection（'contests'）.stateChanges（）；
}),
合并映射（（操作：DocumentChangeAction[]）=>操作），
映射（（操作：DocumentChangeAction）=>{
返回{
类型：`[contest]${action.type}`，
有效载荷：{
id:action.payload.doc.id，
…action.payload.doc.data（）
}
};
})
);
@效果（）
queryMine$：Observable=this.actions$of type（contestActions.QUERY\u MINE）.pipe(
开关映射（操作=>{
返回此.afs.collection（'竞赛'，ref=>{
返回ref.where（'owner'，'='，this.\u auth.cachedUser.uid）；
}).stateChanges（）；
}),
合并映射（（操作：DocumentChangeAction[]）=>操作），
映射（（操作：DocumentChangeAction）=>{
返回{
类型：`[contest]${action.type}`，
有效载荷：{
id:action.payload.doc.id，
…action.payload.doc.data（）
}
};
})
);
...

而contest.reducer.ts是：

export const contestAdapter = createEntityAdapter<IContest>();
export interface State extends EntityState<IContest> { }
export const initialState: State = contestAdapter.getInitialState();

export function contestReducer(
  state: State = initialState,
  action: actions.contestActions) {

    switch (action.type) {

      case actions.ADDED:
        return contestAdapter.addOne(action.payload, state);

      case actions.MODIFIED:
        return contestAdapter.updateOne( {
          id: action.payload.id,
          changes: action.payload,
        }, state);

      case actions.REMOVED:
      return contestAdapter.removeOne(action.payload.id, state);


      default:
      return state;
    }
  }

      // Create the default selectors
      export const getContestState = createFeatureSelector<State>('contests');

      export const {
        selectIds,
        selectEntities,
        selectAll,
        selectTotal,
      } = contestAdapter.getSelectors(getContestState);

export const contestAdapter=createEntityAdapter（）；
导出接口状态扩展EntityState{}
export const initialState:State=contestAdapter.getInitialState（）；
导出函数(
状态：状态=初始状态，
行动：行动。行动）{
开关（动作类型）{
案例行动.新增：
返回confightadapter.addOne（action.payload，state）；
案例行动.修改：
返回CompetAdapter.updateOne（{
id:action.payload.id，
更改：action.payload，
}，国家）；
已删除的案例操作：
返回confightadapter.removeOne（action.payload.id，state）；
违约：
返回状态；
}
}
//创建默认选择器
export const getcontesticstate=createFeatureSelector（'contestics'）；
出口常数{
SelectID，
选择实体，
选择全部，
选择总计，
}=竞赛适配器.getSelectors（getContestState）；

要获取所有文档，我调用
contesticstore.dispatch（new\u contesticsactions.Query（））
，要仅获取我的文档，我调用
contesticstore.dispatch（new\u contesticsactions.QueryMine（））
但是，如何将每个查询的结果分配给不同的变量，例如：


公开竞赛：可观察=此.contestStore.select（\u fromcontest.selectAll）

publicmycontests:observeable=this.contestStore.select（？？？）
?


请帮忙
 您的查询$effect将加载所有实体。因此，您不需要新的查询操作，但需要新的选择器

要创建新选择器，需要在状态中创建一个空间来存储可引用的uid

export interface State extends EntityState<IContest> {
  currentUserUid: string;
}

新减速器壳体：

case actions.LOGIN:
  return { ...state, currentUserUid: action.payload };

新选择器：

export const getCurrentUserUid = createSelector(
  getContestState,
  state => state.currentUserUid
);

export const getMine = createSelector(
  selectAll,
  getCurrentUserUid,
  (contests, currentUserUid) =>
    contests.filter(contest => contest.owner === currentUserUid)
);

用法：

登录时发送登录操作

public mycontests: Observable<Icontest[]> = this.contestStore.select(_fromcontest.getMine);

publicmycontests:observeable=this.contestStore.select（\u fromcontest.getMine）；

ps.我建议创建一个AuthStore。
你是生命的救星！！谢谢！仅供参考，我正在将ngrx与Firestore（它有一个Auth模块）结合起来，想进一步解释一下AuthStore吗？在实际尝试了您的解决方案之后，我有3点意见，希望您能帮助我：1-我的用户ID来自一个服务的可观察数据。如何将该值传递给ngrx选择器o action或redux？2-使用该技术，通过Array类的filter方法过滤“竞赛”。想象一下，我有数千个这样复杂的对象，这将是没有效率的。如果我更喜欢数据库进行过滤，我应该如何继续？3-你能再解释一下AuthStore吗？再次谢谢你的帮助。您可以订阅AuthService中的Observable，并在检测到更改时发送到存储区。2。如果直接查询数据库，则可以在另一种状态下获得结果。3.如果您创建了一个AuthStore来存储用户信息以及您是否登录，而不是使用AuthService，那么您最好满足使用Redux的目的。好的，但是我在哪里传递“用户ID”的值呢？
public mycontests: Observable<Icontest[]> = this.contestStore.select(_fromcontest.getMine);