← Volver al Swagger

Ejemplos de Uso - API Vehiculos

Practica Final - Aplicaciones Moviles ITLA

Base URL: Reemplaza BASE_URL con la URL de tu servidor (ej: http://localhost:8000/api).
Convencion: Todos los POST envian los datos JSON en un campo datax via form-encoded.
Filtrar por framework: Flutter | React/Fetch | Ionic/Angular

Como usar el Bearer Token (Autenticacion)

Los endpoints marcados con Auth requieren enviar el token en el header Authorization. El token se obtiene al hacer login o activar la cuenta. Debes guardarlo en tu app y enviarlo en cada peticion protegida.

Formato del header: Authorization: Bearer TU_TOKEN_AQUI

Flutter (Dart)
React (Fetch)
Ionic (Angular)
import 'package:http/http.dart' as http;
import 'dart:convert';
import 'package:shared_preferences/shared_preferences.dart';

const String BASE_URL = 'http://TU_SERVIDOR/api';

// ---- Guardar token al hacer login ----
Future<void> login(String matricula, String contrasena) async {
  final response = await http.post(
    Uri.parse('$BASE_URL/auth/login'),
    body: {'datax': jsonEncode({'matricula': matricula, 'contrasena': contrasena})},
  );
  final data = jsonDecode(response.body);
  if (data['success']) {
    final prefs = await SharedPreferences.getInstance();
    await prefs.setString('token', data['data']['token']);
  }
}

// ---- Obtener token guardado ----
Future<String?> getToken() async {
  final prefs = await SharedPreferences.getInstance();
  return prefs.getString('token');
}

// ---- Llamada GET con Bearer Token ----
Future<Map> getConAuth(String endpoint) async {
  final token = await getToken();
  final response = await http.get(
    Uri.parse('$BASE_URL/$endpoint'),
    headers: {
      'Authorization': 'Bearer $token',    // <-- ASI SE PASA EL TOKEN
    },
  );
  return jsonDecode(response.body);
}

// ---- Llamada POST con Bearer Token ----
Future<Map> postConAuth(String endpoint, Map datos) async {
  final token = await getToken();
  final response = await http.post(
    Uri.parse('$BASE_URL/$endpoint'),
    headers: {
      'Authorization': 'Bearer $token',    // <-- ASI SE PASA EL TOKEN
    },
    body: {
      'datax': jsonEncode(datos),
    },
  );
  return jsonDecode(response.body);
}

// ---- Ejemplo de uso ----
// final perfil = await getConAuth('perfil');
// final resultado = await postConAuth('vehiculos', {'placa': 'A123', ...});

const BASE_URL = 'http://TU_SERVIDOR/api';

// ---- Guardar token al hacer login ----
async function login(matricula, contrasena) {
  const formData = new URLSearchParams();
  formData.append('datax', JSON.stringify({ matricula, contrasena }));

  const response = await fetch(`${BASE_URL}/auth/login`, {
    method: 'POST',
    body: formData,
  });
  const data = await response.json();
  if (data.success) {
    localStorage.setItem('token', data.data.token);
  }
  return data;
}

// ---- Obtener token guardado ----
function getToken() {
  return localStorage.getItem('token');
}

// ---- Llamada GET con Bearer Token ----
async function getConAuth(endpoint) {
  const token = getToken();
  const response = await fetch(`${BASE_URL}/${endpoint}`, {
    headers: {
      'Authorization': `Bearer ${token}`,  // <-- ASI SE PASA EL TOKEN
    },
  });
  return await response.json();
}

// ---- Llamada POST con Bearer Token ----
async function postConAuth(endpoint, datos) {
  const token = getToken();
  const formData = new URLSearchParams();
  formData.append('datax', JSON.stringify(datos));

  const response = await fetch(`${BASE_URL}/${endpoint}`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${token}`,  // <-- ASI SE PASA EL TOKEN
    },
    body: formData,
  });
  return await response.json();
}

// ---- Ejemplo de uso ----
// const perfil = await getConAuth('perfil');
// const resultado = await postConAuth('vehiculos', { placa: 'A123', ... });

// ---- auth.service.ts ----
import { Injectable } from '@angular/core';
import { HttpClient, HttpHeaders } from '@angular/common/http';
import { Storage } from '@ionic/storage-angular';

@Injectable({ providedIn: 'root' })
export class ApiService {
  private BASE_URL = 'http://TU_SERVIDOR/api';

  constructor(private http: HttpClient, private storage: Storage) {}

  // Guardar token al hacer login
  async login(matricula: string, contrasena: string) {
    const body = new FormData();
    body.append('datax', JSON.stringify({ matricula, contrasena }));

    const data: any = await this.http.post(`${this.BASE_URL}/auth/login`, body).toPromise();
    if (data.success) {
      await this.storage.set('token', data.data.token);
    }
    return data;
  }

  // Obtener headers con Bearer Token
  private async getAuthHeaders(): Promise<HttpHeaders> {
    const token = await this.storage.get('token');
    return new HttpHeaders({
      'Authorization': `Bearer ${token}`   // <-- ASI SE PASA EL TOKEN
    });
  }

  // Llamada GET con Bearer Token
  async getConAuth(endpoint: string, params: any = {}) {
    const headers = await this.getAuthHeaders();
    return this.http.get(`${this.BASE_URL}/${endpoint}`, { headers, params }).toPromise();
  }

  // Llamada POST con Bearer Token
  async postConAuth(endpoint: string, datos: any) {
    const headers = await this.getAuthHeaders();
    const body = new FormData();
    body.append('datax', JSON.stringify(datos));
    return this.http.post(`${this.BASE_URL}/${endpoint}`, body, { headers }).toPromise();
  }
}

// ---- En el componente ----
// const perfil = await this.api.getConAuth('perfil');
// const resultado = await this.api.postConAuth('vehiculos', { placa: 'A123', ... });

1. Autenticacion

POST /auth/registro Publico

Registrar usuario (solo matricula)

Flutter (Dart)
React (Fetch)
Ionic (Angular)
import 'package:http/http.dart' as http;
import 'dart:convert';

Future<Map> registro(String matricula) async {
  final response = await http.post(
    Uri.parse('$BASE_URL/auth/registro'),
    body: {
      'datax': jsonEncode({'matricula': matricula}),
    },
  );
  return jsonDecode(response.body);
}

// Uso:
final result = await registro('20240096');
print(result['data']['token']); // Token temporal

async function registro(matricula) {
  const formData = new URLSearchParams();
  formData.append('datax', JSON.stringify({ matricula }));

  const response = await fetch(`${BASE_URL}/auth/registro`, {
    method: 'POST',
    body: formData,
  });
  return await response.json();
}

// Uso:
const result = await registro('20240096');
console.log(result.data.token); // Token temporal

import { HttpClient } from '@angular/common/http';

registro(matricula: string) {
  const body = new FormData();
  body.append('datax', JSON.stringify({ matricula }));

  return this.http.post(`${this.BASE_URL}/auth/registro`, body);
}

// En el componente:
this.authService.registro('20240096').subscribe(res => {
  console.log(res.data.token); // Token temporal
});
POST /auth/activar Publico

Activar cuenta (establecer contrasena)

Flutter
React
Ionic
Future<Map> activar(String token, String contrasena) async {
  final response = await http.post(
    Uri.parse('$BASE_URL/auth/activar'),
    body: {
      'datax': jsonEncode({'token': token, 'contrasena': contrasena}),
    },
  );
  return jsonDecode(response.body);
}

// Uso:
final result = await activar('aB3kLm9xPq2Rw7Tz5Yv', 'miClave123');
print(result['data']['token']); // Token definitivo

async function activar(token, contrasena) {
  const formData = new URLSearchParams();
  formData.append('datax', JSON.stringify({ token, contrasena }));

  const response = await fetch(`${BASE_URL}/auth/activar`, {
    method: 'POST',
    body: formData,
  });
  return await response.json();
}

// Uso:
const result = await activar('aB3kLm9xPq2Rw7Tz5Yv', 'miClave123');
localStorage.setItem('token', result.data.token);

activar(token: string, contrasena: string) {
  const body = new FormData();
  body.append('datax', JSON.stringify({ token, contrasena }));

  return this.http.post(`${this.BASE_URL}/auth/activar`, body);
}

// En el componente:
this.authService.activar('aB3kLm9xPq2Rw7Tz5Yv', 'miClave123').subscribe(res => {
  this.storage.set('token', res.data.token);
});
POST /auth/olvidar Publico

Olvidar contrasena

Flutter
React
Ionic
Future<Map> olvidarContrasena(String matricula) async {
  final response = await http.post(
    Uri.parse('$BASE_URL/auth/olvidar'),
    body: {
      'datax': jsonEncode({'matricula': matricula}),
    },
  );
  return jsonDecode(response.body);
}

async function olvidarContrasena(matricula) {
  const formData = new URLSearchParams();
  formData.append('datax', JSON.stringify({ matricula }));

  const response = await fetch(`${BASE_URL}/auth/olvidar`, {
    method: 'POST',
    body: formData,
  });
  return await response.json();
}

olvidarContrasena(matricula: string) {
  const body = new FormData();
  body.append('datax', JSON.stringify({ matricula }));

  return this.http.post(`${this.BASE_URL}/auth/olvidar`, body);
}
POST /auth/login Publico

Iniciar sesion

2. Perfil

GET /perfil Auth

Obtener perfil

Flutter
React
Ionic
Future<Map> getPerfil(String token) async {
  final response = await http.get(
    Uri.parse('$BASE_URL/perfil'),
    headers: {'Authorization': 'Bearer $token'},
  );
  return jsonDecode(response.body);
}

async function getPerfil(token) {
  const response = await fetch(`${BASE_URL}/perfil`, {
    headers: { 'Authorization': `Bearer ${token}` },
  });
  return await response.json();
}

getPerfil() {
  const token = this.storage.get('token');
  return this.http.get(`${this.BASE_URL}/perfil`, {
    headers: { Authorization: `Bearer ${token}` }
  });
}

3. Vehiculos

GET /vehiculos Auth

Listar vehiculos

Flutter
React
Ionic
Future<Map> getVehiculos(String token, {String? marca, int page = 1}) async {
  final params = {'page': '$page'};
  if (marca != null) params['marca'] = marca;

  final uri = Uri.parse('$BASE_URL/vehiculos').replace(queryParameters: params);
  final response = await http.get(uri, headers: {'Authorization': 'Bearer $token'});
  return jsonDecode(response.body);
}

async function getVehiculos(token, { marca, page = 1 } = {}) {
  const params = new URLSearchParams({ page });
  if (marca) params.append('marca', marca);

  const response = await fetch(`${BASE_URL}/vehiculos?${params}`, {
    headers: { 'Authorization': `Bearer ${token}` },
  });
  return await response.json();
}

getVehiculos(marca?: string, page = 1) {
  const token = this.storage.get('token');
  let params: any = { page };
  if (marca) params.marca = marca;

  return this.http.get(`${this.BASE_URL}/vehiculos`, {
    headers: { Authorization: `Bearer ${token}` },
    params
  });
}
POST /vehiculos Auth

Registrar vehiculo (con foto opcional)

Flutter
React
Ionic
import 'package:http/http.dart' as http;

Future<Map> crearVehiculo(String token, Map datos, {File? foto}) async {
  var request = http.MultipartRequest('POST', Uri.parse('$BASE_URL/vehiculos'));
  request.headers['Authorization'] = 'Bearer $token';
  request.fields['datax'] = jsonEncode(datos);

  if (foto != null) {
    request.files.add(await http.MultipartFile.fromPath('foto', foto.path));
  }

  final response = await request.send();
  final body = await response.stream.bytesToString();
  return jsonDecode(body);
}

// Uso:
final result = await crearVehiculo(token, {
  'placa': 'A123456',
  'chasis': '1HGCM82633A004352',
  'marca': 'Toyota',
  'modelo': 'Corolla',
  'anio': 2022,
  'cantidadRuedas': 4,
});

async function crearVehiculo(token, datos, foto = null) {
  const formData = new FormData();
  formData.append('datax', JSON.stringify(datos));
  if (foto) formData.append('foto', foto); // File object

  const response = await fetch(`${BASE_URL}/vehiculos`, {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${token}` },
    body: formData,
  });
  return await response.json();
}

