Claro Valida Local

!/bin/bash

url_validationsaddress=https://api.claro.com.br/customers/v2/validationsaddress
url_token=https://api.claro.com.br/oauth2/v1/token

key=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
secret=XXXXXXXXXXXXXX
guid="X"
cpf=XXXXXXXXXXX
customerID="QUOD"
cep=XXXXXXXX
number=XXX
phone="XXXXXXXXXXX"
lat=XXXXXXXXX
lng=XXXXXXXXX
alg="scorealgorithmimpl"
cust="XXXXXXXXX"

senha=$( echo -n $key:$secret | base64)
curl -X POST $url_token -H 'Content-Type: application/x-www-form-urlencoded' -H
'cache-control: no-cache' -d 'grant_type=client_credentials' -H "x-client-auth: Basic
$senha" > json

grep 'access_token' json > atributoJson
token=$(cut -d'"' -f4 atributoJson )
curl -X GET $url_validationsaddress -H "Content-Type: application/json" -H "X-
CustomerID: $customerID" -H "x-client-auth: Bearer $token" -H "guid: $guid" -H "cpf:
$cpf" -H "cep: $cep" -H "number: $number" -H "phone: $phone" -H "lat: $lat" -H "lng:
$lng" -H "alg: $alg" -H "cust: $cust"

package client.validationsLocations;

import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Base64;

import org.codehaus.jackson.JsonProcessingException;
import org.codehaus.jackson.map.ObjectMapper;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestClientException;
import org.springframework.web.client.RestTemplate;

public class App {

    private static final String KEY = "XXXXXXXXXXXXXXXXXXXXXXXXXXX";

    private static final String SECRET = "XXXXXXXXXXX";

    private static final String GRANT_TYPE = "client_credentials";

    private static final String URL = "https://api.claro.com.br";

    private static final String END_POINT_ACCESS_TOKEN = "/oauth2/v1/token";

    private static final String END_POINT_API_VALIDATIONS_LOCATIONS =
    "/customers/v1/validationslocations";

    public static void main( String[] args ) throws URISyntaxException, JsonProcessingException, IOException {

        App app = new App();

        String token = app.getAccessToken();

        String guid="X";
        String cpf= "XXXXXXXXXXX";
        String customerID="QUOD";
        String cep = "XXXXXXXX";
        String number="XXX";
        String phone="XXXXXXXXXXX";
        String lat="XXXXXXXXX";
        String lng="XXXXXXXXX";
        String alg="scorealgorithmimpl";
        String cust="XXXXXXXXXX";

        System.out.println("Válida Localização: " + app.getValidationsLocations( token , guid , cpf , customerID,cep,number,phone,lat,lng,alg,cust ));
    }

    public String getValidationsLocations(String acessToken, String guid , String cpf , String customerID, String cep, String number,String phone,String lat, String lng, String alg, String cust) throws RestClientException, URISyntaxException {

        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        headers.add("cache-control","no-cache");
        headers.add("guid",guid);
        headers.add("cpf",cpf);
        headers.add("number",number);
        headers.add("cep",cep);
        headers.add("phone",phone);
        headers.add("lat",lat);
        headers.add("lng",lng);
        headers.add("alg",alg);
        headers.add("cust",cust);
        headers.add("x-client-auth", "Bearer " + acessToken);
        headers.add("X-CustomerID", customerID);

        HttpEntity entity = new HttpEntity(headers);

        RestTemplate restTemplate = new RestTemplate();
        ResponseEntity<String> result = restTemplate.exchange(new URI(URL +
        END_POINT_API_VALIDATIONS_LOCATIONS), HttpMethod.GET, entity, String.class);

        return result.getBody();
    }

    public String getAccessToken() throws URISyntaxException, JsonProcessingException, IOException {
        String senha = Base64.getEncoder().encodeToString(
        App.KEY.concat(":").concat(App.SECRET).getBytes() );

        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
        headers.add("cache-control","no-cache");
        headers.add("x-client-auth", "Basic " + senha);

        MultiValueMap<String, String> parameters = new LinkedMultiValueMap<>();
        parameters.add("grant_type", GRANT_TYPE);

        HttpEntity<MultiValueMap<String, String>> request = new HttpEntity<>(parameters,
        headers);

        RestTemplate restTemplate = new RestTemplate();
        ResponseEntity<String> result = restTemplate.postForEntity(new URI(URL +
        END_POINT_ACCESS_TOKEN),
        request, String.class);

        return new ObjectMapper().readTree(result.getBody()).get("access_token").asText() ;
    }
}

    $key = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX';

    $secret = 'XXXXXXXXXXXXXXX';

    $guid="X";

    $cpf=XXXXXXXXXXX;
    $cep=XXXXXXXX;
    $number=XXX;
    $phone="XXXXXXXXXXX";
    $lat=XXXXXXXXX;
    $lng=XXXXXXXXX;
    $alg="scorealgorithmimpl";
    $cust="XXXXXXXXXX";

    $token = getAccessToken();

    $validationsLocations = getValidationsLocations($token , $guid, $cpf , $cep,
    $number, $phone, $lat, $lng, $alg, $cust );

    echo $validationsLocations;

    function getAccessToken() {

        try {

            $senha = base64_encode($GLOBALS['key'] . ':' . $GLOBALS['secret']);

            $ch = curl_init();
            curl_setopt($ch, CURLOPT_URL, "https://api.claro.com.br/oauth2/v1/token");
            curl_setopt( $ch, CURLOPT_HTTPHEADER, [
            'Content-Type: application/x-www-form-urlencoded',
            'x-client-auth: Basic ' . $senha

            ]);

            curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
            curl_setopt($ch, CURLINFO_HEADER_OUT, true);
            curl_setopt($ch, CURLOPT_POST, true);
            curl_setopt($ch, CURLOPT_POSTFIELDS, 'grant_type=client_credentials');

            $response = curl_exec($ch);

            if (!$response){
                $error = curl_error($ch);
                $info = curl_getinfo($ch);
                die("cURL request failed, error = {$error}; info = " . print_r($info, true));
            }

            if (curl_errno($ch)){
                curl_close($ch);
                echo 'error:' . curl_error($ch);
            } else {
                curl_close($ch);
                return json_decode($response)->access_token;
            }

        } catch (Exception $e) {
            return 'Erro '. $e;
        }
    }

    function getValidationsLocations($token , $guid, $cpf , $cep, $number, $phone, $lat, $lng, $alg, $cust ) {

        try {
        echo $token;

            $ch = curl_init();
            curl_setopt($ch, CURLOPT_URL,
            "https://api.claro.com.br/customers/v1/validationslocations");

            curl_setopt( $ch, CURLOPT_HTTPHEADER, [
                'Content-Type: application/json',
                'guid: ' . $guid,
                'cpf: ' . $cpf,
                'cep: ' . $cep,
                'number: ' . $number,
                'phone: ' . $phone,
                'lat: ' . $lat,
                'lng: ' . $lng,
                'alg: ' . $alg,
                'cust: ' . $cust,
                'X-CustomerID: QUOD',
                'x-client-auth: Bearer ' . $token
            ]);

            curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
            curl_setopt($ch, CURLINFO_HEADER_OUT, true);
            curl_setopt($ch, CURLOPT_HTTPGET, true);

            $response = curl_exec($ch);

            if (!$response){
                $error = curl_error($ch);
                $info = curl_getinfo($ch);
                die("cURL request failed, error = {$error}; info = " . print_r($info, true));
            }

            if (curl_errno($ch)) {
                curl_close($ch);
                echo 'error:' . curl_error($ch);
            } else {
                curl_close($ch);
                return $response;
            }
        } catch (Exception $e) {
            return 'Erro '. $e;
        }
    }

import requests, json
import base64

KEY="XXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
SECRET="XXXXXXXXXXX"

SENHA = base64.b64encode( (KEY + ':' + SECRET ).encode('ascii') ).decode('ascii')
GRANT_TYPE = "client_credentials";

URL = "https://api.claro.com.br";
END_POINT_ACCESS_TOKEN = "/oauth2/v1/token";
END_POINT_API_VALIDATIONSADDRESS = "/customers/v1/validationslocations";

headers={'Content-Type':'application/x-www-form-urlencoded','cache-control':'no-
cache','x-client-auth': 'Basic {}'.format(SENHA)}

data = {'grant_type': 'client_credentials'}

respToken = requests.post(URL + END_POINT_ACCESS_TOKEN ,
headers=headers , data= data)

if respToken.status_code != 200:
    print('Erro:' + str( respToken.status_code))
else:
    token = json.loads( respToken.text)['access_token']

    guid="X"
    cpf=XXXXXXXXXXX
    customerID="QUOD"
    cep=XXXXXXXX

    number=XXX
    phone="XXXXXXXXXXX"
    lat=XXXXXXXXX
    lng=XXXXXXXXX
    alg="scorealgorithmimpl"
    cust="XXXXXXXX"

    headers_app = {'Content-Type': 'application/json',
    'X-CustomerID': 'claro_exemplo',
    'guid':guid,
    'cpf':str(cpf),
    'customerID':customerID,
    'cep':str(cep),
    'number':str(number),
    'phone':phone,
    'lat':str(lat),
    'lng':str(lng),
    'alg':alg,
    'cust':cust,
    'cache-control':'no-cache',
    'user-agent':'curl/7.60.0',
    'x-client-auth': 'Bearer {}'.format(token)}

    resp = requests.get( URL + END_POINT_API_VALIDATIONSADDRESS,
    headers=headers_app )

    if resp.status_code != 200:
        print('Erro: ' + str(resp.text))
    else:
        print('Valida ' + str( resp.text ))