Untitled

/// Método interno utilizado por getClients.
  /// Trae los clientes. En caso de que haya una busqueda, hace una consulta where
  Future<List<Cliente>> _peticionClients(String? busqueda,
      {bool limitar = true,
      bool verBajas = false,
      bool esProvee = false,
      DateTime? comprobarFechaSinc}) async {
    try {
      String? token = await storage.read(key: 'token');
      if (token == null) {
        throw ("Error de token");
      }

      Map<String, String> headers = {
        "Accept": "application/json",
        "xc-auth": token,
      };

      String tabla =
          !esProvee ? Constants.tablaClient : Constants.tablaProveedores;

      // Parámetros
      String where = "";
      busqueda ??= ""; //en caso de que llegue null
      //Busqueda
      where =
          Utilidades.generarWhereLike(Utilidades.camposLikeClientes, busqueda);

      if (comprobarFechaSinc != null) {
        // Modificado posterior a fechasinc
        where =
            "$where~and(Modificado,gte,${comprobarFechaSinc.toIso8601String()})";
      }
      if (!verBajas && comprobarFechaSinc == null) {
        where = "($where)~and(Baja,neq,1)";
      }

      String limitNumber;
      if (limitar) {
        limitNumber = "${Constants.limitClientes}";
      } else {
        limitNumber = "${Constants.loadLimit}";
      }

      // Realizar la primera solicitud para obtener pageInfo
      // Si limitar es true, retornará la lista después de la primera solicitud
      int offset = 0;
      Map<String, String> params = {
        'where': where,
        'limit': limitNumber,
        "offset": "$offset",
        "sort": "Nombre"
      };
      final firstResp = await http.get(
          Uri.https(Constants.apiUrl, '${Constants.apiPath}/$tabla', params),
          headers: headers);
      if (firstResp.statusCode != 200) {
        throw ("${firstResp.statusCode}: ${firstResp.body}");
      }
      dynamic jsonFirstResponse = json.decode(firstResp.body);
      List<dynamic> firstList = jsonFirstResponse['list'];
      // Añadir respuesta a listado
      List<Cliente> lista =
          firstList.map((element) => Cliente.fromJson(element)).toList();

      if (!limitar) {
        // PAGINACIÓN
        // Otener información de páginas
        int totalRows = jsonFirstResponse['pageInfo']['totalRows'];
        int pageSize = jsonFirstResponse['pageInfo']['pageSize'];
        // Calcular el número total de páginas
        int totalPages = (totalRows / pageSize).ceil();
        // Loop de paginación
        List<Future<http.Response>> requests = [];
        for (int page = 2; page <= totalPages; page++) {
          int currentOffset = (page - 1) * pageSize;
          params['offset'] =
              '$currentOffset'; // actualizar parámetro offset exponencialmente
          // Generar las solicitudes
          requests.add(http.get(
            Uri.https(Constants.apiUrl, '${Constants.apiPath}/$tabla', params),
            headers: headers,
          ));
        }
        // Esperar a que todas las solicitudes se completen
        final responses = await Future.wait(requests);
        for (final resp in responses) {
          // Añadir respuestas a listado
          if (resp.statusCode == 200) {
            dynamic jsonRowList = json.decode(resp.body);
            List<dynamic> list = jsonRowList['list'];
            for (var element in list) {
              Cliente cliente = Cliente.fromJson(element);
              lista.add(cliente);
            }
          } else {
            throw ("${resp.statusCode}: ${resp.body}");
          }
        }
      }

      return lista;
    } catch (e) {
      throw ("Error al traer clientes: ${Utilidades.mensajeError(e)}");
    }
  }
  
   /// Método utilizado por saveClient
  Future<void> subirClienteOrProveedor(Cliente cliente, bool esProvee) async {
    try {
      dynamic clientJson;
      try {
        clientJson = json.encode(cliente.toJson());
      } catch (e) {
        throw ("Error al convertir a json: $e");
      }

      String? token = await storage.read(key: 'token');

      if (token == null) {
        throw ("Error de token");
      }

      Map<String, String> headers = {
        "Content-type": "application/json",
        "Accept": "application/json",
        "xc-auth": token,
      };

      String tabla =
          !esProvee ? Constants.tablaClient : Constants.tablaProveedores;

      final resp = await http.post(
          Uri.https(Constants.apiUrl, '${Constants.apiPath}/$tabla'),
          headers: headers,
          body: clientJson);

      if (resp.statusCode != 200) {
        if (resp.body.toString().contains("Duplicate")) {
          throw ("Clave repetida. Cliente ya existe");
        }
        throw ("Error de conexión: ${resp.body}");
      } else {
        //Exitoso
      }
    } catch (e) {
      return Future.error("Error al crear: ${Utilidades.mensajeError(e)}");
    }
  }