// Uso:
const result = await crearVehiculo(token, {
  placa: 'A123456', chasis: '1HGCM82633A004352',
  marca: 'Toyota', modelo: 'Corolla', anio: 2022, cantidadRuedas: 4
});

crearVehiculo(datos: any, foto?: File) {
  const token = this.storage.get('token');
  const formData = new FormData();
  formData.append('datax', JSON.stringify(datos));
  if (foto) formData.append('foto', foto);

  return this.http.post(`${this.BASE_URL}/vehiculos`, formData, {
    headers: { Authorization: `Bearer ${token}` }
  });
}
GET /vehiculos/detalle?id=1 Auth

Detalle de vehiculo con resumen financiero

Flutter
React
Ionic
Future<Map> getVehiculoDetalle(String token, int id) async {
  final response = await http.get(
    Uri.parse('$BASE_URL/vehiculos/detalle?id=$id'),
    headers: {'Authorization': 'Bearer $token'},
  );
  return jsonDecode(response.body);
}

async function getVehiculoDetalle(token, id) {
  const response = await fetch(`${BASE_URL}/vehiculos/detalle?id=${id}`, {
    headers: { 'Authorization': `Bearer ${token}` },
  });
  return await response.json();
}

getVehiculoDetalle(id: number) {
  const token = this.storage.get('token');
  return this.http.get(`${this.BASE_URL}/vehiculos/detalle`, {
    headers: { Authorization: `Bearer ${token}` },
    params: { id }
  });
}

4. Mantenimientos

GET /mantenimientos?vehiculo_id=1 Auth

Listar mantenimientos

Flutter
React
Ionic
Future<Map> getMantenimientos(String token, int vehiculoId) async {
  final response = await http.get(
    Uri.parse('$BASE_URL/mantenimientos?vehiculo_id=$vehiculoId'),
    headers: {'Authorization': 'Bearer $token'},
  );
  return jsonDecode(response.body);
}

async function getMantenimientos(token, vehiculoId) {
  const response = await fetch(`${BASE_URL}/mantenimientos?vehiculo_id=${vehiculoId}`, {
    headers: { 'Authorization': `Bearer ${token}` },
  });
  return await response.json();
}

getMantenimientos(vehiculoId: number) {
  const token = this.storage.get('token');
  return this.http.get(`${this.BASE_URL}/mantenimientos`, {
    headers: { Authorization: `Bearer ${token}` },
    params: { vehiculo_id: vehiculoId }
  });
}
POST /mantenimientos Auth

Registrar mantenimiento (con fotos opcionales)

Flutter
React
Ionic
Future<Map> crearMantenimiento(String token, Map datos, {List<File>? fotos}) async {
  var request = http.MultipartRequest('POST', Uri.parse('$BASE_URL/mantenimientos'));
  request.headers['Authorization'] = 'Bearer $token';
  request.fields['datax'] = jsonEncode(datos);

  if (fotos != null) {
    for (var foto in fotos) {
      request.files.add(await http.MultipartFile.fromPath('fotos[]', foto.path));
    }
  }

  final response = await request.send();
  final body = await response.stream.bytesToString();
  return jsonDecode(body);
}

// Uso:
final result = await crearMantenimiento(token, {
  'vehiculo_id': 1,
  'tipo': 'Cambio de aceite',
  'costo': 2500,
  'piezas': 'Filtro de aceite',
});

async function crearMantenimiento(token, datos, fotos = []) {
  const formData = new FormData();
  formData.append('datax', JSON.stringify(datos));
  fotos.forEach(foto => formData.append('fotos[]', foto));

  const response = await fetch(`${BASE_URL}/mantenimientos`, {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${token}` },
    body: formData,
  });
  return await response.json();
}

crearMantenimiento(datos: any, fotos: File[] = []) {
  const token = this.storage.get('token');
  const formData = new FormData();
  formData.append('datax', JSON.stringify(datos));
  fotos.forEach(f => formData.append('fotos[]', f));

  return this.http.post(`${this.BASE_URL}/mantenimientos`, formData, {
    headers: { Authorization: `Bearer ${token}` }
  });
}

5. Combustible y Aceite

GET /combustibles?vehiculo_id=1 Auth POST /combustibles

Listar y registrar combustible/aceite

Flutter
React
Ionic
// LISTAR
Future<Map> getCombustibles(String token, int vehiculoId) async {
  final response = await http.get(
    Uri.parse('$BASE_URL/combustibles?vehiculo_id=$vehiculoId'),
    headers: {'Authorization': 'Bearer $token'},
  );
  return jsonDecode(response.body);
}

// REGISTRAR
Future<Map> crearCombustible(String token, Map datos) async {
  final response = await http.post(
    Uri.parse('$BASE_URL/combustibles'),
    headers: {'Authorization': 'Bearer $token'},
    body: {'datax': jsonEncode(datos)},
  );
  return jsonDecode(response.body);
}

// Uso:
await crearCombustible(token, {
  'vehiculo_id': 1, 'tipo': 'combustible',
  'cantidad': 15.5, 'unidad': 'galones', 'monto': 3800,
});

// LISTAR
async function getCombustibles(token, vehiculoId) {
  const response = await fetch(`${BASE_URL}/combustibles?vehiculo_id=${vehiculoId}`, {
    headers: { 'Authorization': `Bearer ${token}` },
  });
  return await response.json();
}

// REGISTRAR
async function crearCombustible(token, datos) {
  const formData = new URLSearchParams();
  formData.append('datax', JSON.stringify(datos));

  const response = await fetch(`${BASE_URL}/combustibles`, {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${token}` },
    body: formData,
  });
  return await response.json();
}

