Ya perdí el hilo de los cambios pero ahi van.

Frontend/src/services/Contables/notaCreditoDebitoService.ts

@@ -0,0 +1,54 @@
+import apiClient from '../apiClient';
+import type { NotaCreditoDebitoDto } from '../../models/dtos/Contables/NotaCreditoDebitoDto';
+import type { CreateNotaDto } from '../../models/dtos/Contables/CreateNotaDto';
+import type { UpdateNotaDto } from '../../models/dtos/Contables/UpdateNotaDto';
+
+interface GetAllNotasParams {
+    fechaDesde?: string | null; // yyyy-MM-dd
+    fechaHasta?: string | null; // yyyy-MM-dd
+    destino?: 'Distribuidores' | 'Canillas' | '' | null;
+    idDestino?: number | null;
+    idEmpresa?: number | null;
+    tipoNota?: 'Debito' | 'Credito' | '' | null;
+}
+
+const getAllNotas = async (filters: GetAllNotasParams): Promise<NotaCreditoDebitoDto[]> => {
+    const params: Record<string, string | number> = {};
+    if (filters.fechaDesde) params.fechaDesde = filters.fechaDesde;
+    if (filters.fechaHasta) params.fechaHasta = filters.fechaHasta;
+    if (filters.destino) params.destino = filters.destino;
+    if (filters.idDestino) params.idDestino = filters.idDestino;
+    if (filters.idEmpresa) params.idEmpresa = filters.idEmpresa;
+    if (filters.tipoNota) params.tipo = filters.tipoNota; // El backend espera 'tipo'
+
+    const response = await apiClient.get<NotaCreditoDebitoDto[]>('/notascreditodebito', { params });
+    return response.data;
+};
+
+const getNotaById = async (idNota: number): Promise<NotaCreditoDebitoDto> => {
+    const response = await apiClient.get<NotaCreditoDebitoDto>(`/notascreditodebito/${idNota}`);
+    return response.data;
+};
+
+const createNota = async (data: CreateNotaDto): Promise<NotaCreditoDebitoDto> => {
+    const response = await apiClient.post<NotaCreditoDebitoDto>('/notascreditodebito', data);
+    return response.data;
+};
+
+const updateNota = async (idNota: number, data: UpdateNotaDto): Promise<void> => {
+    await apiClient.put(`/notascreditodebito/${idNota}`, data);
+};
+
+const deleteNota = async (idNota: number): Promise<void> => {
+    await apiClient.delete(`/notascreditodebito/${idNota}`);
+};
+
+const notaCreditoDebitoService = {
+    getAllNotas,
+    getNotaById,
+    createNota,
+    updateNota,
+    deleteNota,
+};
+
+export default notaCreditoDebitoService;

Frontend/src/services/Contables/pagoDistribuidorService.ts

@@ -0,0 +1,52 @@
+import apiClient from '../apiClient';
+import type { PagoDistribuidorDto } from '../../models/dtos/Contables/PagoDistribuidorDto';
+import type { CreatePagoDistribuidorDto } from '../../models/dtos/Contables/CreatePagoDistribuidorDto';
+import type { UpdatePagoDistribuidorDto } from '../../models/dtos/Contables/UpdatePagoDistribuidorDto';
+
+interface GetAllPagosDistParams {
+    fechaDesde?: string | null; // yyyy-MM-dd
+    fechaHasta?: string | null; // yyyy-MM-dd
+    idDistribuidor?: number | null;
+    idEmpresa?: number | null;
+    tipoMovimiento?: 'Recibido' | 'Realizado' | '' | null;
+}
+
+const getAllPagosDistribuidor = async (filters: GetAllPagosDistParams): Promise<PagoDistribuidorDto[]> => {
+    const params: Record<string, string | number> = {};
+    if (filters.fechaDesde) params.fechaDesde = filters.fechaDesde;
+    if (filters.fechaHasta) params.fechaHasta = filters.fechaHasta;
+    if (filters.idDistribuidor) params.idDistribuidor = filters.idDistribuidor;
+    if (filters.idEmpresa) params.idEmpresa = filters.idEmpresa;
+    if (filters.tipoMovimiento) params.tipoMovimiento = filters.tipoMovimiento;
+
+    const response = await apiClient.get<PagoDistribuidorDto[]>('/pagosdistribuidor', { params });
+    return response.data;
+};
+
+const getPagoDistribuidorById = async (idPago: number): Promise<PagoDistribuidorDto> => {
+    const response = await apiClient.get<PagoDistribuidorDto>(`/pagosdistribuidor/${idPago}`);
+    return response.data;
+};
+
+const createPagoDistribuidor = async (data: CreatePagoDistribuidorDto): Promise<PagoDistribuidorDto> => {
+    const response = await apiClient.post<PagoDistribuidorDto>('/pagosdistribuidor', data);
+    return response.data;
+};
+
+const updatePagoDistribuidor = async (idPago: number, data: UpdatePagoDistribuidorDto): Promise<void> => {
+    await apiClient.put(`/pagosdistribuidor/${idPago}`, data);
+};
+
+const deletePagoDistribuidor = async (idPago: number): Promise<void> => {
+    await apiClient.delete(`/pagosdistribuidor/${idPago}`);
+};
+
+const pagoDistribuidorService = {
+    getAllPagosDistribuidor,
+    getPagoDistribuidorById,
+    createPagoDistribuidor,
+    updatePagoDistribuidor,
+    deletePagoDistribuidor,
+};
+
+export default pagoDistribuidorService;

Frontend/src/services/Contables/tipoPagoService.ts

@@ -1,7 +1,7 @@
 import apiClient from '../apiClient';
 import type { TipoPago } from '../../models/Entities/TipoPago';
-import type { CreateTipoPagoDto } from '../../models/dtos/tiposPago/CreateTipoPagoDto';
-import type { UpdateTipoPagoDto } from '../../models/dtos/tiposPago/UpdateTipoPagoDto';
+import type { CreateTipoPagoDto } from '../../models/dtos/Contables/CreateTipoPagoDto';
+import type { UpdateTipoPagoDto } from '../../models/dtos/Contables/UpdateTipoPagoDto';
 
 const getAllTiposPago = async (nombreFilter?: string): Promise<TipoPago[]> => {
     const params: Record<string, string> = {};

Frontend/src/services/Distribucion/controlDevolucionesService.ts

@@ -0,0 +1,48 @@
+import apiClient from '../apiClient';
+import type { ControlDevolucionesDto } from '../../models/dtos/Distribucion/ControlDevolucionesDto';
+import type { CreateControlDevolucionesDto } from '../../models/dtos/Distribucion/CreateControlDevolucionesDto';
+import type { UpdateControlDevolucionesDto } from '../../models/dtos/Distribucion/UpdateControlDevolucionesDto';
+
+interface GetAllControlesParams {
+    fechaDesde?: string | null; // yyyy-MM-dd
+    fechaHasta?: string | null; // yyyy-MM-dd
+    idEmpresa?: number | null;
+}
+
+const getAllControlesDevoluciones = async (filters: GetAllControlesParams): Promise<ControlDevolucionesDto[]> => {
+    const params: Record<string, string | number> = {};
+    if (filters.fechaDesde) params.fechaDesde = filters.fechaDesde;
+    if (filters.fechaHasta) params.fechaHasta = filters.fechaHasta;
+    if (filters.idEmpresa) params.idEmpresa = filters.idEmpresa;
+
+    const response = await apiClient.get<ControlDevolucionesDto[]>('/controldevoluciones', { params });
+    return response.data;
+};
+
+const getControlDevolucionesById = async (idControl: number): Promise<ControlDevolucionesDto> => {
+    const response = await apiClient.get<ControlDevolucionesDto>(`/controldevoluciones/${idControl}`);
+    return response.data;
+};
+
+const createControlDevoluciones = async (data: CreateControlDevolucionesDto): Promise<ControlDevolucionesDto> => {
+    const response = await apiClient.post<ControlDevolucionesDto>('/controldevoluciones', data);
+    return response.data;
+};
+
+const updateControlDevoluciones = async (idControl: number, data: UpdateControlDevolucionesDto): Promise<void> => {
+    await apiClient.put(`/controldevoluciones/${idControl}`, data);
+};
+
+const deleteControlDevoluciones = async (idControl: number): Promise<void> => {
+    await apiClient.delete(`/controldevoluciones/${idControl}`);
+};
+
+const controlDevolucionesService = {
+    getAllControlesDevoluciones,
+    getControlDevolucionesById,
+    createControlDevoluciones,
+    updateControlDevoluciones,
+    deleteControlDevoluciones,
+};
+
+export default controlDevolucionesService;

Frontend/src/services/Distribucion/entradaSalidaCanillaService.ts

@@ -0,0 +1,72 @@
+import apiClient from '../apiClient';
+import type { EntradaSalidaCanillaDto } from '../../models/dtos/Distribucion/EntradaSalidaCanillaDto';
+import type { CreateEntradaSalidaCanillaDto } from '../../models/dtos/Distribucion/CreateEntradaSalidaCanillaDto'; // Para creación individual si se mantiene
+import type { UpdateEntradaSalidaCanillaDto } from '../../models/dtos/Distribucion/UpdateEntradaSalidaCanillaDto';
+import type { LiquidarMovimientosCanillaRequestDto } from '../../models/dtos/Distribucion/LiquidarMovimientosCanillaDto';
+import type { CreateBulkEntradaSalidaCanillaDto } from '../../models/dtos/Distribucion/CreateBulkEntradaSalidaCanillaDto';
+
+interface GetAllESCanillaParams {
+    fechaDesde?: string | null; // yyyy-MM-dd
+    fechaHasta?: string | null; // yyyy-MM-dd
+    idPublicacion?: number | null;
+    idCanilla?: number | null;
+    liquidados?: boolean | null; // true para solo liquidados, false para solo no liquidados
+    incluirNoLiquidados?: boolean | null; // Si liquidados es null, este determina si se muestran no liquidados
+}
+
+const getAllEntradasSalidasCanilla = async (filters: GetAllESCanillaParams): Promise<EntradaSalidaCanillaDto[]> => {
+    const params: Record<string, string | number | boolean> = {};
+    if (filters.fechaDesde) params.fechaDesde = filters.fechaDesde;
+    if (filters.fechaHasta) params.fechaHasta = filters.fechaHasta;
+    if (filters.idPublicacion) params.idPublicacion = filters.idPublicacion;
+    if (filters.idCanilla) params.idCanilla = filters.idCanilla;
+    if (filters.liquidados !== undefined && filters.liquidados !== null) params.liquidados = filters.liquidados;
+    if (filters.incluirNoLiquidados !== undefined && filters.incluirNoLiquidados !== null) params.incluirNoLiquidados = filters.incluirNoLiquidados;
+
+
+    const response = await apiClient.get<EntradaSalidaCanillaDto[]>('/entradassalidascanilla', { params });
+    return response.data;
+};
+
+const getEntradaSalidaCanillaById = async (idParte: number): Promise<EntradaSalidaCanillaDto> => {
+    const response = await apiClient.get<EntradaSalidaCanillaDto>(`/entradassalidascanilla/${idParte}`);
+    return response.data;
+};
+
+// Método para creación individual (si decides mantenerlo y diferenciar en el backend o aquí)
+const createEntradaSalidaCanilla = async (data: CreateEntradaSalidaCanillaDto): Promise<EntradaSalidaCanillaDto> => {
+    console.warn("Llamando a createEntradaSalidaCanilla (single), considera usar createBulk si es para el modal de múltiples items.")
+    const response = await apiClient.post<EntradaSalidaCanillaDto>('/entradassalidascanilla', data); // Asume que el endpoint /entradassalidascanilla acepta el DTO individual
+    return response.data;
+};
+
+// Nuevo método para creación en lote
+const createBulkEntradasSalidasCanilla = async (data: CreateBulkEntradaSalidaCanillaDto): Promise<EntradaSalidaCanillaDto[]> => {
+    const response = await apiClient.post<EntradaSalidaCanillaDto[]>('/entradassalidascanilla/bulk', data); // Endpoint para el lote
+    return response.data;
+};
+
+
+const updateEntradaSalidaCanilla = async (idParte: number, data: UpdateEntradaSalidaCanillaDto): Promise<void> => {
+    await apiClient.put(`/entradassalidascanilla/${idParte}`, data);
+};
+
+const deleteEntradaSalidaCanilla = async (idParte: number): Promise<void> => {
+    await apiClient.delete(`/entradassalidascanilla/${idParte}`);
+};
+
+const liquidarMovimientos = async (data: LiquidarMovimientosCanillaRequestDto): Promise<void> => {
+    await apiClient.post('/entradassalidascanilla/liquidar', data);
+};
+
+const entradaSalidaCanillaService = {
+    getAllEntradasSalidasCanilla,
+    getEntradaSalidaCanillaById,
+    createEntradaSalidaCanilla, // Mantener si se usa
+    createBulkEntradasSalidasCanilla, // Nuevo
+    updateEntradaSalidaCanilla,
+    deleteEntradaSalidaCanilla,
+    liquidarMovimientos,
+};
+
+export default entradaSalidaCanillaService;

Frontend/src/services/Distribucion/entradaSalidaDistService.ts

@@ -12,7 +12,7 @@ interface GetAllESDistParams {
 }
 
 const getAllEntradasSalidasDist = async (filters: GetAllESDistParams): Promise<EntradaSalidaDistDto[]> => {
-    const params: Record<string, string | number> = {};
+    const params: Record<string, string | number | boolean> = {}; // Permitir boolean para que coincida con la interfaz
     if (filters.fechaDesde) params.fechaDesde = filters.fechaDesde;
     if (filters.fechaHasta) params.fechaHasta = filters.fechaHasta;
     if (filters.idPublicacion) params.idPublicacion = filters.idPublicacion;

Frontend/src/services/Radios/cancionService.ts

@@ -0,0 +1,48 @@
+import apiClient from '../apiClient';
+import type { CancionDto } from '../../models/dtos/Radios/CancionDto';
+import type { CreateCancionDto } from '../../models/dtos/Radios/CreateCancionDto';
+import type { UpdateCancionDto } from '../../models/dtos/Radios/UpdateCancionDto';
+
+interface GetAllCancionesParams {
+    temaFilter?: string | null;
+    interpreteFilter?: string | null;
+    idRitmoFilter?: number | null;
+}
+
+const getAllCanciones = async (filters: GetAllCancionesParams): Promise<CancionDto[]> => {
+    const params: Record<string, string | number> = {};
+    if (filters.temaFilter) params.tema = filters.temaFilter; // Backend espera 'tema'
+    if (filters.interpreteFilter) params.interprete = filters.interpreteFilter; // Backend espera 'interprete'
+    if (filters.idRitmoFilter) params.idRitmo = filters.idRitmoFilter; // Backend espera 'idRitmo'
+
+    const response = await apiClient.get<CancionDto[]>('/canciones', { params });
+    return response.data;
+};
+
+const getCancionById = async (id: number): Promise<CancionDto> => {
+    const response = await apiClient.get<CancionDto>(`/canciones/${id}`);
+    return response.data;
+};
+
+const createCancion = async (data: CreateCancionDto): Promise<CancionDto> => {
+    const response = await apiClient.post<CancionDto>('/canciones', data);
+    return response.data;
+};
+
+const updateCancion = async (id: number, data: UpdateCancionDto): Promise<void> => {
+    await apiClient.put(`/canciones/${id}`, data);
+};
+
+const deleteCancion = async (id: number): Promise<void> => {
+    await apiClient.delete(`/canciones/${id}`);
+};
+
+const cancionService = {
+    getAllCanciones,
+    getCancionById,
+    createCancion,
+    updateCancion,
+    deleteCancion,
+};
+
+export default cancionService;

Frontend/src/services/Radios/radioListaService.ts

@@ -0,0 +1,20 @@
+import apiClient from '../apiClient';
+import type { GenerarListaRadioRequestDto } from '../../models/dtos/Radios/GenerarListaRadioRequestDto';
+// No esperamos un DTO de respuesta complejo, sino un archivo.
+
+interface GenerarListaRadioParams extends GenerarListaRadioRequestDto {}
+
+const generarListaRadio = async (params: GenerarListaRadioParams): Promise<Blob> => {
+    // El backend devuelve un archivo (FileContentResult con "application/zip")
+    // Axios necesita responseType: 'blob' para manejar descargas de archivos.
+    const response = await apiClient.post('/radios/listas/generar', params, {
+        responseType: 'blob',
+    });
+    return response.data; // Esto será un Blob
+};
+
+const radioListaService = {
+    generarListaRadio,
+};
+
+export default radioListaService;

Frontend/src/services/Radios/ritmoService.ts

@@ -0,0 +1,40 @@
+import apiClient from '../apiClient';
+import type { RitmoDto } from '../../models/dtos/Radios/RitmoDto';
+import type { CreateRitmoDto } from '../../models/dtos/Radios/CreateRitmoDto';
+import type { UpdateRitmoDto } from '../../models/dtos/Radios/UpdateRitmoDto';
+
+const getAllRitmos = async (nombreFilter?: string): Promise<RitmoDto[]> => {
+    const params: Record<string, string> = {};
+    if (nombreFilter) params.nombre = nombreFilter; // El backend espera 'nombre'
+
+    const response = await apiClient.get<RitmoDto[]>('/ritmos', { params });
+    return response.data;
+};
+
+const getRitmoById = async (id: number): Promise<RitmoDto> => {
+    const response = await apiClient.get<RitmoDto>(`/ritmos/${id}`);
+    return response.data;
+};
+
+const createRitmo = async (data: CreateRitmoDto): Promise<RitmoDto> => {
+    const response = await apiClient.post<RitmoDto>('/ritmos', data);
+    return response.data;
+};
+
+const updateRitmo = async (id: number, data: UpdateRitmoDto): Promise<void> => {
+    await apiClient.put(`/ritmos/${id}`, data);
+};
+
+const deleteRitmo = async (id: number): Promise<void> => {
+    await apiClient.delete(`/ritmos/${id}`);
+};
+
+const ritmoService = {
+    getAllRitmos,
+    getRitmoById,
+    createRitmo,
+    updateRitmo,
+    deleteRitmo,
+};
+
+export default ritmoService;

Frontend/src/services/Usuarios/usuarioService.ts

@@ -1,9 +1,17 @@
 import apiClient from '../apiClient';
+import type { UsuarioHistorialDto } from '../../models/dtos/Usuarios/Auditoria/UsuarioHistorialDto';
 import type { UsuarioDto } from '../../models/dtos/Usuarios/UsuarioDto';
 import type { CreateUsuarioRequestDto } from '../../models/dtos/Usuarios/CreateUsuarioRequestDto';
 import type { UpdateUsuarioRequestDto } from '../../models/dtos/Usuarios/UpdateUsuarioRequestDto';
 import type { SetPasswordRequestDto } from '../../models/dtos/Usuarios/SetPasswordRequestDto';
 
+interface HistorialParams {
+    fechaDesde?: string | null; // "yyyy-MM-dd"
+    fechaHasta?: string | null; // "yyyy-MM-dd"
+    idUsuarioModifico?: number | null;
+    tipoModificacion?: string | null;
+}
+
 const getAllUsuarios = async (userFilter?: string, nombreFilter?: string): Promise<UsuarioDto[]> => {
     const params: Record<string, string> = {};
     if (userFilter) params.user = userFilter;
@@ -38,6 +46,25 @@ const toggleHabilitado = async (id: number, habilitar: boolean): Promise<void> =
     });
 };
 
