httpsCall method

Future<Map<String, dynamic>> httpsCall(String requestType, String apiUrl, Map<String, dynamic> customHeaders, Map<String, dynamic> bodyParams, Map<String, dynamic> getParams, { bool useServerLog = true, })

Implementation

Future<Map<String, dynamic>> httpsCall(
  String requestType,
  String apiUrl,
  Map<String, dynamic> customHeaders,
  Map<String, dynamic> bodyParams,
  Map<String, dynamic> getParams, {
  bool useServerLog = true,
}) async {
  return loadConfig().then((configStr) async {
    Map<String, dynamic> config = json.decode(configStr);
    String logErrorMessage = '';

    if (config['apiKey'] != null) {
      if (debugJwtToken) {
        logDebug('HttpUtilities | httpsCall | apiKey: ${config['apiKey']}');
      }
      jwtToken = config['apiKey'];
    } else {
      if (debugJwtToken) {
        logDebug(
          'HttpUtilities | httpsCall | jwtToken: ${config["jwtToken"]}',
        );
      }
      jwtToken = config["jwtToken"];
    }

    configItems = config["configItems"];

    if (debugJwtToken) {
      logDebug(
        'HttpUtilities | loadConfig() | jwtToken: $jwtToken | configItems: $configItems',
      );
    }

    // HttpClient client = HttpClient();
    // if (configItems['ENV'] == "local") {
    //   client.badCertificateCallback =
    //       ((X509Certificate cert, String host, int port) => true);
    // }

    Map<String, String> requestHeaders = {};

    String url = '${configItems['API_URL']}/$apiUrl';
    if (getParams.isNotEmpty) {
      url += '?';
      getParams.forEach((key, value) {
        url +=
            '${Uri.encodeComponent(key)}=${Uri.encodeComponent(value.toString())}&';
      });
      // Remove the last '&' or replace with a more efficient method
      url = url.substring(0, url.length - 1);
    }
    if (httpSvcDebug) {
      logDebug('HttpUtilities | httpsCall | url: $url');
    }

    if (jwtToken.isNotEmpty) {
      requestHeaders['Authorization'] = 'Bearer $jwtToken';
    }

    customHeaders.forEach((key, value) {
      requestHeaders[key] = value;
    });

    var jsonPayload = jsonEncode(bodyParams);
    if (bodyParams.isNotEmpty) {
      requestHeaders['Content-Type'] = 'application/json; charset=UTF-8';
    }

    if (httpSvcDebug) {
      logDebug(
        'HttpUtilities | httpsCall | Request Headers: ${requestHeaders.toString()}'
        '\n| Request Body: ${bodyParams.toString()}'
        '\n| Request Get Params: ${getParams.toString()}'
        '\n| Request URL: $url'
        '\n| Request Method: $requestType',
      );
    }

    http.Response response;
    Uri urlParsed = Uri.parse(url);
    try {
      switch (requestType.toLowerCase()) {
        case "get":
          response = await http
              .get(urlParsed, headers: requestHeaders)
              .timeout(httpCallTimeout);
          break;
        case "post":
          response = await http
              .post(urlParsed, headers: requestHeaders, body: jsonPayload)
              .timeout(httpCallTimeout);
          break;
        case "put":
          response = await http
              .put(urlParsed, headers: requestHeaders, body: jsonPayload)
              .timeout(httpCallTimeout);
          break;
        case "delete":
          response = await http
              .delete(urlParsed, headers: requestHeaders, body: jsonPayload)
              .timeout(httpCallTimeout);
          break;
        case "patch":
          response = await http
              .patch(urlParsed, headers: requestHeaders, body: jsonPayload)
              .timeout(httpCallTimeout);
          break;
        default:
          logErrorMessage =
              'HttpUtilities | httpsCall | Invalid request type: $requestType';
          if (useServerLog) {
            await logError(logErrorMessage, 'HC-E010');
          } else {
            logErrorRaw(logErrorMessage);
          }
          return {
            "error": true,
            "error_message": getApiErrorMessage('internalError'),
            "status_code": 500,
            "resultset": {},
          };
      }
    } catch (e) {
      logErrorRaw('HttpUtilities | httpsCall | Error [1]: $e');
      return {
        "error": true,
        "error_message": getApiErrorMessage('serverIsDown'),
        "status_code": 500,
        "resultset": {},
      };
    }

    if (httpSvcDebug) {
      logDebug(
        'HttpUtilities | httpsCall | response.statusCode: ${response.statusCode}',
      );
      logDebug('HttpUtilities | httpsCall | response.body: ${response.body}');
    }

    Map<String, dynamic> result;
    if (response.statusCode == 200 || response.statusCode == 201) {
      try {
        result = json.decode(response.body);
      } catch (e) {
        logErrorMessage =
            'HttpUtilities | httpsCall | Error [3]: $e | response.body: ${response.body}';
        if (useServerLog) {
          await logError(logErrorMessage, 'HC-E030');
        } else {
          logErrorRaw(logErrorMessage);
        }
        return {
          "error": true,
          "error_message": getApiErrorMessage('internalError'),
          "status_code": response.statusCode,
          "resultset": {},
        };
      }
    } else {
      String errorMessage = "";
      try {
        final Map<String, dynamic> error = json.decode(response.body);
        errorMessage = error['detail'];
      } catch (e) {
        errorMessage = response.body;
      }
      if (errorMessage.isEmpty) {
        errorMessage = getApiErrorMessage('unknownError');
      }
      logErrorMessage =
          'HttpUtilities | httpsCall | Error [2]: $errorMessage | response: ${response.toString()}';
      if (useServerLog) {
        await logError(logErrorMessage, 'HC-E020');
      } else {
        logErrorRaw(logErrorMessage);
      }
      result = {
        "error": true,
        "error_message": getApiErrorMessage('serverError'),
        "error_detail": errorMessage,
        "status_code": response.statusCode,
        "resultset": {},
      };
    }

    if (httpSvcDebug) {
      logDebug('HttpUtilities | httpsCall | result: $result');
    }

    return result;
  });
}