// LISTAR
getCombustibles(vehiculoId: number) {
  const token = this.storage.get('token');
  return this.http.get(`${this.BASE_URL}/combustibles`, {
    headers: { Authorization: `Bearer ${token}` },
    params: { vehiculo_id: vehiculoId }
  });
}

// REGISTRAR
crearCombustible(datos: any) {
  const token = this.storage.get('token');
  const body = new FormData();
  body.append('datax', JSON.stringify(datos));

  return this.http.post(`${this.BASE_URL}/combustibles`, body, {
    headers: { Authorization: `Bearer ${token}` }
  });
}

6. Gomas

GET /gomas?vehiculo_id=1 Auth

Estado de gomas

Flutter
React
Ionic
Future<Map> getGomas(String token, int vehiculoId) async {
  final response = await http.get(
    Uri.parse('$BASE_URL/gomas?vehiculo_id=$vehiculoId'),
    headers: {'Authorization': 'Bearer $token'},
  );
  return jsonDecode(response.body);
}

async function getGomas(token, vehiculoId) {
  const response = await fetch(`${BASE_URL}/gomas?vehiculo_id=${vehiculoId}`, {
    headers: { 'Authorization': `Bearer ${token}` },
  });
  return await response.json();
}

getGomas(vehiculoId: number) {
  const token = this.storage.get('token');
  return this.http.get(`${this.BASE_URL}/gomas`, {
    headers: { Authorization: `Bearer ${token}` },
    params: { vehiculo_id: vehiculoId }
  });
}
POST /gomas/actualizar Auth POST /gomas/pinchazos

Actualizar estado y registrar pinchazos

Flutter
React
Ionic
// ACTUALIZAR ESTADO
Future<Map> actualizarGoma(String token, int gomaId, String estado) async {
  final response = await http.post(
    Uri.parse('$BASE_URL/gomas/actualizar'),
    headers: {'Authorization': 'Bearer $token'},
    body: {'datax': jsonEncode({'goma_id': gomaId, 'estado': estado})},
  );
  return jsonDecode(response.body);
}

// REGISTRAR PINCHAZO
Future<Map> registrarPinchazo(String token, int gomaId, String descripcion) async {
  final response = await http.post(
    Uri.parse('$BASE_URL/gomas/pinchazos'),
    headers: {'Authorization': 'Bearer $token'},
    body: {'datax': jsonEncode({'goma_id': gomaId, 'descripcion': descripcion})},
  );
  return jsonDecode(response.body);
}

// ACTUALIZAR ESTADO
async function actualizarGoma(token, gomaId, estado) {
  const formData = new URLSearchParams();
  formData.append('datax', JSON.stringify({ goma_id: gomaId, estado }));

  const response = await fetch(`${BASE_URL}/gomas/actualizar`, {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${token}` },
    body: formData,
  });
  return await response.json();
}

// REGISTRAR PINCHAZO
async function registrarPinchazo(token, gomaId, descripcion) {
  const formData = new URLSearchParams();
  formData.append('datax', JSON.stringify({ goma_id: gomaId, descripcion }));

  const response = await fetch(`${BASE_URL}/gomas/pinchazos`, {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${token}` },
    body: formData,
  });
  return await response.json();
}

// ACTUALIZAR ESTADO
actualizarGoma(gomaId: number, estado: string) {
  const token = this.storage.get('token');
  const body = new FormData();
  body.append('datax', JSON.stringify({ goma_id: gomaId, estado }));

  return this.http.post(`${this.BASE_URL}/gomas/actualizar`, body, {
    headers: { Authorization: `Bearer ${token}` }
  });
}

// REGISTRAR PINCHAZO
registrarPinchazo(gomaId: number, descripcion: string) {
  const token = this.storage.get('token');
  const body = new FormData();
  body.append('datax', JSON.stringify({ goma_id: gomaId, descripcion }));

  return this.http.post(`${this.BASE_URL}/gomas/pinchazos`, body, {
    headers: { Authorization: `Bearer ${token}` }
  });
}

7. Gastos

GET /gastos/categorias Auth GET /gastos?vehiculo_id=1 POST /gastos

Categorias, listar y registrar gastos

Flutter
React
Ionic
// CATEGORIAS
Future<Map> getCategorias(String token) async {
  final response = await http.get(
    Uri.parse('$BASE_URL/gastos/categorias'),
    headers: {'Authorization': 'Bearer $token'},
  );
  return jsonDecode(response.body);
}

// LISTAR GASTOS
Future<Map> getGastos(String token, int vehiculoId) async {
  final response = await http.get(
    Uri.parse('$BASE_URL/gastos?vehiculo_id=$vehiculoId'),
    headers: {'Authorization': 'Bearer $token'},
  );
  return jsonDecode(response.body);
}

// REGISTRAR GASTO
Future<Map> crearGasto(String token, Map datos) async {
  final response = await http.post(
    Uri.parse('$BASE_URL/gastos'),
    headers: {'Authorization': 'Bearer $token'},
    body: {'datax': jsonEncode(datos)},
  );
  return jsonDecode(response.body);
}

// CATEGORIAS
async function getCategorias(token) {
  const response = await fetch(`${BASE_URL}/gastos/categorias`, {
    headers: { 'Authorization': `Bearer ${token}` },
  });
  return await response.json();
}

// LISTAR GASTOS
async function getGastos(token, vehiculoId) {
  const response = await fetch(`${BASE_URL}/gastos?vehiculo_id=${vehiculoId}`, {
    headers: { 'Authorization': `Bearer ${token}` },
  });
  return await response.json();
}

// REGISTRAR GASTO
async function crearGasto(token, datos) {
  const formData = new URLSearchParams();
  formData.append('datax', JSON.stringify(datos));

  const response = await fetch(`${BASE_URL}/gastos`, {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${token}` },
    body: formData,
  });
  return await response.json();
}

// CATEGORIAS
getCategorias() {
  const token = this.storage.get('token');
  return this.http.get(`${this.BASE_URL}/gastos/categorias`, {
    headers: { Authorization: `Bearer ${token}` }
  });
}

// LISTAR GASTOS
getGastos(vehiculoId: number) {
  const token = this.storage.get('token');
  return this.http.get(`${this.BASE_URL}/gastos`, {
    headers: { Authorization: `Bearer ${token}` },
    params: { vehiculo_id: vehiculoId }
  });
}

// REGISTRAR GASTO
crearGasto(datos: any) {
  const token = this.storage.get('token');
  const body = new FormData();
  body.append('datax', JSON.stringify(datos));

  return this.http.post(`${this.BASE_URL}/gastos`, body, {
    headers: { Authorization: `Bearer ${token}` }
  });
}

8. Ingresos / Ganancias

GET /ingresos?vehiculo_id=1 Auth POST /ingresos

Listar y registrar ingresos

Flutter
React
Ionic
// LISTAR
Future<Map> getIngresos(String token, int vehiculoId) async {
  final response = await http.get(
    Uri.parse('$BASE_URL/ingresos?vehiculo_id=$vehiculoId'),
    headers: {'Authorization': 'Bearer $token'},
  );
  return jsonDecode(response.body);
}

// REGISTRAR
Future<Map> crearIngreso(String token, Map datos) async {
  final response = await http.post(
    Uri.parse('$BASE_URL/ingresos'),
    headers: {'Authorization': 'Bearer $token'},
    body: {'datax': jsonEncode(datos)},
  );
  return jsonDecode(response.body);
}

// Uso:
await crearIngreso(token, {
  'vehiculo_id': 1, 'monto': 25000, 'concepto': 'Transporte semanal',
});

// LISTAR
async function getIngresos(token, vehiculoId) {
  const response = await fetch(`${BASE_URL}/ingresos?vehiculo_id=${vehiculoId}`, {
    headers: { 'Authorization': `Bearer ${token}` },
  });
  return await response.json();
}

// REGISTRAR
async function crearIngreso(token, datos) {
  const formData = new URLSearchParams();
  formData.append('datax', JSON.stringify(datos));

  const response = await fetch(`${BASE_URL}/ingresos`, {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${token}` },
    body: formData,
  });
  return await response.json();
}

// LISTAR
getIngresos(vehiculoId: number) {
  const token = this.storage.get('token');
  return this.http.get(`${this.BASE_URL}/ingresos`, {
    headers: { Authorization: `Bearer ${token}` },
    params: { vehiculo_id: vehiculoId }
  });
}

// REGISTRAR
crearIngreso(datos: any) {
  const token = this.storage.get('token');
  const body = new FormData();
  body.append('datax', JSON.stringify(datos));

  return this.http.post(`${this.BASE_URL}/ingresos`, body, {
    headers: { Authorization: `Bearer ${token}` }
  });
}

9. Noticias

GET /noticias Auth GET /noticias/detalle?id=1

Listar y ver detalle de noticias

Flutter
React
Ionic
Future<Map> getNoticias(String token, {int page = 1}) async {
  final response = await http.get(
    Uri.parse('$BASE_URL/noticias?page=$page'),
    headers: {'Authorization': 'Bearer $token'},
  );
  return jsonDecode(response.body);
}

Future<Map> getNoticiaDetalle(String token, int id) async {
  final response = await http.get(
    Uri.parse('$BASE_URL/noticias/detalle?id=$id'),
    headers: {'Authorization': 'Bearer $token'},
  );
  return jsonDecode(response.body);
}

async function getNoticias(token, page = 1) {
  const response = await fetch(`${BASE_URL}/noticias?page=${page}`, {
    headers: { 'Authorization': `Bearer ${token}` },
  });
  return await response.json();
}

async function getNoticiaDetalle(token, id) {
  const response = await fetch(`${BASE_URL}/noticias/detalle?id=${id}`, {
    headers: { 'Authorization': `Bearer ${token}` },
  });
  return await response.json();
}

getNoticias(page = 1) {
  const token = this.storage.get('token');
  return this.http.get(`${this.BASE_URL}/noticias`, {
    headers: { Authorization: `Bearer ${token}` },
    params: { page }
  });
}

getNoticiaDetalle(id: number) {
  const token = this.storage.get('token');
  return this.http.get(`${this.BASE_URL}/noticias/detalle`, {
    headers: { Authorization: `Bearer ${token}` },
    params: { id }
  });
}

10. Catalogo

GET /catalogo Auth GET /catalogo/detalle?id=1

Listar y ver detalle del catalogo