Envolva todos os números em JSON com aspas

$ jq 'map_values(tostring)' file.json
{
  "id": "1",
  "customer": "user",
  "plate": "BMT-216-A",
  "country": "GB",
  "amount": "1000",
  "pndNumber": "20000",
  "zoneNumber": "4"
}

Redirecione para um novo arquivo e mova-o para o nome do arquivo original.

Para uma conversão mais completa de números em estruturas não planas em strings, considere

jq '(..|select(type == "number")) |= tostring' file.json

Isso examinaria todos os valores recursivamente no documento fornecido e selecionaria aqueles que são números. Os valores selecionados são então convertidos em strings. Também, estritamente falando, examinaria as chaves, mas como elas não podem ser números simples em JSON, nenhuma chave seria selecionada.

Exemplo:

$ jq . file.json
{
  "a": {
    "b": 1
  },
  "b": null,
  "c": [
    1,
    2,
    "hello",
    4
  ]
}

$ jq '(..|select(type == "number")) |= tostring' file.json
{
  "a": {
    "b": "1"
  },
  "b": null,
  "c": [
    "1",
    "2",
    "hello",
    "4"
  ]
}

Para citar adicionalmente o null, altere o select()para

select(type == "number" or type == "null")

aqui está uma solução fácil baseada no jtcutilitário unix:

bash $ jtc -w'<.*>D:' -eu echo '"{}"' \; file.json
{
   "amount": "1000",
   "country": "GB",
   "customer": "user",
   "id": "1",
   "plate": "BMT-216-A",
   "pndNumber": "20000",
   "zoneNumber": "4"
}
bash $ 

se você gosta de aplicar alterações diretamente no arquivo json, use o -fswitch, assim:

bash $ jtc -f -w'<.*>D:' -eu echo '"{}"' \; file.json

A solução proposta funcionará corretamente com jsons estruturados arbitrários, por exemplo:

bash $ jtc -w'<.*>D:' -eu echo '"{}"' \; file.json
{
   "amount": "1000",
   "country": "GB",
   "customer": "user",
   "id": "1",
   "plate": "BMT-216-A",
   "pndNumber": "20000",
   "sub": {
      "subvalue": "123"
   },
   "zoneNumber": "4"
}
bash $ 

• se você gosta de citar valores nulos, basta colocar um caminho a pé-w'<>n:'
• se você gosta de citar valores booleanos, coloque um caminho de caminhada-w'<any>b:'

Além disso, a tarefa inversa (tirar as aspas de todos os números) é facilmente conseguida de maneira semelhante: digamos, file.jsonjá está "entre aspas", para retirar as aspas de todos os números:

bash $ jtc -w'<^\d+$>R:' -eu echo {-} \; file.json
{
   "amount": 1000,
   "country": "GB",
   "customer": "user",
   "id": 1,
   "plate": "BMT-216-A",
   "pndNumber": 20000,
   "zoneNumber": 4
}
bash $ 

UPDATE : a última versão do jtcimplementa agora templates e namespaces. Com isso, nenhuma invocação de shell externo é necessária:

bash $ jtc -w'<.*>D:' -u'<.*>D:<val>v' -T'"{val}"' file.json
{
   "amount": "1000",
   "country": "GB",
   "customer": "user",
   "id": "1",
   "plate": "BMT-216-A",
   "pndNumber": "20000",
   "zoneNumber": "4"
}

jtcguia do usuário: https://github.com/ldn-softdev/jtc/blob/master/User%20Guide.md

perl -pe 's/("(?:\\.|[^"])*")|[^\s[\]{}:,"]+/$1||qq("$&")/ge' file.json

Citaria qualquer coisa que não fosse citada e não fosse []{}:,whitespace, então citaria números, true, falsee null.

perl -pe 's/("(?:\\.|[^"])*")|-?\d+(?:\.\d+)?(?:[eE][-+]?\d+)?/$1||qq("$&")/ge'

Citaria especificamente o que corresponde à especificação de um número json e que ainda não está entre aspas.

Esses fazem uma tokenização exata com base na especificação JSON, não é uma aproximação.

Eu tentei com o método abaixo e funcionou bem.

Eu canalizei 2 vezes tentei até o meu nível para reduzi-lo

Comando:

sed 's/[0-9]\{1,\},\?$/"&/g' filename |
sed '/[0-9]\{1,\}$/s/[0-9]\{1,\}/&"/g'|
sed '/[0-9]\{1,\},$/s/,$/"&/g`'

Resultado:

 {
        "id":"1",
        "customer":"user",
        "plate":"BMT-216-A",
        "country":"GB",
        "amount":"1000",
        "pndNumber":"20000",
        "zoneNumber":"4"
}