doRequest<T> method

Future<Validation<T>> doRequest<T>()

La doRequestfa la chiamata senza isolate Per eseguire la chiamata in un isolate, usare doIsolateRequest()._authoritySe è stata impostata la cache tramite useCache tenta di recuperare il valore dalla cache. Se non esiste, esegue la chiamata e poi salva il valore nella cache usando come id l'url della chiamata.

Implementation

Future<Validation<T>> doRequest<T> ()
{
  var uri = getUri();
  var cacheId = uri.toString();
  var request = () => custom_get(uri, headers: _headers, trustBadCertificates: _trustBadCertificatesInDebug);

  // La useCache sarà il valore impostato se è una get, false in tutti gli altri casi
  var useCache = _method == RequestMethod.get
      ? _useCache
      : false;


  switch(_method)
  {
    case RequestMethod.post:
      request = () => custom_post(uri, headers: _headers, body: json.encode(_jsonBody), trustBadCertificates: _trustBadCertificatesInDebug);
      break;

    case RequestMethod.put:
      request = () => custom_put(uri, headers: _headers, body: json.encode(_jsonBody), trustBadCertificates: _trustBadCertificatesInDebug);
      break;

    case RequestMethod.delete:
      request = () => custom_delete(uri, headers: _headers, body: json.encode(_jsonBody), trustBadCertificates: _trustBadCertificatesInDebug);
      break;

    case RequestMethod.patch:
      request = () => custom_patch(uri, headers: _headers, body: json.encode(_jsonBody), trustBadCertificates: _trustBadCertificatesInDebug);
      break;

    default: // Abbiamo già impostato sopra come default la get
      break;
  }

  var preparedRequest = () => request()
                                .timeout(_timeout)
                                .then((response) {
                                  if (response.statusCode == 200 || response.statusCode == 201 || response.statusCode == 204) {
                                    if(_getResponseBytes)
                                    {
                                      return Valid(response.bodyBytes as T);
                                    }
                                    // Usiamo la utf8.decode perché in alcuni casi diceva che il body della response era malformed (Che aria è)
                                    // Forse adesso è risolto ma non si sa mai.
                                    // Se senza il decode dà un malformed, chiamare il metodo decodeResponseBodyBytes sulla RequestX
                                    else if(_decodeResponseBodyBytes)
                                    {
                                      return Valid(utf8.decode(response.bodyBytes, allowMalformed: true) as T);
                                    }
                                    else
                                    {
                                      return Valid(response.body as T);
                                    }
                                  } else {
                                    return BadResponseException(response.statusCode, responseMessage: response.body).toInvalid<T>();
                                  }
                                })
                                .catchError((e) {
                                    if (e is Exception)
                                    {
                                      return e.toInvalid<T>();
                                    }
                                    else if (e is Error)
                                    {
                                      return e.toInvalid<T>();
                                    }

                                    return Error().toInvalid<T>();
                                });

  _printLog(useCache);

  if (!useCache)
  {
    return preparedRequest();
  }

  return SingletonHttpCacheManager().getCacheOrDoRequest<T>(preparedRequest, cacheId, _cacheDuration);
}