Question

由于我对Angular（v6.0），RxJs（v6.0）和可观察对象的总体经验不足，在过去的一周中引起了相当大的头痛。

组件使用的服务需要输出数据模型集合，但这样做需要四个单独的api调用，而且我遇到了相关数据的问题，可以选择阻止数据模型的返回。

基本流量

第一个api调用获取主要实体并创建初始数据模型集合。
第二次api调用将获得相关数据并将其添加到数据模型中。
第三个api调用将获得相关数据（如果存在）并将其添加到数据模型。
第四个 api调用将获取与最新相关的数据来自第三个api调用的条目。然后收集数据模型返回。

设计

对于第二个，第三个和第四个api调用，批处理查询方法是根据ID集合使用，以减少通话次数，没关系，因为我们一次只请求10、20条记录。

期望

如果第一个api调用未返回任何主要实体，以下呼叫将不会发生。
始终会为第二个api调用返回数据。
如果第三个api调用未返回任何相关数据，那么这不是问题，但是应该返回数据模型集合。
如果第三个api调用未返回任何相关数据，则不会发生第四个api调用，但应返回数据模型集合。

问题

确保在没有结果时返回数据模型集合发现发生第三和第四次api调用。
我无法更改api。

已知

我没有太多的错误处理方式。
可能有很多错误，对不起。
这是一条长链，最好将其分成较小的块。
我对JavaScript的使用经验很生疏。

尝试

我已经广泛研究了'* map'函数和'forkJoin'，但是使用RxJ不能使任何东西正常工作大多数示例适用于低于6.0的版本，因此很难翻译。

代码
我希望将其简化，但在这里我们调用api的方式很重要。

return this.agentService.GetByFilter(query)
  .pipe(
    map(agents => {
      let deployments : AgentDeployment[] = [];

      for(let i = 0; i < agents.length; ++i) {          
        deployments.push(new AgentDeployment(agents[i].id, agents[i].name, agents[i].tags));
      };

      return deployments;
    }),
    map(deployments => {
      // Getting related tags assoiciated with the agent

      let tagIds : Array<number> = [];

      // Get tag id's
      for(let i = 0; i < deployments.length; ++i) {          
        if (deployments[i].tagIds) {
          for(let y = 0; y < deployments[i].tagIds.length; ++y) {
            if (!tagIds.includes(deployments[i].tagIds[y])) {
              tagIds.push(deployments[i].tagIds[y]);
            }              
          };
        }
      }

      // Get the tags associated with the agents
      let filter = new Filter();
      filter.Field = 'ID';
      filter.Value = tagIds.join(',');

      // Get tags using list of tag id's
      return this.tagService.GetByFilter(filter).pipe(
        map(tags => {        
          if (tags.length) {
            for(let i = 0; i < tags.length; ++i) {     
              // Find the agent
              deployments.forEach(deployment => {
                if (deployment.tagIds && deployment.tagIds.includes(tags[i].id)) {
                  deployment.tags.push(tags[i]);
                }
              });
            }              
          }
          return deployments;
        }));
    }),
    mergeMap(deployments => deployments),
    map(deployments => {
      // Getting deployments related to the agent, an agent may not have any deployment packages associated

      let agentIds : Array<number> = [];

      // Get tags
      for(let i = 0; i < deployments.length; ++i) {          
        if (deployments[i].id) {
            agentIds.push(deployments[i].id);
        }
      }

      // Get the deployment packages for the agents
      let filter = new Filter();
      filter.Field = 'AgentId';
      filter.Value = agentIds.join(',');

      // Get agent deployment packages using list of agent id's
      return this.agentDeploymentPkgService.GetByFilter(filter)
        .mergeMap(packages =>  packages)
        .groupBy(pkg => pkg.id)            
        .map(pkg$ => {
          if (pkg$) {
            // Add packages to agent deployment
            pkg$.map(pkg => {
            // Find the agent
            let i : number = deployments.findIndex(agent => agent.id == pkg$.key);

              if (pkg.deploymentPackageIds) {
                // Keep last deployment ID handy
                deployments[i].lastDeploymentId = Math.max.apply(null, pkg.deploymentPackageIds);;
                deployments[i].deployments.push(new Deployment(pkg.id, pkg.name))
              }
            }); 
          }
          return deployments;
        });
    }),
    mergeMap(deployments => deployments),
    map(deployments => {
      // Get the logs for the most recent deployment package for the agent, may not exist if no recent deployment package

      let deploymentPackageIds : Array<number> = [];

      // Get tags
      for(let i = 0; i < deployments.length; ++i) {          
        if (deployments[i].id) {
          deploymentPackageIds.push(deployments[i].lastDeploymentId);
        }
      }

      // Get the deployment packages for the agents
      let filter = new Filter();
      filter.Field = 'DeploymentPackageId';
      filter.Value = deploymentPackageIds.join(',');

      // Get agent deployment log based on the last 
      this.logService.GetByFilter(filter)
        .map(logs => {
          logs.forEach(log => {
            // Find the agent
            let i : number = deployments.findIndex(agent => agent.lastDeploymentId == log.deploymentPackageId);

            deployments[i].logId = log.id;
            deployments[i].status = log.lastReportedStatusMessage;
          });

          return deployments;
        });


      return deployments;
    })
  );

Answer 1

这里的快速答案是

forkJoin

检查文档

Rxjs - ForkJoin

需要进行多个HTTP调用并合并结果

1 个答案: