How do i get data from Rest API

Question

Please, i am trying to access data from rest API, From the Documentation ,to get the token, i have to make a post call ,then use the token received to access two other results:

for the token, they gave this from the documentation:

https://apps.qa.interswitchng.com/passport/oauth/token

with the following Query Params

grant_type string

Headers Authorization string required

Set value to "Basic Base64(CLIENT_ID:SECRET_KEY)" Content-Type application/x-www-form-urlencoded string

My Codes

@SuppressLint("StaticFieldLeak")
    class SendTokenReqAsyncTask extends AsyncTask<String, Void, String> {

        @Override
        protected void onPreExecute() {
            super.onPreExecute();
            progressDialog = new ProgressDialog(MainActivity.this);
            progressDialog.setMessage("processing Token");
            progressDialog.setCancelable(false);
            progressDialog.show();
        }

        @Override
        protected String doInBackground(String... params) {
            JSONObject jsonObject2 = new JSONObject();
            InputStream inputStream = null;
            String result2 = "";
            base64EncodedCredentials = "Basic" + Base64.encodeToString ((CLIENT_ID + ":" + SECRET) .getBytes (), Base64.NO_WRAP);

            try {

                HttpClient httpclient = new DefaultHttpClient();
                HttpPost httpPost = new HttpPost(" https://apps.qa.interswitchng.com/passport/oauth/token/");

                //StringEntity stringEntity2 = new StringEntity(userPhoneNumber);
                //httpPost.setEntity(stringEntity2);
                httpPost.setHeader("Accept", "application/json");
                httpPost.setHeader("Authorization", base64EncodedCredentials);
                httpPost.setHeader("Content-type", "application/x-www-form-urlencoded");
                HttpResponse httpResponse1 = httpclient.execute(httpPost);

                inputStream = httpResponse1.getEntity().getContent();

                InputStreamReader inputStreamReader1 = new InputStreamReader(inputStream);

                BufferedReader bufferedReader = new BufferedReader(inputStreamReader1);

                StringBuilder stringBuilder2 = new StringBuilder();

                String bufferedStrChunk = null;
                int data = inputStreamReader1.read();

                while((bufferedStrChunk = bufferedReader.readLine()) != null){
                    stringBuilder2.append(bufferedStrChunk);
                }
                result2=stringBuilder2.toString();


                return result2;

            } catch (Exception e) {
                Log.d("InputStream", e.getLocalizedMessage());
            }

            return null;
        }

        @Override
        protected void onPostExecute(String result2) {
            super.onPostExecute(result2);
            progressDialog = new ProgressDialog(MainActivity.this);
            progressDialog.setCancelable(true);
            progressDialog.hide();
            //String re=null;

            /*try {

                JSONObject jsonObject = new JSONObject(result2);
                re = jsonObject.getString(result2);


            } catch (JSONException e) {
                e.printStackTrace();
            }*/

            txtInfo = findViewById(R.id.textViewMain);
            txtInfo.setVisibility(View.VISIBLE);
            txtInfo.setText(MessageFormat.format("Token is :{0}", result2));
            



        }
    }

with the below code in the oncreate

SendTokenReqAsyncTask myAsyncTasks = new SendTokenReqAsyncTask();
        myAsyncTasks.execute();

i also used retrofit this way

@SuppressWarnings("deprecation")
public class MyRetrofitClient {
    protected static MyRetrofitClient myRetrofitClient = null;
    private static RetroApis myRetroApis;
    private static TokenAPI tokenAPI;
    private static Retrofit retrofit = null;
    private String tokenFromServer;
    String clientID,secret;
    private  byte[] data64;
    String base64=null;

