How to convert below rule data to json data

Question

Hi All, Please help on below -

I'm trying to pass my below rule to JsonToExcel Smart Service which needs a json data. How do I pass this rule so my output looks something like this:

expected output sample -

"[ { ""Name"": ""Robert"",""age"": ""30"" }]"

Rule I want to convert to json by passing from process parameters in start process-

a!localVariables(
  local!data: a!refreshVariable(
    /*RMSP1-2105 - Added rule input - refresh to getlatest data*/
    value: a!queryEntity(
      entity: cons!RMO_ENTITY_VW_EMPLOYEES,
      query: a!query(
        selection: if(
          rule!RMO_RULE_isNullorEmpty(ri!columns),
          rule!RMO_RULE_employeeSelection(),
          a!querySelection(
            columns: a!forEach(
              items: ri!columns,
              expression: a!queryColumn(field: fv!item)
            )
          )
        ),
        logicalExpression: a!queryLogicalExpression(
          operator: "AND",
          /* additional filter logic if time status is involved */
          /* this can all be skipped if there aren't aly time statuses selected */
          logicalExpressions: {
            rule!RMO_RULE_generatetimeQueryLogicalExpression(
              statusList: ri!filters.timeStatus,
              istimeMetField: "hasMettime",
              timeField: "timeDateTime",
              eodToday: ri!eodToday
            ),
            rule!RMO_RULE_generatetimeQueryLogicalExpression(
              statusList: ri!filters.qatimeStatus,
              istimeMetField: "isQAtimeMet",
              timeField: "qatime",
              eodToday: ri!eodToday
            ),
            rule!RMO_RULE_generatetimeQueryLogicalExpression(
              statusList: ri!filters.ectimeStatus,
              istimeMetField: "isErrCorrecttimeMet",
              timeField: "errorCorrectiontime",
              eodToday: ri!eodToday
            ),
            /*rule!RMO_RULE_generatetimeQueryLogicalExpression(*/
            /*statusList: ri!filters.ectimeStatus,*/
            /*istimeMetField: "hasMetQctime",*/
            /*timeField: "qctime",*/
            /*eodToday: ri!eodToday*/
            /*),*/
            rule!RMO_RULE_generatetimeQueryLogicalExpression(
              statusList: ri!filters.qctimeStatus,
              istimeMetField: "hasMetQctime",
              timeField: "qctime",
              eodToday: ri!eodToday
            ),
            /*Start RMSF-4153*/
            rule!RMO_RULE_generatetimeQueryLogicalExpression(
              statusList: ri!filters.ecQctimeStatus,
              istimeMetField: "isEcQctimeMet",
              timeField: "ecQctime",
              eodToday: ri!eodToday
            ),
            /*End RMSF-4153*/
            /*Start RMSF-4180*/
            rule!RMO_RULE_generatetimeQueryLogicalExpression(
              statusList: ri!filters.qaEctimeStatus,
              istimeMetField: "isEcQatimeMet",
              timeField: "ecQatime",
              eodToday: ri!eodToday
            ),
            /*End RMSF-4180*/
            /*Cashier's Check visibility logic RMS-252*/
            a!queryLogicalExpression(
              operator: "OR",
              filters: {
                a!queryFilter(
                  field: "isGLConfirmed",
                  operator: "is null",
                  applyWhen: not(ri!filters.showNonConfirmedGL = true)
                ),
                a!queryFilter(
                  field: "isGLConfirmed",
                  operator: "=",
                  value: 1,
                  applyWhen: not(ri!filters.showNonConfirmedGL = true)
                ),
                a!queryFilter(
                  field: "isGLConfirmed",
                  operator: "=",
                  value: 0,
                  applyWhen: or(
                    ri!canViewNonConfirmedGL = true,
                    and(
                      ri!canViewNonConfirmedGL = true,
                      ri!filters.showNonConfirmedGL = true
                    )/*ri!isBranchServices*/
                    
                  )
                )
              }
            ),
            /* private Display (either Cashier's Check or Standard logic) */
            a!queryLogicalExpression(
              operator: "AND",
              filters: {
                a!queryFilter(
                  field: "isprivate",
                  operator: "in",
                  value: if(
                    not(
                      and(
                        ri!canViewprivate = true,
                        ri!filters.showOnlyprivate = true
                      )
                    ),
                    {0,1}, {1}
                  )
                ),
              },
              logicalExpressions: {
                a!queryLogicalExpression(
                  operator: "OR",
                  logicalExpressions: 
                  {
                    if(
                      ri!isBranchServices,
                      {
                        a!queryLogicalExpression(
                        operator: "AND",
                        filters: {
                          a!queryFilter(
                            field: "isGLConfirmed",
                            operator: "=",
                            value: 1,

                          ),
                          a!queryFilter(
                            field: "PaymentModeId",
                            operator: "=",
                            value: cons!RMO_INT_REF_REQUEST_TYPE_CASHIERS_CHECK,

                          )
                        }
                      ),
                      a!queryLogicalExpression(
                        operator: "AND",
                        filters: {
                          a!queryFilter(
                            field: "parentRoleAssigned",
                            operator: "=",
                            value: cons!RMO_TEXT_REF_EXTERNAL_TEAM_GDO_LPO
                          )
                        }
                      )
                      },
                      {}
                    ),
                    if( or(
                      ri!isRES,ri!isDocMgmt
                    ),
                    a!queryLogicalExpression(
                      operator: "AND",
                      filters: {


                        a!queryFilter(
                          field: "PaymentModeId",
                          operator: "in",
                          value: {
                            if(ri!isRES = true,
                            { cons!RMO_INT_REF_REQUEST_TYPE_DEPOSIT_COPY_CHECKS_DEPOSIT_SUBPOENA,
                            cons!RMO_INT_REF_REQUEST_TYPE_DEPOSIT_STAT_REQUEST_SUBPOENA},{}),
                            if(   ri!isDocMgmt = true, cons!RMO_INT_REF_REQUEST_TYPE_RES_DEPOSIT_DOC_COPY, {})
                          },

                        )
                      }
                    ),{}),

                    a!queryLogicalExpression(
                      operator: "AND",
                      filters: {


                        a!queryFilter(
                          field: "submittedBy",
                          operator: "=",
                          value: loggedInUser()
                        )
                      }
                    ),

                    if(
                      or(
                        and(
                          ri!canViewprivate,
                          or(ri!isPBDeposit,ri!isPBLoans,ri!isPBDocs,ri!isfcbLPO)
                        ),
                        and(
                          ri!canViewprivate,

                          not(
                            or(
                              ri!isASIABranch,
                              ri!isASIAPayments,
                              ri!isASIALoan,
                              /*ri!isGerLoan,*/
                              ri!isASIALoanQa
                            )
                          )

                        )

                      ),
                      a!queryLogicalExpression(
                        operator: "AND",
                        filters: {


                          if(
                            and(
                              ri!canViewprivate,
                              or(
                                ri!isPBDeposit,
                                ri!isPBLoans,
                                ri!isPBDocs,
                                ri!isfcbLPO
                              )
                            ),
                            a!queryFilter(
                              field: "roleAssigned",
                              operator: "in",
                              value: {
                                if(
                                  ri!isPBDeposit,
                                  cons!RMO_TEXT_REF_EXTERNAL_TEAMS_PB_DEPOSITS,
                                  if(
                                    ri!isPBLoans,
                                    cons!RMO_TEXT_REF_EXTERNAL_TEAM_PB_LOANS,
                                    if(
                                      ri!isPBDocs,
                                      cons!RMO_TEXT_REF_EXTERNAL_TEAM_PB_DOCS,
                                      if(
                                        ri!isfcbLPO,
                                        cons!RMO_TEXT_REF_EXTERNAL_TEAM_FCB_LEVIES_AND_GARNISHMENTS,
                                        {}
                                      )
                                    )
                                  )
                                )
                              },

                            ),
                            a!queryFilter(
                              field: "roleAssigned",
                              operator: "not in",
                              value: {
                                cons!RMO_TEXT_REF_EXTERNAL_TEAMS_ASIA_DEPOSIT_OPERATIONS,
                                cons!RMO_TEXT_REF_EXTERNAL_TEAMS_ASIALOAN,
                                cons!RMO_TEXT_REF_EXTERNAL_TEAM_ASIAPaymentServices,

                              },

                            )
                          )
                        }
                      ),{}),
                      if(
                        or(ri!canViewprivate<> true, ri!filters.showNonConfirmedGL <> true ),
                        a!queryLogicalExpression(
                          operator: "AND",
                          filters: {
                            a!queryFilter(
                              field: "isprivate",
                              operator: "=",
                              value: 0
                            ),
                          }
                        ),
                        {}
                      ),


                      a!queryLogicalExpression(
                        operator: "AND",
                        filters: {

                          a!queryFilter(
                            field: "submittedBy",
                            operator: "=",
                            value: loggedInUser(),
                            applyWhen: not(ri!isASIABranch, )
                          ),
                          a!queryFilter(
                            field: "roleAssigned",
                            operator: "=",
                            value: cons!RMO_TEXT_REF_EXTERNAL_TEAMS_ASIA_DEPOSIT_OPERATIONS
                          )
                        }
                      ),
                      a!queryLogicalExpression(
                        operator: "AND",
                        filters: {

                          a!queryFilter(
                            field: "submittedBy",
                            operator: "=",
                            value: loggedInUser(),
                            applyWhen: and(not(ri!isASIALoan), not(ri!isASIALoanQa))
                          ),
                          a!queryFilter(
                            field: "roleAssigned",
                            operator: "=",
                            value: cons!RMO_TEXT_REF_EXTERNAL_TEAMS_ASIALOAN
                          ),
                        },

                      ),
                      a!queryLogicalExpression(
                        operator: "AND",
                        filters: {

                          a!queryFilter(
                            field: "submittedBy",
                            operator: "=",
                            value: loggedInUser(),
                            applyWhen: and(not(ri!isASIALoan), not(ri!isASIALoanQa))
                          ),
                          a!queryFilter(
                            field: "parentRoleAssigned",
                            operator: "=",
                            value: cons!RMO_TEXT_REF_EXTERNAL_TEAMS_ASIALOAN
                          )
                        },

                      ),
                      if(
                        and(ri!canViewprivate, ri!isASIAPayments),
                        a!queryLogicalExpression(
                          operator: "AND",
                          filters: {

                            a!queryFilter(
                              field: "submittedBy",
                              operator: "=",
                              value: loggedInUser(),
                              applyWhen: not(ri!isASIAPayments)
                            ),
                            a!queryFilter(
                              field: "roleAssigned",
                              operator: "=",
                              value: cons!RMO_TEXT_REF_EXTERNAL_TEAM_ASIAPaymentServices
                            )
                          }
                        ),
                        {}
                      ),
                      if(
                        and(ri!canViewprivate, ri!isASIAFXOps),
                        a!queryLogicalExpression(
                          operator: "AND",
                          filters: {

                            a!queryFilter(
                              field: "submittedBy",
                              operator: "=",
                              value: loggedInUser(),
                              applyWhen: not(ri!isASIAFXOps)
                            ),
                            a!queryFilter(
                              field: "roleAssigned",
                              operator: "=",
                              value: cons!RMO_TEXT_REF_EXTERNAL_TEAM_ASIATransfer_TEAMS_VALUES[2]
                            )
                          }
                        ),
                        {}
                      )
                  }
                )
              }
            ), 
            if(
              and(
                rule!RMO_RULE_isNullorEmpty(ri!filters.assignee),
                rule!RMO_RULE_isNullorEmpty(ri!filters.isUnassigned)
              ),
              {},
              a!queryLogicalExpression(
                operator: "OR",
                filters: {
                  a!queryFilter(
                    field: "assignee",
                    operator: "IN",
                    value: ri!filters.assignee,
                    applyWhen: not(
                      rule!RMO_RULE_isNullorEmpty(ri!filters.assignee)
                    )
                  ),
                  a!queryFilter(
                    field: "assignee",
                    operator: "IS NULL",
                    applyWhen: ri!filters.isUnassigned = true
                  )
                }
              )
            ),
            /* Updated By Abhilash */
            if(
              rule!RMO_RULE_isNullorEmpty(ri!filters.TransferAmountCurrency),
              {},
              a!queryLogicalExpression(
                operator: "OR",
                filters: {
                  a!forEach(
                    items: ri!filters.TransferAmountCurrency,
                    expression: a!queryFilter(
                      field: "TransferAmount",
                      operator: "ends with",
                      value: fv!item
                    )
                  )
                },
                ignoreFiltersWithEmptyValues: true
              )
            ),
            /*RMSP2-5434*/
            if(
              rule!RMO_RULE_isNullorEmpty(ri!filters.sourceOfFunds),
              {},
                a!queryLogicalExpression(
                  operator: "OR",
                  filters: 
                  /*a!forEach(*/
                    /*items: ri!filters.sourceOfFunds,*/
                    /*expression: */
                    if(
                      ri!filters.sourceOfFunds= "Incoming Transfer",
                      {
                      a!queryFilter(
                        field: "sourceOfFunds",
                        operator: "includes",
                        value: concat(ri!filters.sourceOfFunds,",")
                      ),
                      a!queryFilter(
                        field: "sourceOfFunds",
                        operator: "ends with",
                        value: ri!filters.sourceOfFunds
                      )
                      },
                      a!queryFilter(
                        field: "sourceOfFunds",
                        operator: "includes",
                        value: ri!filters.sourceOfFunds
                      )
                    )
                  /*)*/
              )
            ),
          },
          /*
      **
      **
      * ALL OTHER FILTERS 
      * Add standard filters here that don't have extra conditional logic.
      **
      **
      */
          filters: {
            /* Status Filters */
            if(
              rule!RMO_RULE_isNullorEmpty(ri!filters.status),
              {
                a!queryFilter(
                  field: "status",
                  operator: "<>",
                  value: cons!RMO_TEXT_REF_REQUEST_STATUS_DRAFT
                ),
                a!queryFilter(
                  field: "status",
                  operator: "<>",
                  value: cons!RMO_TEXT_REF_REQUEST_STATUS_CANCELLED
                )
              },
              a!queryFilter(
                field: "status",
                operator: "IN",
                value: ri!filters.status
              )
            ),
            a!queryFilter(
              field: "PaymentModeId",
              operator: "IN",
              value: ri!filters.PaymentMode,
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.PaymentMode)
              )
            ),
            a!queryFilter(
              field: "RecordId",
              operator: "=",
              value: tointeger(
                cleanwith(ri!filters.RecordNumber, "0123456789")
              ),
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(
                  tointeger(
                    cleanwith(ri!filters.RecordNumber, "0123456789")
                  )
                )
              )
            ),
            a!queryFilter(
              field: "submittedBy",
              operator: "IN",
              value: ri!filters.submittedBy,
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.submittedBy)
              )
            ),
            a!queryFilter(
              field: "companyName",
              operator: "INCLUDES",
              value: ri!filters.companyName,
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.companyName)
              )
            ),
            a!queryFilter(
              field: "ContactNumber",
              operator: "INCLUDES",
              value: ri!filters.ContactNumber,
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.ContactNumber)
              )
            ),
            a!queryFilter(
              field: "cisNumber",
              operator: "INCLUDES",
              value: ri!filters.cisNumber,
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.cisNumber)
              )
            ),
            a!queryFilter(
              field: "PhoneTINEIN",
              operator: "includes",
              value: ri!filters.PhoneTINEIN,
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.PhoneTINEIN)
              )
            ),
            a!queryFilter(
              field: "agencyName",
              operator: "IN",
              value: ri!filters.agencyName,
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.agencyName)
              )
            ),
            a!queryFilter(
              field: "companyId",
              operator: "INCLUDES",
              value: ri!filters.companyId,
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.companyId)
              )
            ),
            a!queryFilter(
              field: "requestId",
              operator: "=",
              value: tointeger(ri!filters.requestId),
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(tointeger(ri!filters.requestId))
              )
            ),
            /*rmsf-4358 starts */
            a!queryFilter(
              field: "referenceId",
              operator: "=",
              value: ri!filters.referenceId,
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.referenceId)
              )
            ),
            /*rmsf-4358 ends */
            a!queryFilter(
              field: "submittedDateTime",
              operator: ">=",
              value: rule!RMO_RULE_getMidnightFromDate(date: ri!filters.submittedDateStart),
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.submittedDateStart)
              )
            ),
            a!queryFilter(
              field: "submittedDateTime",
              operator: "<=",
              value: rule!RMO_RULE_get1159PmFromDate(date: ri!filters.submittedDateEnd),
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.submittedDateEnd)
              )
            ),
            /* RMSP3-1724 Start*/
            /*a!queryFilter(*/
              /*field: "submittedDateTime",*/
              /*operator: ">=",*/
              /*value: rule!RMO_RULE_getMidnightFromDate(date: subtractmonths(now(), 13)),*/
              /*applyWhen: ri!filters.currentHistoricalData = "Current"*/
            /*),*/
            /*a!queryFilter(*/
              /*field: "submittedDateTime",*/
              /*operator: "<",*/
              /*value: rule!RMO_RULE_getMidnightFromDate(date: subtractmonths(now(), 13)),*/
              /*applyWhen: ri!filters.currentHistoricalData = "Historical"*/
            /*),*/
            /* RMSP3-1724 End*/
            a!queryFilter(
              field: "updatedDateTime",
              operator: ">=",
              value: rule!RMO_RULE_getMidnightFromDate(date: ri!filters.lastUpdatedDateStart),
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.lastUpdatedDateStart)
              )
            ),
            a!queryFilter(
              field: "updatedDateTime",
              operator: "<=",
              value: rule!RMO_RULE_get1159PmFromDate(date: ri!filters.lastUpdatedDateEnd),
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.lastUpdatedDateEnd)
              )
            ),
            a!queryFilter(
              field: "dueDate",
              operator: ">=",
              value: rule!RMO_RULE_getMidnightFromDate(date: ri!filters.reviewDateStart),
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.reviewDateStart)
              )
            ),
            a!queryFilter(
              field: "dueDate",
              operator: "<=",
              value: rule!RMO_RULE_get1159PmFromDate(date: ri!filters.reviewDateEnd),
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.reviewDateEnd)
              )
            ),
            a!queryFilter(
              field: "productTypeId",
              operator: "in",
              value: ri!filters.productType,
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.productType)
              )
            ),
            a!queryFilter(
              field: "implementedBy",
              operator: "in",
              value: ri!filters.implementedBy,
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.implementedBy)
              )
            ),
            if(
              ri!filters.needsAcknowledgement = true,
              {
                a!queryFilter(
                  field: "clarificationReceived",
                  operator: "=",
                  value: 1
                ),
                a!queryFilter(
                  field: "clarificationAcknowledged",
                  operator: "=",
                  value: 0
                )
              },
              {}
            ),
            if(
              ri!filters.allChildrenReady = true,
              {
                a!queryFilter(
                  field: "allChildrenReady",
                  operator: "=",
                  value: 1
                )
              },
              {}
            ),
            a!queryFilter(
              field: "roleAssigned",
              operator: "in",
              value: ri!filters.roleAssigned,
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.roleAssigned)
              )
            ),
            /* GDO*/
            a!queryFilter(
              field: "teamCode",
              operator: "INCLUDES",
              value: upper(ri!filters.teamCode),
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.teamCode)
              )
            ),
            a!queryFilter(
              field: "isRush",
              operator: "=",
              value: 1,
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.showOnlyRush)
              )
            ),
            /*RMSP2-5434*/
            a!queryFilter(
              field: "isAdvisoryServices",
              operator: "=",
              value: 1,
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.isAdvisoryServices)
              )
            ),
            /*add logggedin user is assignee and not to pull other statuses filters here
        */
            a!queryFilter(
              field: "processingDate",
              operator: ">=",
              value: rule!RMO_RULE_getMidnightFromDate(date: ri!filters.processingDateStart),
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.processingDateStart)
              )
            ),
            a!queryFilter(
              field: "processingDate",
              operator: "<=",
              value: rule!RMO_RULE_get1159PmFromDate(date: ri!filters.processingDateEnd),
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.processingDateEnd)
              )
            ),
            a!queryFilter(
              field: "disbursementDeadline",
              operator: ">=",
              value: rule!RMO_RULE_getMidnightFromDate(date: ri!filters.disbursementDateStart),
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.disbursementDateStart)
              )
            ),
            a!queryFilter(
              field: "disbursementDeadline",
              operator: "<=",
              value: rule!RMO_RULE_get1159PmFromDate(date: ri!filters.disbursementDateEnd),
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.disbursementDateEnd)
              )
            ),
            a!queryFilter(
              field: "renewalDate",
              operator: ">=",
              value: rule!RMO_RULE_getMidnightFromDate(date: ri!filters.renewalDateStart),
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.renewalDateStart)
              )
            ),
            a!queryFilter(
              field: "renewalDate",
              operator: "<=",
              value: rule!RMO_RULE_get1159PmFromDate(date: ri!filters.renewalDateEnd),
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.renewalDateEnd)
              )
            ),
            a!queryFilter(
              field: "gdoDueDate",
              operator: ">=",
              value: rule!RMO_RULE_getMidnightFromDate(date: ri!filters.dueDateStart),
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.dueDateStart)
              )
            ),
            a!queryFilter(
              field: "gdoDueDate",
              operator: "<=",
              value: rule!RMO_RULE_get1159PmFromDate(date: ri!filters.dueDateEnd),
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.dueDateEnd)
              )
            ),
            /* If they cannot view private only query for non private*/
            /* cashier's checks ? */
            a!queryFilter(field: "isWithdrawn", operator: "is null"),
            /*GLO*/
            a!queryFilter(
              field: "loanType",
              operator: "in",
              value: ri!filters.loanType,
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.loanType)
              )
            ),
            /*Implementation Benchmark*/
            a!queryFilter(
              field: "implementationBenchmark",
              operator: "=",
              value: ri!filters.implementationBenchmark,
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.implementationBenchmark)
              )
            ),
            a!queryFilter(
              field: "isForeignCurrency",
              operator: "=",
              value: if(ri!filters.isForeignCurrency, 1, 0),
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.isForeignCurrency)
              )
            ),
            a!queryFilter(
              field: "isCanada",
              operator: "=",
              value: if(ri!filters.isCanada, 1, 0),
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.isCanada)
              )
            ),
            a!queryFilter(
              field: "openCardOpsRequestExists",
              operator: "=",
              value: 0,
              applyWhen: or(
                ri!isAccountServicesBangalore,
                ri!isAccountServicesAndFulfillmentImplementer,
                ri!isClientOnboarding/* RMSF-4312 */
                
              )
            ),
            a!queryFilter(
              field: "loanType",
              operator: "in",
              value: ri!filters.loanType,
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.loanType)
              ),
              
            ),
            a!queryFilter(
              field: "PaymentModePriority",
              operator: "in",
              value: ri!filters.PaymentModePriority,
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.PaymentModePriority)
              ),
              
            ),
            a!queryFilter(
              field: "isSameDayImplReq",
              operator: "=",
              value: if(ri!filters.isSameDayImplReq, 1, 0),
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.isSameDayImplReq)
              ),
              
            ),
            a!queryFilter(
              field: "TransferAccountNo",
              operator: "includes",
              value: ri!filters.TransferAccountNo,
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(tointeger(ri!filters.TransferAccountNo))
              )
            ),
            a!queryFilter(
              field: "TransferAccountStatus",
              operator: "in",
              value: ri!filters.TransferAccountStatus,
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.TransferAccountStatus)
              )
            ),
            a!queryFilter(
              field: "TransferDueDate",
              operator: ">=",
              value: rule!RMO_RULE_getMidnightFromDate(date: ri!filters.wiDueDateStart),
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.wiDueDateStart)
              )
            ),
            a!queryFilter(
              field: "TransferDueDate",
              operator: "<=",
              value: rule!RMO_RULE_get1159PmFromDate(date: ri!filters.wiDueDateEnd),
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.wiDueDateEnd)
              )
            ),
            a!queryFilter(
              field: "TransferReferenceId",
              operator: "includes",
              value: ri!filters.TransferReferenceId,
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.TransferReferenceId)
              )
            ),
            a!queryFilter(
              field: "TransferDate",
              operator: ">=",
              value: rule!RMO_RULE_getMidnightFromDate(date: ri!filters.TransferDateStart),
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.TransferDateStart)
              )
            ),
            a!queryFilter(
              field: "TransferDate",
              operator: "<=",
              value: rule!RMO_RULE_get1159PmFromDate(date: ri!filters.TransferDateEnd),
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.TransferDateEnd)
              )
            ),
            a!queryFilter(
              field: "narrativeStatus",
              operator: ">",
              value: 0,
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.autolinkedMessage)
              )
            ),
            a!queryFilter(
              field: "TransferAmountNumber",
              operator: ">=",
              value: todecimal(ri!filters.minTransferAmount),
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.minTransferAmount)
              )
            ),
            a!queryFilter(
              field: "TransferAmountNumber",
              operator: "<=",
              value: todecimal(ri!filters.maxTransferAmount),
              applyWhen: not(
                rule!RMO_RULE_isNullorEmpty(ri!filters.maxTransferAmount)
              )
            ),
            a!queryFilter(
              field: "isArchived",
              operator: "=",
              value: if(ri!filters.currentHistoricalData="Historical",
              1,
              0)

            ),
          }
        ),
        pagingInfo: ri!pagingInfo
      ),
      fetchTotalCount: true
    ),
    refreshOnVarChange: ri!refresh
  ),
  local!data
)

Nandhakumar · Answer

Hi, Dusty

Your rule internally uses a!queryEntity() to fetch data from a datastore. When this rule is called, it returns a DataSubset.
Index the value with "data" and wrap with a!toJson().In your case.

a!toJson( local!data.data )

or

a!toJson(
index(local!data, "data", {})
)

Shubham Aware · Answer

Wrap your rule in a!toJson() and pass to JsonToExcel Json input. https://docs.appian.com/suite/help/26.2/fnc_system_a_tojson.html