1.2.3 Receivables Implementation
Case 1
We want the list of Purchase Orders status wise linked with logged in party. To achieve this we fire the list of purchase orders with below specified query parameters and then group them by status (grouping purchase orders of same status) and finally calculate the sum of purchase order amount for each group.
Prop_id: purchaseorders.Amount.Status
URL:
/digx-scf/v1/aggregator/purchaseorders
Request Parameters:
data: Amount
grouping: Status
q:1. Role of the logged in party that is used to get list of purchase orders(B or S) .
Response:
{ "aggregatedData":
{
"resource": "purchaseorders","groups":
[{
"identifiers": ["ACCEPTED"],
"intervals": [{
"amount": {
"currency": "EUR",
"amount":132708027.4107700091004397884741905500050052069127559661865234375
},
"count": 70
}] },
{
"identifiers": ["RAISED"],
"intervals": [{
"amount": {
"currency": "EUR",
"amount": 4071865.5212500003207022947204762886030948720872402191162109375
},
"count": 61
}] },
{
"identifiers": ["REJECTED"], "intervals":
[{
"amount": {
"currency": "EUR",
"amount": 20205.5700000000016314682937945690355263650417327880859375
},
"count": 7
}] },
{
"identifiers": ["CANCELLED"],
"intervals": [{
"amount": {
"currency": "EUR",
"amount":1653850.000000000133537625401913828682154417037963867187500
},
"count": 4
}]
}] }
} Here, “groups” is the array which contains list of data after grouping. i.e. different groups. Inside group, “identifiers” represents the unique Id of that group. Since, grouping is done on the basis of purchase order status, id contains purchase order’s status.
Intervals contains the actual data (in this case, the total amount for each status wise) at various intervals. Here since no interval is specified there will always be one element in intervals array.
Case 2
We want the list of Top 10 associated parties purchase order status wise linked with logged in party. To achieve this we fire the list of purchase orders with below specified query parameters and then group them by associated party id (grouping purchase orders of same associated party), then group them by purchase order status(grouping purchase orders of same status for every associated party) and finally calculate the sum of purchase order amount for each group.
Prop_id: purchaseorders.Amount.AssociatedParty,Status
URL:
/digx-scf/v1/aggregator/purchaseorders
Request Parameters:
data: Amount
grouping: AssociatedParty,Status
q:
- Role of the logged in party that is used to get list of purchase orders(B or S) .
- Invoice status - ACCEPTED, RAISED.
Response:
{ "aggregatedData":
{
"resource": "purchaseorders", "groups":
[{
"identifiers":
["98DCBD13A0F3EA4F5EDE19325B4CD2D30A1C949B838D0E171B1B~***000153~LINKINVA23Dec",
"ACCEPTED"],
"intervals": [{
"amount": {
"currency": "EUR",
"amount":
109765554.800000008862854272706499614287167787551879882812500
},
"count": 1
}] },
{
"identifiers": ["E6AFBD17A6F1717F4C5BCEE75406C9BB37C8DF99577A~***462~ABZ
Solutions", "ACCEPTED"],
"intervals": [{
"amount": {
"currency": "EUR",
"amount":
22904335.7207700002345062100683747985385707579553127288818359375
},
"count": 62
}] },
{
"identifiers": ["E6AFBD17A6F1717F4C5BCEE75406C9BB37C8DF99577A~***462~ABZ Solutions", "RAISED"],
"intervals": [{
"amount": {
"currency": "EUR",
"amount":4066573.1572500003202749707664764855508110485970973968505859375
},
"count": 45
}] },
{
"identifiers": ["98DCBD13A0F3EB4D5ADBFB7E68621176D18D733CA71A0B515B69~***000077~Septoneparty",
"ACCEPTED"],
"intervals": [{
"amount": {
"currency": "EUR",
"amount":22000.000000000001776356839400250464677810668945312500000
},
"count": 1
}] },
{
"identifiers": ["E6AFBC14A1F57BA066463EE6C10B5E5D5324274D7899~***716~AugBuyer",
"ACCEPTED"],
"intervals": [{
"amount": {
"currency": "EUR",
"amount":10636.8900000000008588596500658240984193980693817138671875
},
"count": 5 }] },
{
"identifiers":
["98DCBD13A0F3EB4C5BD1361685D7E30CC39EA19106076A3CB8DB~***000066~LinkInvBuyCp",
"ACCEPTED"],
"intervals": [{
"amount": {
"currency": "EUR",
"amount": 5500.000000000000444089209850062616169452667236328125000
},
"count": 1
}] },
{
"identifiers": ["E6AFBC14A1F57BA066463EE6C10B5E5D5324274D7899~***716~AugBuyer",
"RAISED"],
"intervals": [{
"amount": {
"currency": "EUR",
"amount": 5292.36400000000042732395399980305228382349014282226562500
},
"count": 16
}]
}] }}
Here, “groups” is the array which contains list of data after grouping. i.e. different groups. Inside group, “identifiers” represents the unique Id of that group. Since, multiple grouping is done, id is the list containing 2 elements. First is the combination of associated party id (hashed value), associated party id (display value) and associated party name, all tilde(~) separated and second Is the purchase order status.
Intervals contains the actual data (in this case, the total amount for each associated party, status wise) at various intervals. Here since no interval is specified there will always be one element in intervals array.
Case 1
We want the list of unmatched payments currency wise for the logged in party. To achieve this we fire the list of payments with below specified query parameters and then group them by currency (grouping payments of same currency), then group them by payment type(grouping payments of same type for every currency) and finally calculate the sum of payment amount for each group.
Prop_id: payments.Amount.Currency,Type
URL:
/digx-cms/v1/aggregator/payments
Request Parameters:
data: Amount
grouping: Currency,Type
q:1.Payment Status - UNMATCHED .
Response:
{ "aggregatedData":
{
"resource": "payments", "groups":
[{
"identifiers": ["GBP", "C"],
"intervals": [{
"amount": {
"currency": "GBP",
"amount": 835619
},
"count": 7
}] },
{
"identifiers": ["USD", "D"],
"intervals": [{
"amount": {
"currency": "USD",
"amount": 346103
},
"count": 8
}] },
{
"identifiers": ["GBP", "D"],
"intervals": [{
"amount": {
"currency": "GBP",
"amount": 333903
},
"count": 7
}] },
{
"identifiers": ["USD", "C"],
"intervals": [{
"amount": {
"currency": "USD",
"amount": 40200
},
"count": 5
}]
}]
}}
Here, “groups” is the array which contains list of data after grouping. i.e. different groups. Inside group, “identifiers” represents the unique Id of that group. Since, multiple grouping is done, id is the list containing 2 elements. First is the currency and second is the payment type.
Intervals contains the actual data (in this case, the total amount for each currency, payment type wise) at various intervals. Here since no interval is specified there will always be one element in intervals array.
Case 2
We want the list of unreconciled invoices currency wise for the logged in party. To achieve this we fire the list of invoices with below specified query parameters and then group them by currency (grouping invoices of same currency), then group them by role wise(grouping invoices of same role for every currency) and finally calculate the sum of invoice amount for each group.
Prop_id: invoices.Amount.Currency,Role
URL:/digx-invoice/v1/aggregator/invoices
Request Parameters:
data: Amount
grouping: Currency,Role
q:1.Payment Status - UNPAID .
Response:
{ "aggregatedData":
{
"resource": "invoices", "groups":
[{
"identifiers": ["GBP", "B"],
"intervals": [{
"amount": {
"currency": "GBP",
"amount": 1047165452.0
},
"count": 281
}] },
{
"identifiers": ["GBP", "S"],
"intervals": [{
"amount": {
"currency": "GBP",
"amount": 4742388.0
},
"count": 75
}] },
{
"identifiers": ["USD", "B"],
"intervals": [{
"amount": {
"currency": "USD",
"amount": 17900.0
},
"count": 5
}] },
{
"identifiers": ["USD", "S"],
"intervals": [{
"amount": {
"currency": "USD",
"amount": 5000.0
},
"count": 3
}] },
{
"identifiers": ["INR", "S"],
"intervals": [{
"amount": {
"currency": "INR",
"amount": 5000.0
},
"count": 1
}] },
{
"identifiers": ["LAK", "B"],
"intervals": [{
"amount": {
"currency": "LAK",
"amount": 4401
},
"count": 37
}] },
{
"identifiers": ["LAK", "S"],
"intervals": [{
"amount": {
"currency": "LAK",
"amount": 2024
},
"count": 7
}]
}] }}
Here, “groups” is the array which contains list of data after grouping. i.e. different groups. Inside group, “identifiers” represents the unique Id of that group. Since, multiple grouping is done, id is the list containing 2 elements. First is the currency and second is the associated party role.
Intervals contains the actual data (in this case, the total amount for each currency, associated party role wise) at various intervals. Here since no interval is specified there will always be one element in intervals array.
Case 3
We want the list of unreconciled cashflows currency wise for the logged in party. To achieve this we fire the list of cashflows with below specified query parameters and then group them by currency (grouping cashflows of same currency), then group them by cashflow type(grouping cashflows of same type for every currency) and finally calculate the sum of cashflow amount for each group.
Prop_id: cashflows.Amount.Currency,Type
URL:
/digx-cms/v1/aggregator/cashflows
Request Parameters:
data: Amount
grouping: Currency,Type
q:1.Reconciliation Status - UNRECONCILED .
Response:
{ "aggregatedData":
{
"resource": "cashflows", "groups":
[{
"identifiers": ["LAK", "I"],
"intervals": [{ "amount": {
"currency": "LAK",
"amount": 573993369
},
"count": 82
}] },
{
"identifiers": ["GBP", "I"],
"intervals": [{
"amount": {
"currency": "GBP",
"amount": 59712749
},
"count": 194
}] },
{
"identifiers": ["USD", "I"],
"intervals": [{
"amount": {
"currency": "USD",
"amount": 36663338
},
"count": 177
}] },
{
"identifiers": ["GBP", "O"],
"intervals": [{
"amount": {
"currency": "GBP",
"amount": 1666225
},
"count": 67
}] },
{
"identifiers": ["LBP", "I"],
"intervals": [{
"amount": {
"currency": "LBP",
"amount": 991545
},
"count": 4 }]
},
{
"identifiers": ["USD", "O"],
"intervals": [{
"amount": {
"currency": "USD",
"amount": 51044.33
},
"count": 264
}] },
{
"identifiers": ["EUR", "I"],
"intervals": [{
"amount": {
"currency": "EUR",
"amount": 28547.17
},
"count": 34
}] },
{
"identifiers": ["LAK", "O"],
"intervals": [{
"amount": {
"currency": "LAK",
"amount": 4567
},
"count": 2
}]
}] }}
Here, “groups” is the array which contains list of data after grouping. i.e. different groups. Inside group, “identifiers” represents the unique Id of that group. Since, multiple grouping is done, id is the list containing 2 elements. First is the currency and second is the cashflow type.
Intervals contains the actual data (in this case, the total amount for each currency, cashflow type wise) at various intervals. Here since no interval is specified there will always be one element in intervals array.
Case 4
We want the list of payments status wise for the logged in party. To achieve this we fire the list of payments with below specified query parameters and then group them by status (grouping payments of same status), then group them by type(grouping payments of same type for every status) and finally calculate the sum of payment amount for each group.
Prop_id: payments.Amount.Status,Type
URL:
/digx-cms/v1/aggregator/payments
Request Parameters:
data: Amount
grouping: Status,Type
q:1.Payment Date – from date and to date .
Response:
{ "aggregatedData":
{
"resource": "payments", "groups":
[{
"identifiers": ["MATCHED", "C"],
"intervals": [{
"amount": {
"currency": "USD",
"amount": 291300
},
"count": 57
}] },
{
"identifiers": ["PART_MATCHED", "C"],
"intervals": [{
"amount": {
"currency": "GBP",
"amount": 9700
},
"count": 1
}] },
{
"identifiers": ["PART_MATCHED", "D"],
"intervals": [{
"amount": {
"currency": "GBP",
"amount": 32900
},
"count": 6
}] },
{
"identifiers": ["RECON_NA", "D"],
"intervals": [{
"amount": {
"currency": "USD",
"amount": 5200
},
"count": 1
}] },
{
"identifiers": ["MATCHED", "D"],
"intervals": [{
"amount": {
"currency": "GBP",
"amount": 580900
},
"count": 41
}]
}]
}} Here, “groups” is the array which contains list of data after grouping. i.e. different groups. Inside group, “identifiers” represents the unique Id of that group. Since, multiple grouping is done, id is the list containing 2 elements. First is the payment status and second is the payment type.
Intervals contains the actual data (in this case, the total amount for each status, payment type wise) at various intervals. Here since no interval is specified there will always be one element in intervals array.
Case 5
We want the list of unmatched payments entity wise for the logged in party. To achieve this we fire the list of payments with below specified query parameters and then group them by payment entity (grouping payments of same entity), then group them by payment type(grouping payments of same type for every entity) and finally calculate the sum of payment amount for each group.
Prop_id: payments.Amount.Entity,Type
URL:/digx-cms/v1/aggregator/payments
Request Parameters:
data: Amount
grouping: Entity,Type
q:1.Payment Status - UNMATCHED .
Response:
{ "aggregatedData":
{ "resource":
"payments", "groups":
[{
"identifiers": ["E", "C"],
"intervals": [{
"amount": {
"currency": "GBP",
"amount": 140412
},
"count": 5
}] }, {
"identifiers": ["I", "C"],
"intervals": [{
"amount": {
"currency": "USD",
"amount": 735407
},
"count": 7
}] }, {
"identifiers": ["I", "D"],
"intervals": [{
"amount": {
"currency": "USD",
"amount": 553005
},
"count": 9
}] }, {
"identifiers": ["E", "D"],
"intervals": [{
"amount": {
"currency": "GBP",
"amount": 127001
},
"count": 6
}]
}]
}
}Here, “groups” is the array which contains list of data after grouping. i.e. different groups. Inside group, “identifiers” represents the unique Id of that group. Since, multiple grouping is done, id is the list containing 2 elements. First is the payment entity and second is the payment type.
Intervals contains the actual data (in this case, the total amount for each entity, payment type wise) at various intervals. Here since no interval is specified there will always be one element in intervals array.
Case 6
We want the list of payments allocation status wise for the logged in party. To achieve this we fire the list of payments with below specified query parameters and then group them by allocation status (grouping payments of same allocation status), then group them by payment type wise(grouping payments of same type for every allocation status) .
Prop_id: payments.Count.AllocationStatus,Type
URL:
/digx-cms/v1/aggregator/payments
Request Parameters:
data: Count
grouping: AllocationStatus,Type
q:1.Payment Date – from date and to date .
Response:
{ "aggregatedData":
{
"resource": "payments", "groups":
[{
"identifiers": ["FAILED", "C"],
"intervals": [{
"count": 3
}] },
{
"identifiers": ["UNALLOCATED", "C"],
"intervals": [{
"count": 55
}] },
{
"identifiers": ["UNALLOCATED", "D"],
"intervals": [{
"count": 47
}] },
{
"identifiers": ["FAILED", "D"],
"intervals": [{
"count": 1
}]
}]
}
}Here, “groups” is the array which contains list of data after grouping. i.e. different groups. Inside group, “identifiers” represents the unique Id of that group. Since, multiple grouping is done, id is the list containing 2 elements. First is the allocation status and second is the payment type.
Intervals contains the actual data (in this case, the total count for each allocation status, payment type wise) at various intervals. Here since no interval is specified there will always be one element in intervals array.
Case 7
We want the list of allocated transactions allocation type wise for the logged in party. To achieve this we fire the list of payments with below specified query parameters and then group them by allocation type (grouping payments of same allocation type), then group them by payment type(grouping payments of same type for every allocation type) .
Prop_id: allocations.Count.PaymentType,Type
URL:
/digx-cms/v1/aggregator/allocations
Request Parameters:
data: Count
grouping: PaymentType,Type
Response:
{ "aggregatedData":
{ "resource":
"allocations", "groups":
[{
"identifiers": ["C", "M"],
"intervals": [{
"count": 102
}] }, {
"identifiers": ["D", "M"],
"intervals": [{
"count": 50
}]
}]
}
}Here, “groups” is the array which contains list of data after grouping. i.e. different groups. Inside group, “identifiers” represents the unique Id of that group. Since, multiple grouping is done, id is the list containing 2 elements. First is the payment type and second is the allocation type.
Intervals contains the actual data (in this case, the total count for each payment type, allocation type wise) at various intervals. Here since no interval is specified there will always be one element in intervals array.
Parent topic: Implementation Details of Individual Service