    MyRetrofitClient() {
        if (retrofit == null) {
            retrofit = new Retrofit.Builder()
                    .baseUrl(TOKEN_URL)
                    .addConverterFactory(GsonConverterFactory.create())
                    .build();
        }
        myRetroApis = retrofit.create(RetroApis.class);


    }
    public String encodeToBase64() {
        clientID= CLIENT_ID1;
        secret=SECRET1;

        String text = clientID + ":" + secret;

        data64 = new byte[0];
        data64 = text.getBytes(StandardCharsets.UTF_8);
        base64=android.util.Base64.encodeToString(data64, android.util.Base64.DEFAULT);

        return base64;
    }

    static Retrofit getTokenClient() {
        String type="application/x-www-form-urlencoded";
        String base64String=MyRetrofitClient.myRetrofitClient.encodeToBase64();
        RequestBody requestBody = RequestBody.create(MediaType.parse("Content-type"), type);
        HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
        logging.setLevel(HttpLoggingInterceptor.Level.BASIC);
        logging.redactHeader("Authorization");
        OkHttpClient httpClient = new OkHttpClient.Builder()
                .addInterceptor(logging)
                .addNetworkInterceptor(new Interceptor() {
                    @NotNull
                    @Override
                    public Response intercept(@NotNull Interceptor.Chain chain) throws IOException {
                        Request request = chain.request().newBuilder().addHeader("Authorization", MyRetrofitClient.getInstance().encodeToBase64()).build();
                        return chain.proceed(request);
                    }
                })
                .addNetworkInterceptor(new HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.BASIC))
                .build();


        retrofit = new Retrofit.Builder()
                .baseUrl(TOKEN_URL)
                .addConverterFactory(GsonConverterFactory.create())
                .client(httpClient)
                .build();



        return retrofit;
    }
    static Retrofit getTCreditReportClient(String tokenFromServer,String userPhoneNumber) {
        String type="application/json";
        RequestBody requestBody = RequestBody.create(MediaType.parse("Content-type"), type);
        HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
        logging.setLevel(HttpLoggingInterceptor.Level.BODY);
        //logging.setLevel(HttpLoggingInterceptor.Level.BODY);
        logging.redactHeader("Authorization");
        logging.redactHeader("Content-type");


        OkHttpClient httpClient = new OkHttpClient.Builder()
                .addInterceptor(logging)
                .addNetworkInterceptor(new Interceptor() {
                    @NotNull
                    @Override
                    public Response intercept(@NotNull Interceptor.Chain chain) throws IOException {
                        Request request = chain.request().newBuilder().addHeader("Authorization", tokenFromServer).build();
                        //Request request3 = chain.request().newBuilder().method("Content-type", requestBody).build();
                        return chain.proceed(request);
                    }
                })
                .addNetworkInterceptor(new HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.BODY))
                .build();


        retrofit = new Retrofit.Builder()
                .baseUrl("https://reqres.in")
                .addConverterFactory(GsonConverterFactory.create())
                .client(httpClient)
                .build();



        return retrofit;
    }
    static Retrofit getClient() {

        HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
        logging.setLevel(HttpLoggingInterceptor.Level.BASIC);
        //logging.setLevel(HttpLoggingInterceptor.Level.BODY);
        logging.redactHeader("Authorization");
        logging.redactHeader("Cookie");
        OkHttpClient client = new OkHttpClient.Builder()
                .addInterceptor(logging)
                .build();


        retrofit = new Retrofit.Builder()
                .baseUrl("https://reqres.in")
                .addConverterFactory(GsonConverterFactory.create())
                .client(client)
                .build();



        return retrofit;
    }

    public static synchronized MyRetrofitClient getInstance() {
        if (myRetrofitClient == null) {
            myRetrofitClient = new MyRetrofitClient();
        }
        return myRetrofitClient;
    }

    public RetroApis getMyApi() {
        return myRetroApis;
    }
    public TokenAPI getMyTokenApi() {
        return tokenAPI;
    }
}







public interface TokenAPI {
    String contentType= "application/json";
    String authorization= "<>";

    @FormUrlEncoded
    @POST("client_credentials")
    Call<OAuthToken> postCredentials(@Field("grant_type") String grantType);


