当前位置: 首页 > 知识库问答 >
问题:

在 Mule ESB 中聚合两个有效负载

黎奇思
2023-03-14

我的mule代码在两张表上显示并得到一些细节。第一个是订单详细信息,我将其存储在一个流变量中,即order,另一个数据库将返回我存储在orderitem变量中的订单项详细信息。

我想基于一个条件聚合两个有效负载。每个orderId都有订单项(存储在flowVars.orderitem中),并将这些订单项映射到各自的orderID。

flowVars.order值如下

[{partnerId=e83185e9f33e4234ba9eaa81dba515ad, orderId=12345, orderDate=2017-02-28 16:41:41.0, id=22}, {partnerId=e83185e9f33e4234ba9eaa81dba515ad, orderId=123456, orderDate=2017-02-28 16:41:41.0, id=23}, {partnerId=e83185e9f33e4234ba9eaa81dba515ad, orderId=11111, orderDate=2017-02-28 16:41:41.0, id=24}, {partnerId=e83185e9f33e4234ba9eaa81dba515ad, orderId=321123, orderDate=2017-05-19 15:25:41.0, id=26}]

flowVars.orderitem值如下

 [{productCode=ELT-LP-ICND1-020067, orderId=12345, quantity=10, id=14}, {productCode=ELT-IP-ICND1-1.0, orderId=12345, quantity=11, id=15}, {productCode=ELT-LP-ICND1-020067, orderId=123456, quantity=12, id=16}, {productCode=ELT-IP-ICND1-1.0, orderId=123456, quantity=13, id=17}, {productCode=ELT-LP-ICND1-020067, orderId=11111, quantity=14, id=18}, {productCode=ELT-IP-ICND1-1.0, orderId=11111, quantity=15, id=19}, {productCode=ELT-LP-ICND2-020067, orderId=321123, quantity=5, id=20}]

预期产出

[
  {
    "orderId": "12345",
    "orderDate": "2017-02-28T16:41:41",
    "partnerId": "e83185e9f33e4234ba9eaa81dba515ad",
    "orderItems": [
       {
          "productCode": "ELT-LP-ICND1-020067",
          "quantity": "10"
        },
        {
          "productCode": "ELT-IP-ICND1-1.0",
          "quantity": "11"
        }
    ]
  },
  {
    "orderId": "123456",
    "orderDate": "2017-02-28T16:41:41",
    "partnerId": "e83185e9f33e4234ba9eaa81dba515ad",
    "orderItems": [
        {
          "productCode": "ELT-LP-ICND1-020067",
          "quantity": "12"
        },
        {
          "productCode": "ELT-IP-ICND1-1.0",
          "quantity": "13"
        }
    ]
  },
  {
    "orderId": "11111",
    "orderDate": "2017-02-28T16:41:41",
    "partnerId": "e83185e9f33e4234ba9eaa81dba515ad",
    "orderItems": [
       {
          "productCode": "ELT-LP-ICND1-020067",
          "quantity": "14"
        },
        {
          "productCode": "ELT-IP-ICND1-1.0",
          "quantity": "15"
        }
    ]
  },
  {
    "orderId": "321123",
    "orderDate": "2017-05-19T15:25:41",
    "partnerId": "e83185e9f33e4234ba9eaa81dba515ad",
    "orderItems": [
      {
          "productCode": "ELT-LP-ICND1-020067",
          "quantity": "5"
        }
    ]
  }
]

在这里,我需要显示订单的相应订单项目详细信息。所以基本上我需要结合两个有效载荷。

我试过使用数据编织,但运气不佳。

数据编织代码:

%dw 1.0
%output application/json
%var mergeddata = flowVars.orderitem groupBy $.orderId  
---
 flowVars.order map ((data,index) ->
     {
    orderid: data.orderId,
    partnerid: data.partnerId,
    orderdate: data.orderDate,
    order: flowVars.orderitem default [] map ((data1 ,indexOf)  ->
           {
            (productcode: data1.productCode) when (data1.orderId == data.orderId),      
            (quantity: data1.quantity) when (data1.orderId == data.orderId) ,
            (id: data1.id) when (data1.orderId == data.orderId) 
            }

            )})  

和转换后的输出:

{
    "orderid": "12345",
    "partnerid": "e83185e9f33e4234ba9eaa81dba515ad",
    "orderdate": "2017-02-28T16:41:41",
    "order": [
      {
        "productcode": "ELT-LP-ICND1-020067",
        "quantity": 10,
        "id": 14
      },
      {
        "productcode": "ELT-IP-ICND1-1.0",
        "quantity": 11,
        "id": 15
      },
      {

      },
      {

      },
      {

      },
      {

      },
      {

      }
    ]
  },
  {
    "orderid": "123456",
    "partnerid": "e83185e9f33e4234ba9eaa81dba515ad",
    "orderdate": "2017-02-28T16:41:41",
    "order": [
      {

      },
      {

      },
      {
        "productcode": "ELT-LP-ICND1-020067",
        "quantity": 12,
        "id": 16
      },
      {
        "productcode": "ELT-IP-ICND1-1.0",
        "quantity": 13,
        "id": 17
      },
      {

      },
      {

      },
      {

      }
    ]
  },
  {
    "orderid": "11111",
    "partnerid": "e83185e9f33e4234ba9eaa81dba515ad",
    "orderdate": "2017-02-28T16:41:41",
    "order": [
      {

      },
      {

      },
      {

      },
      {

      },
      {
        "productcode": "ELT-LP-ICND1-020067",
        "quantity": 14,
        "id": 18
      },
      {
        "productcode": "ELT-IP-ICND1-1.0",
        "quantity": 15,
        "id": 19
      },
      {

      }
    ]
  },
  {
    "orderid": "321123",
    "partnerid": "e83185e9f33e4234ba9eaa81dba515ad",
    "orderdate": "2017-05-19T15:25:41",
    "order": [
      {

      },
      {

      },
      {

      },
      {

      },
      {

      },
      {

      },
      {
        "productcode": "ELT-LP-ICND2-020067",
        "quantity": 5,
        "id": 20
      }
    ]
  }
]

正如您所看到的,我几乎已经完成了,并且能够将订单项目详细信息映射到相应的orderId,但是在转换之后,我仍然得到一些空白值。

谁能帮我达到预期的产量。提前感谢!!!

共有1个答案

萧韬
2023-03-14

您需要过滤 flowVars.orderitem 映射,而不是完全迭代它,并且仅在 orderId 匹配时才打印值。

    order: ((flowVars.orderitem default []) filter (data.orderId == $.orderId)) map ((data1 ,indexOf) -> {
            productcode: data1.productCode,      
            quantity: data1.quantity
            id: data1.id
    })

然后,您也可以删除所有这些“when”语句。

 类似资料:
  • 问题内容: 如何合并两个保持BST属性的二叉搜索树? 如果我们决定从一棵树中取出每个元素并将其插入到另一个元素中,则此方法的复杂度将为,其中是我们已拆分的树的节点数(例如),是的结点数。另一棵树(例如)。此操作后,只有一个具有节点。 我的问题是:我们能做得比好吗? 问题答案: 纳夫的答案还有更多细节: 将BST展平为排序列表为O(N) 它只是整个树上的“有序”迭代。 两者都做O(n1 + n2)

  • 我试图实现的是将两个聚合字段的总和sum(DiscoverCountOld)显示为VisitsDiscoverdOld,并将sum(DiscoverCount)显示为VisitsDiscover作为新列,而不是这两个字段

  • 使用MongoDB 3.4。10和猫鼬4.13。6我能够计算用户模型上两个阵列的大小: 我的用户所在的位置(per) {“_id”:ObjectId(“5a2b21e63023c6117085c240”),“右投票”:[2],“左投票”:[1,6]} {“_id”:ObjectId(“5a2c0d68efde3416bc8b7020”),“右投票”:[2],“左投票”:[1]} 在这里,我得到了预

  • 很简单地说,我有 假设我每个有3000个 创建新的

  • 我希望在我们的web应用程序中实现一些高效(即具有良好性能)的逻辑来进行有效负载签名。HTML5客户端的目标是保证接收到的有效负载的内容确实是我们后端生成的内容。 我们不想使用共享盐进行有效负载哈希生成,因为用户可以轻松打开HTML5源并找到盐短语。 我们现在已经实现了RSA签名,我们的后端使用其私钥添加有效负载签名,我们的HTML5客户端使用其烘焙的公钥验证有效负载签名。然而,签名生成过程需要2

  • 问题内容: 有一个对话列表,每个对话都有一个消息列表。每个消息都有一个不同的字段和一个字段。我们需要考虑的是,在对话的第一条消息中使用了动作,在几条消息中使用了动作之后,过了一会儿,依此类推(有一个聊天机器人意图列表)。 将对话的消息动作分组将类似于: 问题: 我需要使用ElasticSearch创建一个报告,该报告将返回每次会话的;接下来,我需要对类似的东西进行分组并添加一个计数;最终将导致as