Angular 对象id未添加到ngrx存储实体

我从一个post-effect操作中获得一系列帖子，我尝试将其添加到商店中。问题是只添加了数组中的第一个post对象，这是错误的，因为缺少id（它从后端返回为_id，但我对组实体进行了相同的设置，并且工作正常，id是根据_id属性自动添加的）。 任何帮助都将不胜感激

后期效果：

getGroupPosts$ = createEffect(() =>
        this.actions$.pipe(
            ofType(PostActions.getGroupPosts),
            switchMap(action => {
                return this.http
                    .get<{ posts: Post[] }>
                    (`${BACKEND_URL}/posts/${action.groupId}?pageSize=${action.pageSize}&currentPage=${action.pageNumber}`)
                    .pipe(
                        map(response => {
                            this.store.dispatch(GroupActions.groupPostsLoaded({ groupId: action.groupId }));
                            return {
                                type: PostActions.GET_GROUP_POSTS_SUCCESS,
                                posts: response.posts
                            };
                        }),
                        catchError(err => this.handleError(err, PostActions.GET_GROUP_POSTS_FAILED))
                    );
            })
        )
    );

    getGroupPostsSucess$ = createEffect(() =>
        this.actions$
            .pipe(
                ofType(PostActions.getGroupPostsSuccess),
                map(action => {
                    return {
                        type: SpinnerActions.STOP_SPINNER
                    };
                })
            )
    );

getGroupPosts$=createEffect（（）=>
此.actions$管道(
类型（PostActions.getGroupPosts），
开关映射（操作=>{
返回此文件。http
.得到
（`${BACKEND\u URL}/posts/${action.groupId}？pageSize=${action.pageSize}¤tPage=${action.pageNumber}`）
.烟斗(
映射（响应=>{
this.store.dispatch（GroupActions.groupPostsLoaded（{groupId:action.groupId}））；
返回{
类型：PostActions.GET\u GROUP\u POSTS\u SUCCESS，
帖子：response.posts
};
}),
catchError（err=>this.handleError（err，PostActions.GET\u GROUP\u POSTS\u失败））
);
})
)
);
GetGroupPostsAccess$=createEffect（（）=>
这是我的行动$
.烟斗(
类型（PostActions.GetGroupPostSuccess），
映射（操作=>{
返回{
类型：SpinGenerations.STOP\u微调器
};
})
)
);

柱减速器：

import { EntityState, createEntityAdapter } from '@ngrx/entity';
import { Post } from 'src/app/models/post.model';
import { createReducer, on } from '@ngrx/store';
import * as PostActions from './post.actions';

export interface PostState extends EntityState<Post> { }

export const adapter = createEntityAdapter<Post>();

export const initPostsState = adapter.getInitialState();

export const postReducer = createReducer(
    initPostsState,
    on(PostActions.createPostSuccess, (state, action) => {
        return adapter.addOne(action.post, { ...state });
    }),
    on(PostActions.getGroupPostsSuccess, (state, action) => {
        console.log(action);

        return adapter.addMany(action.posts, { ...state });
    })
);

export const {
    selectAll,
} = adapter.getSelectors();

从'@ngrx/entity'导入{EntityState，createEntityAdapter}；
从'src/app/models/Post.model'导入{Post}；
从'@ngrx/store'导入{createReducer，on}；
从“/post.actions”导入*作为PostActions；
导出接口PostState扩展EntityState{}
export const adapter=createEntityAdapter（）；
export const initPostsState=adapter.getInitialState（）；
export const postReducer=createReducer(
初始后状态，
on（PostActions.createPostSuccess，（状态、操作）=>{
返回adapter.addOne（action.post，{…state}）；
}),
on（PostActions.GetGroupPostsAccess，（状态，操作）=>{
控制台日志（操作）；
返回adapter.addMany（action.posts，{…state}）；
})
);
出口常数{
选择全部，
}=adapter.getSelectors（）；

群体效应：

getTopicGroups$ = createEffect(() =>
    this.actions$
        .pipe(
            ofType(GroupActions.getTopicGroups),
            switchMap(action => {
                this.topic = action.topic;
                return this.http
                    .get<{ groups: Group[], count: number }>(
                        `${BACKEND_URL}/groups/${this.topic}?pageNumber=${action.pageNumber}&pageSize=${action.pageSize}`)
                    .pipe(
                        map(response => {
                            return {
                                type: GroupActions.GET_TOPIC_GROUPS_SUCCESS,
                                groups: response.groups,
                                topic: this.topic,
                                count: response.count,
                                groupsLoaded: response.groups.length
                            };
                        }),
                        catchError(err => this.handleError(err, GroupActions.GET_TOPIC_GROUPS_FAILED))
                    );
            })
        )
);

getTopicGroupSuccess$ = createEffect(() =>
    this.actions$
        .pipe(
            ofType(GroupActions.getTopicGroupsSuccess),
            map(action => {
                return {
                    type: SpinnerActions.STOP_SPINNER
                };
            })
        )
);

getTopicGroups$=createEffect（（）=>
这是我的行动$
.烟斗(
类型（GroupActions.getTopicGroups），
开关映射（操作=>{
this.topic=action.topic；
返回此文件。http
.得到(
`${BACKEND\u URL}/groups/${this.topic}？pageNumber=${action.pageNumber}&pageSize=${action.pageSize}`）
.烟斗(
映射（响应=>{
返回{
类型：GroupActions.GET\u TOPIC\u GROUPS\u SUCCESS，
组：response.groups，
topic:this.topic，
count:response.count，
groupsLoaded:response.groups.length
};
}),
catchError（err=>this.handleError（err，GroupActions.GET\u TOPIC\u GROUPS\u失败））
);
})
)
);
getTopicGroupSuccess$=createEffect（（）=>
这是我的行动$
.烟斗(
类型（GroupActions.GetTopicGroupsAccess），
映射（操作=>{
返回{
类型：SpinGenerations.STOP\u微调器
};
})
)
);

组减速器：

export interface GroupState extends EntityState<Group> {
    topicsLoaded: {
        topic: string,
        count: number,
        groupsLoaded: number
    }[];
}

export const adapter = createEntityAdapter<Group>();

export const initialGroupState = adapter.getInitialState({
    topicsLoaded: []
});

export const groupReducer = createReducer(
    initialGroupState,
    on(GroupActions.getTopicGroupsSuccess, (state, action) => {
        let oldTopics;
        let newTopics;
        // Check if 1st batch of groups have already been loaded //
        const oldGroupsLoaded = state.topicsLoaded.find(g => g.topic === action.topic);

        if (!oldGroupsLoaded) {
            // Add topic to group entity //
            newTopics = [...state.topicsLoaded];
            newTopics.push({
                topic: action.topic,
                count: action.count,
                groupsLoaded: action.groupsLoaded
            });
        } else {
            // Update group entity //
            const index = [...state.topicsLoaded].indexOf(oldGroupsLoaded);
            oldTopics = [...state.topicsLoaded];
            oldTopics[index] = {
                ...state.topicsLoaded[index],
                groupsLoaded: state.topicsLoaded[index].groupsLoaded + action.groupsLoaded
            };
        }
        return adapter.addMany(action.groups,
            {
                ...state,
                topicsLoaded: oldGroupsLoaded ? oldTopics : newTopics
            });
    }),

导出接口GroupState扩展EntityState{
主题：{
主题：字符串，
计数：数字，
groupsLoaded:编号
}[];
}
export const adapter=createEntityAdapter（）；
export const initialGroupState=adapter.getInitialState({
topicsLoaded:[]
});
export const groupReducer=createReducer(
初始组状态，
on（GroupActions.GetTopicGroupsAccess，（状态，操作）=>{
让老话题；
让新托皮克；
//检查是否已加载第一批组//
constOldGroupsLoaded=state.topicsloadded.find（g=>g.topic==action.topic）；
如果（！oldGroupsLoaded）{
//将主题添加到组实体//
newTopics=[…state.topicsloadded]；
推({
主题：action.topic，
count:action.count，
groupsLoaded:action.groupsLoaded
});
}否则{
//更新组实体//
const index=[…state.topicsloadded].indexOf（oldGroupsLoaded）；
oldTopics=[…state.topicsLoaded]；
旧主题[索引]={
…state.topicsLoaded[索引]，
groupsLoaded:state.topicsLoaded[index]。groupsLoaded+action.groupsLoaded
};
}
返回adapter.addMany（action.groups，
{
……国家，
加载的主题：旧组已加载？旧主题：新主题
});
}),

事实证明，您必须为实体适配器上的selectId属性创建一个方法……但如果您向其添加属性（如组实体适配器中的属性），您就不会这样做

导出接口PostState扩展EntityState{
选择posted:string；
}
export const selectPostId=（post:post）=>post.\u id；
导出常量适配器=createEntityAdapter({
selectId:selectPostId
});

export interface PostState extends EntityState<Post> {
    selectPostId: string;
}

export const selectPostId = (post: Post) => post._id;

export const adapter = createEntityAdapter<Post>({
    selectId: selectPostId
});