    //@FormUrlEncoded
    @GET("creditScores")
    Call<CreditScore> getCreditScore(@Query("client_credentials") String queryParam);

    //@FormUrlEncoded
    @GET("creditScores")
    Call<List<CreditScoreHistory>> getCreditScoreHistory(@Query("client_credentials") String name);



    @GET("/1.1/users/show.json")
    Call<String> getUserDetails(@Query("screen_name") String name);

}





private void createInterSwitchTokenAPI33() {
        editText = findViewById(R.id.editText);
        base64EncodedCredentials = "Basic" + Base64.encodeToString ((CLIENT_ID + ":" + SECRET) .getBytes (), Base64.NO_WRAP);

        //base64String=this.encodeToBase64();
        String editTextInput = Objects.requireNonNull(editText.getText()).toString();

        HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
        logging.setLevel(HttpLoggingInterceptor.Level.BASIC);
        logging.redactHeader("Authorization");
        OkHttpClient httpClient = new OkHttpClient.Builder()
                .addInterceptor(logging)
                .addNetworkInterceptor(new Interceptor() {
                    @NotNull
                    @Override
                    public okhttp3.Response intercept(@NotNull Interceptor.Chain chain) throws IOException {
                        Request request = chain.request().newBuilder().addHeader("Authorization", base64EncodedCredentials).build();
                        return chain.proceed(request);
                    }
                })
                .addNetworkInterceptor(new HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.BASIC))
                .build();


        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(TOKEN_URL)
                .addConverterFactory(GsonConverterFactory.create())
                .client(httpClient)
                .build();
        tokenAPI = retrofit.create(TokenAPI.class);
        tokenAPI.getCreditScore(editTextInput).enqueue(creditScoreCallback);

    }
    public void onClick(View view) {
        if (view.getId() == R.id.post) {
            editText = findViewById(R.id.editText);
            String editTextInput = editText.getText().toString();
            if (!editTextInput.isEmpty())
                createCreditScoreAPI(token);
                createHistoryAPI(token);
                tokenAPI.getCreditScore(editTextInput).enqueue(creditScoreCallback);
                tokenAPI.getCreditScoreHistory(editTextInput).enqueue(creditScoreHistoryCallback);


            }  else {
                Toast.makeText(this, "Please provide your BVN Phone Number", Toast.LENGTH_LONG).show();
            }
    }