+const getHistorialDeUsuario = async (idUsuarioAfectado: number, params?: Omit<HistorialParams, 'idUsuarioModifico' | 'tipoModificacion'>): Promise<UsuarioHistorialDto[]> => {
+    const queryParams: Record<string, string> = {};
+    if (params?.fechaDesde) queryParams.fechaDesde = params.fechaDesde;
+    if (params?.fechaHasta) queryParams.fechaHasta = params.fechaHasta;
+    
+    const response = await apiClient.get<UsuarioHistorialDto[]>(`/usuarios/${idUsuarioAfectado}/historial`, { params: queryParams });
+    return response.data;
+};
+
+const getTodoElHistorialDeUsuarios = async (params?: HistorialParams): Promise<UsuarioHistorialDto[]> => {
+    const queryParams: Record<string, string | number> = {};
+    if (params?.fechaDesde) queryParams.fechaDesde = params.fechaDesde;
+    if (params?.fechaHasta) queryParams.fechaHasta = params.fechaHasta;
+    if (params?.idUsuarioModifico) queryParams.idUsuarioModifico = params.idUsuarioModifico;
+    if (params?.tipoModificacion) queryParams.tipoModificacion = params.tipoModificacion;
+
+    const response = await apiClient.get<UsuarioHistorialDto[]>('/usuarios/historial', { params: queryParams });
+    return response.data;
+};
 
 const usuarioService = {
     getAllUsuarios,
@@ -46,6 +73,8 @@ const usuarioService = {
     updateUsuario,
     setPassword,
     toggleHabilitado,
+    getHistorialDeUsuario,
+    getTodoElHistorialDeUsuarios,
 };
 
 export default usuarioService;