wyatt-packages/packages/wyatt_http_client/example/wyatt_http_client_example.dart

// Copyright (C) 2022 WYATT GROUP
// Please see the AUTHORS file for details.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.

import 'dart:async';
import 'dart:io';

import 'package:wyatt_http_client/src/authentication/basic_authentication_client.dart';
import 'package:wyatt_http_client/src/authentication/bearer_authentication_client.dart';
import 'package:wyatt_http_client/src/authentication/digest_authentication_client.dart';
import 'package:wyatt_http_client/src/authentication/unsafe_authentication_client.dart';
import 'package:wyatt_http_client/src/rest_client.dart';
import 'package:wyatt_http_client/src/utils/header_keys.dart';
import 'package:wyatt_http_client/src/utils/protocols.dart';

void printAuth(HttpRequest req) {
  print(
    'Authorization => '
    "${req.headers.value('Authorization') ?? 'no authorization header'}",
  );
}

Future<void> handleBasic(HttpRequest req) async {
  printAuth(req);
}

Future<void> handleBasicNegotiate(HttpRequest req) async {
  if (req.headers.value('Authorization') == null) {
    req.response.statusCode = HttpStatus.unauthorized;
    req.response.headers
        .set(HeaderKeys.wwwAuthenticate.toString(), 'Basic realm="Wyatt"');
    print(req.response.headers.value('WWW-Authenticate'));
    return req.response.close();
  }
  printAuth(req);
}

Future<void> handleBearer(HttpRequest req) async {
  printAuth(req);
}

Future<void> handleDigest(HttpRequest req) async {
  if (req.headers.value('Authorization') == null) {
    req.response.statusCode = HttpStatus.unauthorized;
    req.response.headers.set(
      'WWW-Authenticate',
      'Digest realm="Wyatt", '
          'qop="auth,auth-int", '
          'nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", '
          'opaque="5ccc069c403ebaf9f0171e9517f40e41"',
    );
    print(req.response.headers.value('WWW-Authenticate'));
    return req.response.close();
  }
  printAuth(req);
}

Future<void> handleUnsafe(HttpRequest req) async {
  print(
    'Query parameters => '
    '${req.uri.queryParameters.toString()}',
  );
}

Future<void> server() async {
  final server = await HttpServer.bind(InternetAddress.anyIPv6, 8080);
  var error = 0;
  var token = 0;
  await server.forEach((HttpRequest request) {
    print('[${request.method}] ${request.uri}');
    switch (request.uri.path) {
      case '/test/basic-test':
        handleBasic(request);
        break;
      case '/test/basic-test-with-negotiate':
        handleBasicNegotiate(request);
        break;
      case '/test/digest-test':
        handleDigest(request);
        break;
      case '/test/apikey-test':
        handleBearer(request);
        break;
      case '/test/bearer-test':
        handleBearer(request);
        break;
      case '/test/unsafe-test':
        handleUnsafe(request);
        break;

      case '/test/bearer-login':
        if (request.method == 'POST') {
          request.response.write('{"token": "access-token-test"}');
        }
        break;

      case '/test/oauth2-test-error':
        error++;
        print('Error $error');
        if (error >= 3) {
          print('Authorized');
          error = 0;
        } else {
          request.response.statusCode = HttpStatus.unauthorized;
        }
        break;
      case '/test/oauth2-test-timeout':
        error++;
        print('Error $error');
        request.response.statusCode = HttpStatus.unauthorized;
        break;
      case '/test/oauth2-test':
        print(
          'Authorization => '
          "${request.headers.value('Authorization') ?? 'no access token'}",
        );
        break;
      case '/test/oauth2-login':
        if (request.method == 'POST') {
          token++;
          request.response.write(
            '{"accessToken": "access-token-awesome$token", '
            '"refreshToken": "refresh-token-awesome$token"}',
          );
        }
        break;
      case '/test/oauth2-refresh':
        print(
          'Authorization => '
          "${request.headers.value('Authorization') ?? 'no refresh token'}",
        );
        if (request.method == 'GET') {
          token++;
          request.response
              .write('{"accessToken": "access-token-refreshed$token"}');
        }
        break;
      case '/test/oauth2-refresh-error':
        request.response.statusCode = HttpStatus.unauthorized;
        break;

      default:
        print(' => Unknown path or method');
        request.response.statusCode = HttpStatus.notFound;
    }
    request.response.close();
    print('====================');
  });
}

Future<void> main() async {
  unawaited(server());
  final base = 'localhost:8080';
  final restClient = RestClient(protocol: Protocols.http, authority: base);

  // Basic
  final basic = BasicAuthenticationClient(
    username: 'username',
    password: 'password',
    inner: restClient,
  );
  await basic.get(Uri.parse('/test/basic-test'));

  // Basic with negotiate
  final basicWithNegotiate = BasicAuthenticationClient(
    username: 'username',
    password: 'password',
    preemptive: false,
    inner: restClient,
  );
  await basicWithNegotiate.get(Uri.parse('/test/basic-test-with-negotiate'));

  // Digest
  final digest = DigestAuthenticationClient(
    username: 'Mufasa',
    password: 'Circle Of Life',
    inner: restClient,
  );
  await digest.get(Uri.parse('/test/digest-test'));

  // Bearer
  final bearer = BearerAuthenticationClient(
    token: 'access-token-test',
    inner: restClient,
  );
  await bearer.get(Uri.parse('/test/bearer-test'));

  // API Key
  final apiKey = BearerAuthenticationClient(
    token: 'awesome-api-key',
    authenticationMethod: 'ApiKey',
    inner: restClient,
  );
  await apiKey.get(Uri.parse('/test/apikey-test'));

  // Unsafe URL
  final unsafe = UnsafeAuthenticationClient(
    username: 'Mufasa',
    password: 'Circle Of Life',
    inner: restClient,
  );
  await unsafe.get(Uri.parse('/test/unsafe-test'));

  exit(0);
}