private void createCreditScoreAPI(OAuthToken token) {
        OkHttpClient okHttpClient = new OkHttpClient.Builder().addInterceptor(new Interceptor() {
            @NotNull
            @Override
            public okhttp3.Response intercept(@NotNull Chain chain) throws IOException {
                //Request originalRequest = chain.request();

                Request request = chain.request().newBuilder().addHeader("Authorization", token.getAccessToken()).build();
                return chain.proceed(request);
            }
        }).addNetworkInterceptor(new HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.HEADERS))
                .build();

        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(SCORE_URL)
                .client(okHttpClient)
                .addConverterFactory(GsonConverterFactory.create())
                .build();

        tokenAPI = retrofit.create(TokenAPI.class);
    }
    Callback<CreditScore> creditScoreCallback = new Callback<CreditScore>() {
        @Override
        public void onResponse(Call<CreditScore> call, Response<CreditScore> response) {
            if (response.isSuccessful()) {
                CreditScore creditScore = response.body();

                if (creditScore != null) {
                    id = creditScore.getId();
                    msisdn = creditScore.getMsisdn();
                    score = creditScore.getScore();
                    dateCreated = creditScore.getDateCreated();
                }

                displayResponse += id + " Phone\n" + msisdn + " Score\n" + score + " dateCreated\n"+dateCreated;
                txtCreditScore = findViewById(R.id.textCreditScore);
                if (displayResponse == null) txtCreditScore.setText("no value");
                else txtCreditScore.setText(displayResponse);
            } else {
                Toast.makeText(MainActivity.this, "Failure while requesting Credit Score", Toast.LENGTH_LONG).show();
                txtCreditScore.setText(MessageFormat.format("Error!{0}", response.message()));
                Log.d("Credit Score Details", "Code: " + response.code() + "Message: " + response.message());
            }
        }

        @Override
        public void onFailure(Call<CreditScore> call, Throwable t) {
            t.printStackTrace();
        }
    };
    private void createHistoryAPI(OAuthToken token) {
        OkHttpClient okHttpClient = new OkHttpClient.Builder().addInterceptor(new Interceptor() {
            @NotNull
            @Override
            public okhttp3.Response intercept(@NotNull Chain chain) throws IOException {
                Request originalRequest = chain.request();

                Request request = chain.request().newBuilder().addHeader("Authorization", token.getAccessToken()).build();
                return chain.proceed(request);
            }
        }).addNetworkInterceptor(new HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.HEADERS))
                .build();

        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(HISTORY_URL)
                .client(okHttpClient)
                .addConverterFactory(GsonConverterFactory.create())
                .build();

        tokenAPI = retrofit.create(TokenAPI.class);
    }
    Callback<List<CreditScoreHistory>> creditScoreHistoryCallback = new Callback<List<CreditScoreHistory>>() {
        @Override
        public void onResponse(Call<List<CreditScoreHistory>> call, Response<List<CreditScoreHistory>> response) {
            if (response.isSuccessful()) {

                recyclerView = findViewById(R.id.recyclerViewHistory);
            } else {
                Toast.makeText(MainActivity.this, "Failure while requesting user details", Toast.LENGTH_LONG).show();
                Log.d("History Callback", "Code: " + response.code() + "Message: " + response.message());
            }
            if (response.isSuccessful()) {
                CreditScoreHistory creditScoreHistory = new CreditScoreHistory();
                creditScoreList = response.body();

                if (creditScoreList != null) {
                    for (int i = 0; i < creditScoreList.size(); i++) {
                        creditScoreList.add(creditScoreHistory);
                        count=creditScoreList.size();

                    }
                    if(creditScoreHistory !=null){
                        msisdn = creditScoreHistory.getMsisdn1();
                        score = creditScoreHistory.getScore1();
                        dateCreated = creditScoreHistory.getDateCreated1();
                        creditScoreList = creditScoreHistory.data;

                    }


                }

                displayResponse += count+" Phone\n" + msisdn + " Score\n" + score + " dateCreated\n"+dateCreated;
                txtCreditHistory = findViewById(R.id.textCreditHistory);
                creditHistoryAdapter = new CreditHistoryAdapter(MainActivity.this, creditScoreList);
                LinearLayoutManager linearLayoutManager = new LinearLayoutManager(MainActivity.this);
                recyclerView.setLayoutManager(linearLayoutManager);
                recyclerView.setItemAnimator(new DefaultItemAnimator());
                recyclerView.setAdapter(creditHistoryAdapter);
                SnapHelper snapHelper = new PagerSnapHelper();
                snapHelper.attachToRecyclerView(recyclerView);
                recyclerView.setNestedScrollingEnabled(false);

                if (displayResponse == null) txtCreditScore.setText("no value");
                else txtCreditHistory.setText(displayResponse);
            } else {
                Toast.makeText(MainActivity.this, "Failure while requesting Credit Score", Toast.LENGTH_LONG).show();
                txtCreditHistory.setText(MessageFormat.format("Error!{0}", response.message()));
                Log.d("Credit Score History", "Code: " + response.code() + "Message: " + response.message());
            }
        }

        @Override
        public void onFailure(Call<List<CreditScoreHistory>> call, Throwable t) {
            t.printStackTrace();
        }
    };

buy could not get any result, please help

Answer 1

Use VSCode and ThunderClient extension https://marketplace.visualstudio.com/items?itemName=rangav.vscode-thunder-client