Perguntas[json](coding)

Bom dia. Sou iniciante em Stack Overflow, Powershell e RegEx.

Estou interessado em fazer um aprimoramento no programa a seguir no Powershell. A partir de agora, o programa procura por um entityType de "IHUR" dentro de um ForEach. Uma vez que "IHUR" é encontrado, o programa produz dois objetos de interesse: id e RatedOI.

Tenho um arquivo JSON complexo em que id e RatedOI e IHUR estão aparecendo várias vezes no arquivo JSON. Acabei de perceber que IHUR só ocorre uma vez no JSON. Como o programa atual está retornando apenas a 1ª ocorrência de id e RatedOI, estou procurando aprimorá-lo.

1. Quando entityType "Operator" for encontrado, capture apenas a primeira ocorrência de ID, fisicamente localizada 1 linha acima dela (varredura para cima?)

2. Quando o entityType "Operator" for encontrado, capture apenas o primeiro RatedOperatorIndicator abaixo dele (varredura para baixo?) (RatedOI pode ser encontrado 1 linha abaixo ou muitas linhas abaixo)

3. Se a seguinte sequência de caracteres for encontrada (que está em linhas separadas no JSON e não produz resultados):
   

    "EntityType": "Operator", 
    "Characteristics": [ 
   

Observe o colchete, não a chave

 id                                    RatedIO 
----                                  ------
833e2a7f-c173-4062-9cd6-2196432e0001  False
6fe06340-072f-49b2-8d5a-449e3db80002  True

  Id                                     RatedOI
  ----                                  ------
  833e2a7f-c173-4062-9cd6-2196432e0001  False

Alguém pode revisar este arquivo JSON de exemplo e o código do PowerShell e fornecer feedback?

Código JSON

{ 
"id": "4fd338f7-746b-420b-9d7e-b41709e9a641",
"RD": {

"PDR": []
},
"TimeStamp": "2025-02-14T16:55:20.1433467Z",
"NNTl": {
"CD": [
  {
    "EntityType": "Occurrence",
    "Characteristics": [
      "OFGE",
      "ORI"
    ],
    "Cardinality": "Many"
   },
   {
    "EntityType": "Operator",
    "Characteristics": [
      "ADL",
      "ERO"
    ],
    "Cardinality": "Many"
  }
   ],
  "RRXC": true

  },
  "EntitiesData": {
  "Entities": [
  {
    "Id": "b0000000-0000-0000-0000-00000000000b",
    "EntityType": "IHUR",
    "Ordinal": 0,
    "Characteristics": {
      "PBIL": {
        "StringValue": "DDDD"
      }
    }
    },
    {
    "Id": "833e2a7f-c173-4062-9cd6-2196432e0001",
    "EntityType": "Operator",
    "Ordinal": 0,
    "Characteristics": {
      "FN": {
        "StringValue": "Da"
      },
       "RatedOI": {
        "BoolValue": false
      },
       "fdfdf": {
        "DDFDF": "SDFDS43R5"
      }
     },
     "EntityCreationDateTime": "2025-02-12T19:42:59.2852792Z"
    },
    {
     "Id": "6fe06340-072f-49b2-8d5a-449e3db80002",
    "EntityType": "Operator",
    "Characteristics": {
      "Deleted": {
        "StringValue": "0"
      },
           
       "RatedOI": {
        "BoolValue": true 
       }
      }
          }
  
  ]
 },
 "OR": "FFFFF01"
 }
 

Código Powershell, baseado nesta resposta :

Set-Location C:\Users\A187515\Downloads\
$file = Get-ChildItem -Path C:\Users\A187515\Downloads\ -Filter *.json | Sort-Object LastAccessTime -Descending | Select-Object -First 1
(Get-Content -Raw "$file" | ConvertFrom-Json) | ForEach-Object {
  $useNext = $false
  foreach ($entity in $_.entitiesData.entities) {
    if ($entity.entityType -eq 'IHUR') {
      $useNext = $true
    }
    elseif ($useNext) {
      $entity | Select-Object `
        id, 
      @{ Name = 'RatedOI'; Expression = { 
          $_.characteristics.RatedOI.boolValue } 
      }    
      #break
      $useNext = $false
    }
  }
}

Tenho um JSON similar ao seguinte. Tenho vários registros e estou tentando extrair o valor do campo para "RecType" do registro que tem a tag where Key==namee Value==qwerty.

{
  "Records": [
    {
      "RecType": "type-A",
      "Tags": [
        {
          "Key": "category",
          "Value": "foo"
        },
        {
          "Key": "name",
          "Value": "qwerty"
        }
      ]
    },
    {
      "RecType": "type-B",
      "Tags": [
        {
          "Key": "category",
          "Value": "bar"
        },
        {
          "Key": "name",
          "Value": "uiop"
        }
      ]
    }
  ]
}

Estou tentando fazer o comando abaixo, mas ele retorna o RecType para AMBOS os registros, presumivelmente porque o Key==Nameaparece em ambos. Mas o que estou tentando fazer é puxar o registro onde o par Chave/Valor estava name==uiop; Acho que o que estou fazendo é dizer "puxar todos os registros onde há um Key==nameAND Value==uiop, o que não é a intenção.

jq ".Records[] | (select(.Tags[].Key==\"Name\")) 
               | (select(.Tags[].Value==\"uiop\"))" 
               | jq ".RecType" 

Tentei fazer um "and" para as duas instruções select, mas parece que resulta em booleanos, não na correspondência que eu esperava.

Alguma ideia?

Estou tentando desempacotar alguns dados JSON. Acho que o problema é que os 2 arrays têm campos diferentes, então não correspondem corretamente à minha struct. Basicamente, preciso apenas dos dados do primeiro item no array. Existe uma maneira de lidar com isso? Aqui está o que eu tenho, no entanto, não está gerando nenhum erro, mas não parece estar retornando nada.

Aqui está um exemplo no Go Playground

package main

import (
    "encoding/json"
    "fmt"
    "time"
)

var jsondata = `{
  "Secrets": [
    {
      "name": "default",
      "versionInfo": "2025-02-10T20:11:05Z/1",
      "lastUpdated": "2025-02-10T20:11:05.512Z",
      "secret": {
        "@type": "type.googleapis.com/envoy.extensions.transport_sockets.tls.v3.Secret",
        "name": "default",
        "tlsCertificate": {
          "certificateChain": {
            "inlineBytes": "RRVkp2YjNSRApRVEV1WTN=="
          },
          "privateKey": {
            "inlineBytes": "W3JlZFRDSGVkXQ=="
          }
        }
      }
    },
    {
      "name": "default2",
      "versionInfo": "2025-02-10T20:11:05Z/3",
      "lastUpdated": "2025-02-10T20:11:05.527Z",
      "secret": {
        "@type": "type.googleapis.com/envoy.extensions.transport_sockets.tls.v3.Secret",
        "name": "ROOTCA",
        "validationContext": {
          "trustedCa": {
            "inlineBytes": "LS0tLS1CRUdJTiBDRVJUSUZJ="
          }
        }
      }
    }
  ]
}`

type model struct {
    Name        string    `json:"name"`
    VersionInfo time.Time `json:"versionInfo"`
    LastUpdated time.Time `json:"lastUpdated"`
    Secret      struct {
        Type           string `json:"@type"`
        Name           string `json:"name"`
        TLSCertificate struct {
            CertificateChain struct {
                InlineBytes string `json:"inlineBytes"`
            } `json:"certificateChain"`
            PrivateKey struct {
                InlineBytes string `json:"inlineBytes"`
            } `json:"privateKey"`
        } `json:"tlsCertificate"`
    } `json:"secret"`
}

func main() {

    input := []byte(jsondata)
    //Source := (*json.RawMessage)(&data2)

    var Info model
    // Notice the dereferencing asterisk *
    err := json.Unmarshal(input, &Info)
    if err != nil {
        //fmt.Printf(err.Error())
        panic(err)
    }
    fmt.Printf("%s", Info.Name)

}

Estou trabalhando na criação de um gráfico de funil usando o Vega Lite, mas estou enfrentando um problema ao colocar o texto no centro de cada barra.

Abaixo está a especificação do Vega Lite.

{
  "$schema": "https://vega.github.io/schema/vega-lite/v5.json",
  "encoding": {
    "y": {"field": "department", "type": "nominal", "sort": "-x"},
    "x": {
      "field": "daily_total_login",
      "type": "quantitative",
      "stack": "center"
    }
  },
  "layer": [
    {
      "mark": {"tooltip": true, "type": "bar"},
      "encoding": {
        "x": {
          "field": "daily_total_login",
          "type": "quantitative",
          "stack": "center"
        },
        "color": {"field": "department", "type": "nominal", "legend": null}
      }
    },
    {
      "mark": {"type": "text"},
      "encoding": {
        "text": {"field": "daily_total_login", "type": "quantitative"}
      },
    }
  ],
  "data": {
    "values": [
      {
        "date": "2024-08-09",
        "department": "A",
        "daily_total_login": 277,
        "daily_active_user": 87
      },
      {
        "date": "2024-08-10",
        "department": "B",
        "daily_total_login": 36,
        "daily_active_user": 9
      },
      {
        "date": "2024-08-11",
        "department": "C",
        "daily_total_login": 39,
        "daily_active_user": 14
      },
      {
        "date": "2024-08-12",
        "department": "D",
        "daily_total_login": 124,
        "daily_active_user": 51
      },

    ]
  },
  "height": "container",
  "width": "container"
}

Com a saída conforme abaixo:

Alguém poderia sugerir que mudanças eu poderia fazer na especificação vega lite acima, para que o texto pudesse aparecer no centro de cada barra?

Na entrada json "daysRanges" é um array que contém múltiplos valores de "min" e "max". Mas na saída eu preciso somente do primeiro valor de "min" e "max". Preciso de uma especificação jolt que transformará essa entrada json em saída json.

Entrada json:

{
  "group": [
    {
      "daysRanges": [
        {
          "min": 0,
          "max": 0
        },
        {
          "min": 1,
          "max": 1
        }
      ]
    }
  ]
}

Saída json:

{
  "group": [
    {
      "min": 0,
      "max": 0
    }
  ]
}

Quero comparar muitos documentos JSON sem me importar com uma precisão maior que 2 dígitos. Quero arredondar qualquer número em um documento JSON, mas não sei onde os números estão nos documentos (mas eles não são chaves).
Atualmente, estou usando apenas uma regex ( sed 's/\(\.[0-9][0-9]\)[0-9]*/\1/g'), mas assim, 0.9999ou 1.0001tenho o mesmo resultado.

Eu sei como fazer isso quando sei em quais caminhos os números estão, mas como faço isso se não especifico nenhuma localização dos números no documento?

Desta fonte:

{
  "a": -4e-12,
  "b": {
    "c": 0.999999999999997,
    "d": 101.12222222222
  }
}

Eu esperaria um resultado como:

{
  "a": 0,
  "b": {
    "c": 1,
    "d": 101.12
  }
}

Eu defini um array JSON dentro de uma propriedade:

    <property name="systemList" type="STRING" value='[
    {"systemName":"Vodafone", "tokenEndpoint":"https://vodafone.com/oauth/token",         "client_id":"c6VwL5qIGQAhJfmZADoR", "client_secret":"dGfk4xKTGPcZ4MvMxpl5"},
    {"systemName":"TalkTalk", "tokenEndpoint":"https://talktalk.com/oauth/token", "client_id":"xyz123", "client_secret":"abc456"},
    {"systemName":"NewSystem", "tokenEndpoint":"https://newapi.com/oauth/token",     "client_id":"newClientID", "client_secret":"newSecret"}
    ]'/>

Para iterar sobre esta matriz, estou usando o mediador <iterate>:

<iterate expression="json-eval($.systemList)" preservePayload="false" attachPath="$">
    <target>
        <sequence>
            <log category="INFO" level="custom">
                <property name="Step" value="Fetching token for a system" />
                <property name="Current System" expression="json-eval($.systemName)" />
            </log>
            <property name="TokenEndpoint" scope="default"
                expression="json-    eval($.tokenEndpoint)" />
            <property name="Content-Type" scope="transport" type="STRING"
                value="application/x-www-form-urlencoded" />
            <property name="Accept" scope="transport" type="STRING"
                value="application/json" />
            <property name="client_id" scope="default"
                expression="json-eval($.client_id)" />
            <property name="client_secret" scope="default"
                expression="json-eval($.client_secret)" />
            <send>
                <endpoint>
                    <http method="POST" uri-template="{get-property('TokenEndpoint')}">
                        <timeout>
                            <responseAction>discard</responseAction>
<duration>30000</duration>
                        </timeout>
                    </http>
                </endpoint>
            </send>
            <enrich>
                <source clone="true" type="body" />
                <target property="fetchedToken" type="property" />
            </enrich>
            <property expression="json-eval($.access_token)" name="storedToken"
                scope="registry" type="STRING" />
            <property expression="json-eval($.systemName)" name="systemName"
                scope="default" type="STRING" />
            <property name="registryTokenKey"
                expression="concat('storedToken_', get-property('systemName'))"
                scope="default" type="STRING" />
        </sequence>
    </target>
</iterate>

Devo usar um mecanismo de loop diferente para iterar na matriz JSON?

Recebo um objeto JSON como este:

{
    "id": "...",
    "Nested": {
        "nestedId": "..."
    }
}

Há muitos outros atributos tanto no objeto de nível superior quanto no de nível Nestedúnico.

Estou interessado apenas em uma dúzia de campos do objeto de nível superior e do Nestedobjeto nestedId.

Este código os coloca em uma classe de dados Kotlin:

import com.fasterxml.jackson.annotation.*

@JsonIgnoreProperties(ignoreUnknown = true)
data class MainObject(
    @JsonProperty("id") val id: String,
    // ... more properties for other fields

    @JsonProperty("nested") val nested: Nested?,
) {
    val nestedId: String? get() = nested?.id
}

@JsonIgnoreProperties(ignoreUnknown = true)
data class Nested(
    @JsonProperty("id") val id: String
)

e posso acessar o id do objeto aninhado facilmente com n.nestedId.

Eu ainda gostaria de me livrar da Nestedclasse extra.

Como posso usar anotações para desserializar apenas o id aninhado em vez do objeto inteiro?

Já vi um personalizado JsonDeserializer, mas parece que tem mais código e complexidade do que minha pequena classe extra.

Acho que eu poderia usar readTreee path, mas aí terei que mapear todos os outros campos manualmente.

Tenho a seguinte saída JSON da AWS CLI que contém o ID da instância, o endereço IP e alguns outros valores das minhas tags da AWS (uma lista de FQDNs desejados e se um proxy deve ser usado ou não):

[
    [
        {
            "InstanceId": "i-11111111111111111",
            "ClusterName": "vpn",
            "Ip": "192.168.0.1",
            "FqdnList": "vpn.example.com",
            "Proxy": null
        }
    ],
    [
        {
            "InstanceId": "i-22222222222222222",
            "ClusterName": "sql",
            "Ip": "192.168.0.2",
            "FqdnList": "db.example.com;sql.example.com",
            "Proxy": "nginx"
        }
    ],
    [
        {
            "InstanceId": "i-33333333333333333",
            "ClusterName": "nginx",
            "Ip": "192.168.0.3",
            "FqdnList": "nginx.example.com;db.example.com;sql.example.com",
            "Proxy": null
        }
    ],
    [
        {
            "InstanceId": "i-44444444444444444",
            "ClusterName": "vpn",
            "Ip": "192.168.0.4",
            "FqdnList": "vpn.example.com",
            "Proxy": null
        }
    ],
    [
        {
            "InstanceId": "i-55555555555555555",
            "ClusterName": "nginx",
            "Ip": "192.168.0.5",
            "FqdnList": "nginx.example.com;db.example.com;sql.example.com",
            "Proxy": null
        }
    ]
]

Meu objetivo final é usar esse JSON para criar a lista de Aregistros DNS (para outro script que preenche nossa zona DNS), então estou tentando transpô-lo para algo mais simples, como:

{
    "vpn.example.com": [
        "192.168.0.1",
        "192.168.0.4",
    ],

    "nginx.example.com": [
        "192.168.0.3"
        "192.168.0.5"
    ],
    "db.example.com": [
        "192.168.0.3"
        "192.168.0.5"
    ],
    "sql.example.com": [
        "192.168.0.3"
        "192.168.0.5"
    ]
}

ou

[
    {
        "name": "vpn.example.com",
        "value": "192.168.0.1"
    },
    {
        "name": "vpn.example.com",
        "value": "192.168.0.4"
    },
    {
        "name": "nginx.example.com",
        "value": "192.168.0.3"
    },
    {
        "name": "nginx.example.com",
        "value": "192.168.0.5"
    },
    {
        "name": "db.example.com",
        "value": "192.168.0.5"
    },
    {
        "name": "db.example.com",
        "value": "192.168.0.3"
    },
    {
        "name": "sql.example.com",
        "value": "192.168.0.3"
    },
    {
        "name": "sql.example.com",
        "value": "192.168.0.5"
    }
]

Consegui remover os itens que estão sendo um proxy ( Proxy!= null, porque seus endereços já estão repetidos na tag do proxy) e criar um array a partir da string FQDNs usando:

jq '
  .[].[]
  | select(.Proxy | . == null)
  | {
      Ip: .Ip,
      Fqdns: .FqdnList | split(";"),
    }
  '

O que dá:

{
  "Ip": "192.168.0.1",
  "Fqdns": [
    "vpn.example.com"
  ]
}
{
  "Ip": "192.168.0.3",
  "Fqdns": [
    "nginx.example.com",
    "db.example.com",
    "sql.example.com"
  ]
}
{
  "Ip": "192.168.0.4",
  "Fqdns": [
    "vpn.example.com"
  ]
}
{
  "Ip": "192.168.0.5",
  "Fqdns": [
    "nginx.example.com",
    "db.example.com",
    "sql.example.com"
  ]
}

Mas como eu "crio" linhas/itens para cada item em Fqdnsmatrizes?

Não tenho certeza se isso é possível em jq.

Isso pode ser feito facilmente em um script PHP/Python, mas prefiro mantê-lo "simples".

Pode map()+ group_by()ser útil como nesta resposta do SO? "Transpondo" objetos em jq

Estou tentando substituir valores de um array com base em um mapa de pesquisa usando Jolt, mas a especificação não parece funcionar. Ela funciona até atingir o mapa de pesquisa e eu posso deslocar o mapa inteiro, mas referenciar cada chave usando & não está funcionando como esperado.

Entrada:

{
  "records": [
    {
      "id": "1",
      "keys": [
        "ba2c89c3",
        "aa2c89c3"
      ]
    }
  ],
  "lookup": {
    "ba2c89c3": "EE",
    "aa2c89c3": "EL"
  }
}

Saída esperada:

{
  "data": {
    "records": [
      {
        "id": "1",
        "vals": [
          "EE",
          "EL"
        ]
      }
    ]
  }
}

Tentei especificar, mas parece que não funciona.

[
  {
    "operation": "shift",
    "spec": {
      "records": {
        "*": {
          "id": "data.records[&1].id",
          "keys": {
            "*": {
              "@(4,lookup.&)": "data.records[&3].vals"
            }
          }
        }
      }
    }
  }
]