### Menús adaptados por rol [#menús-adaptados-por-rol]
Los menús también se adaptan al rol de cada usuario para que cada uno vea solo lo que necesita.
En este ejemplo:
* El **Comercial** accede a un menú reducido, centrado en su operativa diaria: productos, documentación y ayuda.
* El **Administrador** dispone de un menú completo con acceso a todas las áreas del sistema: presupuestos, ventas, compras, gastos, nóminas, etc.
## Crear o editar un rol [#crear-o-editar-un-rol-]
1. Desde Dinaup Desktop navega hacia `Configuración`\
2. Haz clic en `Roles` \
3. Desde ahí puedes **Agregar** o **Editar** los roles existentes\
## Configuración de una sección [#configuración-de-una-sección]
Para dar acceso a una sección dentro de un rol, sigue estos pasos:
* Abre la configuración del rol desde **Configuración > Roles**.
* En el panel izquierdo, verás el listado de secciones activas. Si está vacío, no hay ninguna aún.
* Haz clic en el botón **Opciones...** (abajo a la izquierda).
* Selecciona **Administrar Secciones** en el menú emergente.
* Se abrirá la ventana de secciones (como la que ves en la imagen).
* Activa o desactiva el acceso a cada sección. Verás el estado actualizado como:
* 🔒 **Accesible** → el usuario podrá entrar a la sección.
* 🚫 **Sin acceso** → la sección estará oculta para ese rol.
### Configurar permisos de una sección [#configurar-permisos-de-una-sección]
Una vez hayas activado una sección en el panel izquierdo, toca definir qué puede hacer el rol dentro de esa sección.
* Haz clic en la sección (por ejemplo, **Empleados**).
* En la parte central verás todos los permisos disponibles (Agregar, Eliminar, Ver eliminados, Ver histórico)
* Haz clic en cada permiso para activarlo (✔) o desactivarlo (🚫).
* Usa los botones **Solo lectura** o **Todo** si quieres aplicar un conjunto de permisos de forma rápida.
### Diseños de las secciones [#diseños-de-las-secciones-]
El diseño de una `Sección` determina la distribución de los campos, así como los campos bloqueados, los campos obligatorios, etc.
2. En la ventana que se abre, pulsa Configurar.
3. Continúa a partir del paso 5 de [Crear un diseño personalizado](/docs/cuenta/permisos-y-roles#crear-un-dise-o-personalizado)
### Asignar roles a un empleado [#asignar-roles-a-un-empleado-]
Asigna los roles desde la web, en el apartado Secure Link.
# Preguntas frecuentes (/docs/cuenta/preguntas-frecuentes)
Dudas frecuentes sobre cuenta y usuarios. Si no encuentras la respuesta, escribe a `soporte@dinaup.com` o abre el chat de ayuda en [play.dinaup.com](https://play.dinaup.com).
***
## Primeros pasos y cuenta [#primeros-pasos-y-cuenta]
**Datos de Empresa** | Campo | Descripción | | ---------------- | --------------------------------------------- | | **Razón social** | Nombre legal de tu empresa | | **NIF/CIF** | Número de identificación fiscal de la empresa | | **Teléfono** | Teléfono de contacto de la empresa | **Dirección** | Campo | Descripción | | ----------------- | ------------------------------------------------------- | | **Dirección** | Dirección fiscal principal de la empresa | | **Dirección 2** | Información adicional de dirección (piso, puerta, etc.) | | **Municipio** | Ciudad o localidad | | **Provincia** | Provincia o región | | **Código Postal** | Código postal de la dirección | | **País** | Selecciona tu país en el desplegable | #### Finalizar el registro [#finalizar-el-registro] Una vez completados todos los campos, pulsa el botón **"Crear perfil de empresa"** para finalizar el registro y activar tu licencia.
### Solicitar vacaciones [#solicitar-vacaciones]
Desde el formulario de solicitud eliges las **fechas**, añades un comentario si hace falta y envías la petición.
### Seguimiento del estado [#seguimiento-del-estado]
Una vez enviada, su estado se actualiza solo en tu perfil: **pendiente, aprobada o rechazada**, sin preguntar a Recursos Humanos.
Para el detalle de la solicitud, consulta la guía de Vacaciones y ausencias.
→ [Vacaciones y ausencias](/docs/rtg/recursos-humanos/vacaciones-y-ausencias)
***
## Correspondencias [#correspondencias]
En **Correspondencias** recibes las **comunicaciones formales** que la empresa te dirige: avisos de Recursos Humanos, solicitudes de documentación, mensajes internos y cualquier notificación relevante para tu relación laboral. Queda todo registrado en tu buzón interno.
→ [Correspondencias](/docs/rtg/recursos-humanos/correspondencias)
***
## Tus archivos [#tus-archivos]
El Área de Empleado incluye un espacio de documentos organizado por ámbito, para que cada archivo esté donde toca.
| Carpeta | Qué contiene | Quién la ve |
| ------------------- | ----------------------------------------------------------------- | ------------------ |
| **Mis archivos** | Tus documentos personales | Solo tú |
| **Compartidos** | Documentos que la empresa pone a disposición de toda la plantilla | Toda la empresa |
| **Departamento** | Archivos de tu departamento | Tu departamento |
| **Subdepartamento** | Archivos de tu subdepartamento | Tu subdepartamento |
En cada carpeta puedes navegar entre los documentos, abrirlos y subir los tuyos. **Mis archivos** es privado; **Compartidos** te da acceso a lo que la empresa publica para todos; y **Departamento** y **Subdepartamento** aparecen solo si perteneces a uno y agrupan la documentación de tu equipo.
***
## Cumpleaños de compañeros [#cumpleaños-de-compañeros]
Cuando la empresa lo activa, el Área de Empleado muestra los **cumpleaños de tus compañeros**.
***
## Preguntas frecuentes [#preguntas-frecuentes]
## Soluciones listas para empezar [#soluciones-listas-para-empezar]
A la derecha de cada campo hay 4 botones para configurar:
* Obligatorio
* Bloqueado
* Visible en Información Adicional
* Visible
| Servicio | Coste Mensual | Usuarios incluidos (Acumulables) |
|---|---|---|
| Ready to Go Pymes | 90 € | 5 |
| Ready to Go Recursos Humanos | 90 € | 5 |
| Ready to Go CRM | 90 € | 5 |
| Ready to Go Marketing | 90 € | 5 |
| Ready to Go ToDo | 90 € | 5 |
| Ready to Go TPV | Incluido en Pymes | 0 |
| Usuarios Adicionales | 7,99 € + (1,97 € por RTG) | — |
| Almacenes | 150 € por almacén adicional (1 incluido) | — |
| Servicio | Coste Mensual | Claves API Incluidas |
|---|---|---|
| Dinaup Flex | 90 € mes + 1,97 € (por usuario) | 1 |
| Licencia desarrollador Flex. (Permite utilizar las herramientas de desarrollo) | Desde 3.000 € | — |
| Servicio | Pago único |
|---|---|
| Alta de Licencia Personalizada | 6.000 - 10.000 € |
| Sección | 350 € - 890 € |
| Campo | 150 € - 290 € |
| Informe | 150 € - 290 € |
| Documento Dinámico | 150 € - 300 € |
**Pago único** * Alta de licencia 7.000 € * 3 secciones: 1.500 € * 4 informes: 800 € * Pago único: 9.300 €
| Servicio | Coste Mensual | Capa gratuita |
|---|---|---|
| Base de datos (Datos estructurados) | 4 € / GB | 8 GB |
| Archivos (Imágenes, PDF, XLS...) archivos adjuntos al sistema. | 0,25 € / GB | 20 GB |
| vCore API | 90 € / mes | Sin capa gratuita. |
| Servicio | Coste Mensual |
|---|---|
| Gratuito | 0 € - Incluido mediante Tickets, respuesta 24-48 horas. |
| Business (Email y telefónico) | 400 € / mes |
| Partner Support | Consultar con partner |
F, control de flujo) vive en su sección.
```
### Imágenes responsive [#imágenes-responsive]
```html
```
### Iconos en interfaces [#iconos-en-interfaces]
```html
```
## Buenas prácticas [#buenas-prácticas]
***
## Para qué sirve [#para-qué-sirve]
Cada informe responde a una pregunta concreta del día a día. Esa es la forma de usarlos: no los mires por mirar, ábrelos cuando tengas una decisión delante.
| Informe | Pregunta que responde | Decisión que apoya |
| ------------------------------------ | ----------------------------------------------------- | ------------------------------------------------------ |
| **Dashboard** | ¿Cómo va el mes ahora mismo? | Detectar a tiempo si vas por debajo del mes anterior |
| **Pérdidas y Ganancias** | ¿Estoy ganando o perdiendo dinero? | Saber si el negocio es rentable y dónde se va el gasto |
| **Balance** | ¿Qué tengo y qué debo a fecha de hoy? | Conocer tu situación patrimonial |
| **Flujos de caja** | ¿Tendré dinero para pagar dentro de 30, 60 o 90 días? | Anticipar tensiones de tesorería |
| **Análisis por cliente / proveedor** | ¿Quién me paga bien y quién me da problemas? | Priorizar cobros y revisar condiciones |
***
## Dashboard [#dashboard]
El **dashboard** es tu pantalla de inicio: un resumen del estado del negocio, pensado para abrirlo cada mañana. Reúne los indicadores que más importan:
* **Facturación del mes** comparada con el mes anterior, para ver la tendencia.
* **Tesorería**: el saldo disponible en tus [cuentas bancarias](/docs/rtg/pymes/tesoreria/cuentas-bancarias) y cajas.
* **Pendiente de cobro frente a pendiente de pago**, para saber cuánto te deben y cuánto debes.
* **Top 10 de clientes y proveedores**, por volumen.
***
#### Exporta en Excel Ventas, Compras y extractos bancarios [#exporta-en-excel-ventas-compras-y-extractos-bancarios]
## Recursos Humanos [#recursos-humanos]
## Área de Empleados [#área-de-empleados]
***
***
El empleado puede ver sus vacaciones y estado
***
Desde el portal de empleado puede editar sus fichajes
***
La edición de fichaje deja un registro para poder auditar los cambios
# Documentos oficiales (/docs/rtg/pymes/documentos-oficiales) Los **documentos oficiales** son los libros, registros y archivos que tu empresa debe presentar o conservar: libros registro de IVA, su clasificación por tipo de operación, balances, escrituras y cualquier documento clave. Dinaup los genera a partir de los datos que ya tienes (facturas, asientos, movimientos) y te da un sitio único donde guardar el resto. **No rellenas nada dos veces**: si emites facturas y registras gastos, los libros se construyen solos a partir de esas operaciones. *** ## Qué cubre Dinaup [#qué-cubre-dinaup] Dinaup parte de tus datos del día a día y los organiza en los registros que la normativa española espera. A grandes rasgos, distingues entre lo que **se genera solo** y lo que **conservas tú**. | Tipo | Qué es | De dónde sale | | ----------------------------- | ---------------------------------------------------------------------------------------------------------------- | ---------------------------------- | | **Libros registro de venta** | Facturas emitidas agrupadas por tipo de operación (nacionales, simplificadas, intracomunitarias, exportaciones…) | Tus facturas de venta | | **Libros registro de compra** | Facturas recibidas agrupadas por origen (nacionales, intracomunitarias, importaciones) | Tus facturas de proveedor y gastos | | **Documentos conservados** | Balances, escrituras, declaraciones ya presentadas, contratos y cualquier archivo oficial | Los subes y archivas tú |
Los **libros registro de compra** en Dinaup permiten organizar las facturas recibidas según el origen y tipo de operación: compras nacionales, intracomunitarias o importaciones desde fuera de la UE.
Cada factura de proveedor se clasifica sola en un libro según el **tipo de compra** elegido. Esa clasificación alimenta el control fiscal, la deducción del IVA soportado y la preparación de informes.
Estos libros agrupan las operaciones según su tratamiento contable y fiscal, lo que facilita auditorías internas y exportaciones periódicas.
***
## Para qué sirve [#para-qué-sirve]
La estructura de departamentos no es solo un organigrama bonito: condiciona cómo funciona el día a día en RRHH. Tres usos concretos:
* **Organizar la plantilla.** Cada empleado vive dentro de un departamento, así que sabes quién pertenece a qué área. Los listados, fichajes y planificadores se pueden agrupar y filtrar por departamento.
* **Gestionar permisos por área.** La jerarquía es la base para decidir quién ve y gestiona a quién. Un responsable de área accede a la información de su departamento; RRHH accede a toda la plantilla.
* **Segmentar el análisis.** Al consultar productividad, ausencias o nóminas, puedes acotar por departamento y comparar áreas entre sí, en lugar de mirar la empresa como un único bloque.
***
## La jerarquía: sede, departamento, equipo [#la-jerarquía-sede-departamento-equipo]
La estructura se lee de arriba abajo, de la unidad más amplia a la más pequeña:
| Nivel | Qué representa | Ejemplo |
| ---------------- | ----------------------------------------- | ------------------------------- |
| **Sede** | El centro de trabajo o ubicación física | Oficina central, Tienda Madrid |
| **Departamento** | El área funcional dentro de la sede | Ventas, Administración, Almacén |
| **Equipo** | El grupo concreto dentro del departamento | Ventas Norte, Soporte N1 |
No estás obligado a usar los tres niveles. Una empresa pequeña puede tener solo un par de departamentos colgando de una sede; una grande puede anidar varios niveles hasta llegar al equipo. Crea solo la profundidad que de verdad necesitas para ordenar a tu gente.
En Dinaup, los **empleados** se gestionan como usuarios del sistema. Esto permite asignarles permisos, horarios, fichajes y otras funcionalidades clave dentro del área de Recursos Humanos.\
Cada empleado debe tener su propio **usuario con email personal y válido**, lo que garantiza que pueda identificarse correctamente y recibir notificaciones o acceder a sus datos cuando lo necesite.
## ¿Por qué debo crear un usuario? [#por-qué-debo-crear-un-usuario]
Aunque un empleado no utilice Dinaup activamente al principio, es importante que **pueda acceder con su cuenta personal cuando sea necesario**.
La legislación española sobre control horario obliga a que cada empleado pueda:
* Consultar sus propios fichajes
* Descargar sus registros de jornada
* Justificar y editar fichajes incorrectos (si la empresa lo permite)
Para cumplir con esta normativa, **es imprescindible que el empleado tenga acceso al sistema mediante su propio inicio de sesión**.
## ¿Qué diferencia hay entre un usuario y un empleado? [#qué-diferencia-hay-entre-un-usuario-y-un-empleado]
En Dinaup, **todos los empleados son usuarios**, pero no todos los usuarios son empleados.\
Por ejemplo, un asesor externo o un responsable de área puede tener acceso al sistema sin ser parte del equipo de Recursos Humanos como empleado gestionado.
# Exportar horas (/docs/rtg/recursos-humanos/exportar)
La pantalla de **Exportar** genera el desglose de horas de un empleado en un periodo concreto. Vive en **Recursos Humanos → Rendimiento → Exportar**.
# Motivos de ausencia (/docs/rtg/recursos-humanos/motivos-de-ausencia)
Un **motivo de ausencia** es la categoría que explica por qué un empleado no trabaja: vacaciones, baja médica, asuntos propios, permiso retribuido, formación... Cada motivo no es solo una etiqueta: define **cómo se comporta** esa ausencia en Dinaup, es decir, si descuenta del saldo de vacaciones, si es retribuida y cómo se refleja en la nómina.
Clasificar bien las ausencias te da un control claro de la asistencia y hace que los saldos y las nóminas salgan solos, sin ajustes a mano.
El **registro de eventos legales** centraliza todas las acciones con impacto legal realizadas dentro de Recursos Humanos. Aquí se muestran, de forma ordenada y trazable:
* **Ediciones de fichajes**, incluyendo modificaciones manuales y ajustes de horario.
* **Eventos de correspondencias**, como su creación, apertura y lecturas verificadas.
Cada evento guarda automáticamente:
* **IP de origen**
* **User-Agent del dispositivo**
* **Huella/fingerprint del navegador**
* **Fecha y hora exacta del evento**
* **Referencia única generada por el sistema**
# Turnos sin fichar (/docs/rtg/recursos-humanos/turnos-sin-fichar)
La pantalla de **Turnos sin fichar** reúne los turnos que constan como **ausencia**: días en los que el empleado tenía turno pero no hay actividad fichada. Es la vista a la que vienes para revisar esas ausencias y ponerles un motivo.
Vive en **Recursos Humanos → Día a día → Turnos sin fichar**.
***
## Qué ves [#qué-ves]
La pantalla se divide en dos pestañas:
| Pestaña | Qué lista |
| -------------- | ---------------------------------------------------------------- |
| **Pendientes** | Los turnos en ausencia que **no tienen motivo** asignado todavía |
| **Todas** | Todos los turnos en ausencia, tengan motivo o no |
Cada pestaña es una tabla con los turnos marcados como ausencia. Un aviso en la parte superior recuerda que se consideran **pendientes** las ausencias que no tienen un motivo asociado.
***
## Qué puedes hacer [#qué-puedes-hacer]
* **Revisar** los turnos en ausencia, empezando por los pendientes.
* **Abrir** un turno desde su fila para asignarle un motivo.
* **Filtrar y ordenar** con la barra de herramientas de cada tabla.
Al asignar un motivo a un turno pendiente, deja de figurar en **Pendientes**.
***
## Turno frente a horario y jornada [#turno-frente-a-horario-y-jornada]
Es la distinción que más ayuda a entender el módulo. Son tres conceptos encadenados: la jornada define las horas, el horario las organiza en una semana, y el turno las pone en un día concreto para una persona.
| | [Jornada](/docs/rtg/recursos-humanos/horarios/jornadas) | [Horario](/docs/rtg/recursos-humanos/horarios) | Turno |
| --------------- | ------------------------------------------------------- | -------------------------------------------------------- | ----------------------------------------------------------- |
| Qué es | La plantilla de horas (entrada, descanso, salida) | El conjunto de jornadas repartidas por días de la semana | La asignación real de un horario a un empleado en una fecha |
| Responde a | ¿Cuántas horas y cuándo? | ¿Qué días se trabaja qué jornada? | ¿Quién trabaja este día y con qué horario? |
| Es reutilizable | Sí, la usan muchos horarios | Sí, lo comparten varios empleados | No, es de un empleado y una fecha |
| Dónde vive | Configuración | Configuración | El planificador |
@ aparece el buscador con esos miembros. Si alguien no sale, añádelo antes al equipo del proyecto.
@, recibe una notificación inmediata avisándole de que se le requiere en esa tarea.
@ en un comentario, igual que a un compañero, y le pides lo que necesites: resumir el hilo, decirte qué queda pendiente, proponer subtareas o buscar tareas similares ya cerradas.
***
## Qué es un proyecto [#qué-es-un-proyecto]
Un **proyecto** es el contenedor donde agrupas el trabajo de un área, un cliente o un equipo. Cada proyecto tiene:
* **Título**: el nombre con el que lo identificas.
* **Icono y color**: la pista visual para reconocerlo entre los demás.
* **Clave**: un prefijo corto (por ejemplo, `MKT-`) que antecede al identificador de cada tarea, de forma que las tareas quedan numeradas y rastreables (`MKT-042`).
* **Miembros**: las personas con acceso, ya sean compañeros internos o colaboradores externos, cada una con sus permisos.
* **Flujo**: el recorrido de estados y tipos de tarea que siguen los trabajos de ese proyecto, desde que nacen hasta que se cierran.
Dentro de un proyecto creas **tareas**, las mueves entre estados, las asignas, registras el tiempo que inviertes y comentas con tu equipo. Todo queda centralizado en la ficha del proyecto.
***
## La tarea, sin abrirla [#la-tarea-sin-abrirla]
Buena parte del trabajo diario se resuelve desde la propia tarjeta, sin entrar en la ficha completa:
* **Asignación rápida**: busca un usuario y cambia el responsable.
* **Progreso**: fija el avance (1 %, 25 %, 50 %, 75 % o completada); el tablero se refresca al momento.
* **Prioridad y vencimiento**: desde el menú contextual, con plantillas de fecha (hoy, mañana, próximo lunes, mes próximo…).
Referencia completa de campos y dependencias en → [Tareas](/docs/rtg/proyectos/tareas) y → [Vistas](/docs/rtg/proyectos/vistas).
***
## Registrar el tiempo [#registrar-el-tiempo]
Proyectos controla el tiempo dedicado a cada tarea para planificar mejor y conocer el coste real del trabajo.
* Arrancas una actividad desde la tarea; Dinaup la relaciona con el proyecto y la tarea.
* El **cronómetro** sigue activo aunque cambies de aplicación (TPV, Pymes, RRHH…).
* Cada tarea muestra el tiempo total invertido sin abrirla; el cronómetro suma solo tus propias actividades.
***
## Colaborar dentro de la tarea [#colaborar-dentro-de-la-tarea]
Cada tarea tiene un hilo para comentar, mencionar compañeros y compartir archivos sin salir de Dinaup. Cada cambio queda registrado en su línea de tiempo.
→ [Comentarios, menciones y adjuntos](/docs/rtg/proyectos/colaboracion)
***
## Conectado con el resto de Dinaup [#conectado-con-el-resto-de-dinaup]
Las tareas se vinculan con lo que ya gestionas en otros módulos:
| Módulo | Cómo se conecta |
| --------- | ------------------------------------------------------------------------------------------------------------ |
| **Pymes** | Vincula tareas con presupuestos, pedidos y ventas; el trabajo registrado puede reflejarse en la facturación. |
| **CRM** | Las oportunidades pueden generar tareas asociadas, y el avance de las tareas acompaña al proceso comercial. |
| **RRHH** | Las tareas asignadas a una persona y el tiempo registrado quedan ligados a su actividad. |
| **TPV** | El cronómetro sigue activo mientras trabajas en el punto de venta, sin perder el seguimiento. |
***
## Preguntas frecuentes [#preguntas-frecuentes]
MKT-042). Sirve para numerar y referenciar tareas de forma única, de modo que puedas citarlas en comentarios, emails o documentos y todo el equipo sepa de cuál hablas.
MKT-) con un número correlativo. No la escribes tú y siempre es única dentro del proyecto.
@* Aquí pintas las filas a tu manera, leyéndolas del CascadingValue *@
### Conceptos Fundamentales [#conceptos-fundamentales] #### 1. Espacios de Nombres (Namespaces) [#1-espacios-de-nombres-namespaces] DinaScript organiza sus funciones en **espacios de nombres** que agrupan funcionalidades relacionadas: * **`F.`** - [Funciones generales](/docs/desarrollo/flex/dinascript/funciones) (manipulación de datos, fechas, texto, etc.) * **`S.`** - [Sistema](/docs/desarrollo/flex/dinascript/s.-espacio-de-nombre-schema) (acceso a metadatos y configuración de Dinaup) * **`C.`** - [Registro del formulario](/docs/desarrollo/flex/dinascript/c.-registro-del-formulario) (leer y escribir el registro abierto, en scripts de formulario) * **`I.`** - [Iterador](/docs/desarrollo/flex/dinascript/i.-d.-a.-otros-espacios-de-nombre) (datos del registro actual en procesamiento) * **`D.`** - [Datos globales del sistema](/docs/desarrollo/flex/dinascript/i.-d.-a.-otros-espacios-de-nombre) * **`V.`** - Variables locales o globales del script * **`A.`** - [Opciones avanzadas de algoritmos](/docs/desarrollo/flex/dinascript/i.-d.-a.-otros-espacios-de-nombre) ## Sintaxis de DinaScript [#sintaxis-de-dinascript] ### Declaración de Variables [#declaración-de-variables] #### Tipos de Variables (Solo 2 tipos) [#tipos-de-variables-solo-2-tipos] ```javascript // TEXTO (txt) - Para todo tipo de cadenas, fechas, booleanos, GUIDs txt nombre = "Juan" txt apellido = 'García' txt vacio = "" txt fecha = "2024-12-25" // Fechas como texto txt guid = "550e8400-e29b-41d4-a716-446655440000" // NÚMERO (num) - Para enteros y decimales num entero = 42 num decimal = 3.14159 num negativo = -10 num cero = 0 num booleano = 1 // 1 = true, 0 = false ``` #### Variables del Sistema [#variables-del-sistema] ```javascript // v. = Variables locales (las que tú creas) txt miTexto = "Hola" num miNumero = 100 // I. = Iterador (datos del registro actual en un bucle) txt clienteNombre = I.Clientes.Nombre num clienteSaldo = I.Clientes.Saldo ``` ### Operadores [#operadores] #### Operadores Aritméticos [#operadores-aritméticos] ```javascript num suma = 10 + 5 // 15 num resta = 10 - 5 // 5 num multiplicacion = 10 * 5 // 50 num division = 10 / 5 // 2 num modulo = 10 % 3 // 1 (resto) // Operaciones combinadas num resultado = (10 + 5) * 2 - 3 // 27 ``` #### Operadores de Comparación [#operadores-de-comparación] ```javascript // Igual if v.edad = 18 // Igual a if v.nombre == "Juan" // También funciona // Diferente if v.edad <> 18 // Diferente de if v.nombre != "Juan" // También funciona // Mayor y menor (solo con números) if v.edad > 18 // Mayor que if v.edad >= 18 // Mayor o igual que if v.edad < 18 // Menor que if v.edad <= 18 // Menor o igual que // Comparación de texto if v.estado = "activo" if v.estado <> "" // No vacío ``` #### Operadores Lógicos [#operadores-lógicos] ```javascript // AND - Todas las condiciones deben ser verdaderas if v.edad >= 18 and v.tieneLicencia = 1 F.Write("Puede conducir") end if // OR - Al menos una condición debe ser verdadera if v.dia = "sábado" or v.dia = "domingo" F.Write("Es fin de semana") end if ``` ### Estructuras de Control [#estructuras-de-control] #### IF Simple [#if-simple] ```javascript if v.temperatura > 30 F.Write("Hace calor") end if ``` #### IF-ELSE [#if-else] ```javascript if v.edad >= 18 F.Write("Mayor de edad") else F.Write("Menor de edad") end if ``` #### IF-ELSEIF-ELSE [#if-elseif-else] ```javascript if v.nota >= 9 F.Write("Sobresaliente") elseif v.nota >= 7 F.Write("Notable") elseif v.nota >= 5 F.Write("Aprobado") else F.Write("Suspenso") end if ``` #### IF Anidados [#if-anidados] ```javascript txt tipoPlan = "premium" num esMiembro = 1 if v.esMiembro = 1 if v.tipoPlan = "premium" F.Write("Acceso completo") elseif v.tipoPlan = "basico" F.Write("Acceso limitado") else F.Write("Plan no válido") end if else F.Write("No es miembro") end if ``` ### Bucles y Procesamiento [#bucles-y-procesamiento] #### ProcessDataList (bucle sobre registros) [#processdatalist-bucle-sobre-registros] ```javascript F.DataListLoad(S.Sections.Productos.ID, 1, 999999) F.DataListLoadAddFilter(S.Sections.Productos.ID, S.Fields.Productos.Activo.ID, '=', 1) num totalProductos = 0 num productosConBajoStock = 0 F.ProcessDataList_Ini(S.Sections.Productos.ID) v.totalProductos = v.totalProductos + 1 // Verificar stock if I.Productos.Stock < 10 and I.Productos.Importante = 1 F.Write(F.Concat("ALERTA: ", I.Productos.Nombre, " bajo stock")) v.productosConBajoStock = v.productosConBajoStock + 1 elseif I.Productos.Stock = 0 F.Write(F.Concat("SIN STOCK: ", I.Productos.Nombre)) end if F.ProcessDataList_End ``` ### Trabajar con texto [#trabajar-con-texto] #### Concatenación [#concatenación] ```javascript // Usando F.Concat txt nombre = "Juan" txt apellido = "García" txt mensaje = F.Concat("Hola ", v.nombre, " ", v.apellido) // Concatenación múltiple txt calle = "Gran Vía" txt numero = "123" txt ciudad = "Madrid" txt codigoPostal = "28001" txt direccion = F.Concat4(v.calle, " ", v.numero, ", ", v.ciudad, " ", v.codigoPostal) // Con condiciones num hora = 14 txt saludo = "" if v.hora < 12 v.saludo = F.Concat("Buenos días, ", v.nombre) elseif v.hora < 20 v.saludo = F.Concat("Buenas tardes, ", v.nombre) else v.saludo = F.Concat("Buenas noches, ", v.nombre) end if ``` #### Comparación de Texto [#comparación-de-texto] ```javascript // Comparación exacta txt nombre = "Juan" if v.nombre = "Juan" F.Write("Es Juan") end if // Verificar si está vacío txt email = "" if v.email = "" F.Write("Email no proporcionado") end if if v.email <> "" F.Write("Email proporcionado") end if // Contiene texto (usando función) txt descripcion = "Tarea urgente para hoy" if F.Contains(v.descripcion, "urgente") F.Write("Tarea prioritaria") end if // Empieza o termina con txt codigo = "ES12345" if F.StartsWith(v.codigo, "ES") F.Write("Código español") end if txt archivo = "documento.pdf" if F.EndsWith(v.archivo, ".pdf") F.Write("Es un PDF") end if ``` ### Trabajar con números [#trabajar-con-números] #### Comparaciones y Rangos [#comparaciones-y-rangos] ```javascript num edad = 25 // Verificar rangos if v.edad >= 0 and v.edad <= 17 F.Write("Menor de edad") elseif v.edad >= 18 and v.edad <= 65 F.Write("Adulto") elseif v.edad > 65 F.Write("Tercera edad") end if // Validar valores num precio = 100 num descuento = 15 num precioFinal = 0 if v.precio > 0 if v.descuento >= 0 and v.descuento <= 100 v.precioFinal = v.precio * (1 - v.descuento/100) else F.Write("Descuento no válido") end if else F.Write("Precio no válido") end if ``` #### Trabajar con booleanos (como números) [#trabajar-con-booleanos-como-números] ```javascript // true = 1, false = 0 num activo = 1 num verificado = 0 num tieneLicencia = 1 // Verificación simple if v.activo = 1 F.Write("Usuario activo") end if // Múltiples verificaciones if v.activo = 1 and v.verificado = 1 F.Write("Usuario activo y verificado") end if // Toggle (cambiar estado) v.activo = 1 - v.activo // Si era 1 pasa a 0, si era 0 pasa a 1 // Contador de condiciones verdaderas num condicionesCumplidas = v.activo + v.verificado + v.tieneLicencia if v.condicionesCumplidas >= 2 F.Write("Al menos 2 condiciones cumplidas") end if ``` ### Trabajar con fechas (como texto) [#trabajar-con-fechas-como-texto] #### Comparación de Fechas [#comparación-de-fechas] ```javascript // Las fechas se manejan como texto o mediante funciones F. txt fechaHoy = F.Cast_DateToText(D.DatosEspeciales.FechaActual) txt fechaVencimiento = "2024-12-31" // Para comparar fechas, usar funciones F. num diasDiferencia = F.DaysDifferenceBetweenDates(D.DatosEspeciales.FechaActual, v.fechaVencimiento) if v.diasDiferencia < 0 F.Write("Vencido") elseif v.diasDiferencia = 0 F.Write("Vence hoy") elseif v.diasDiferencia <= 7 F.Write("Vence esta semana") else F.Write(F.Concat("Vence en ", F.Cast_NumToText(v.diasDiferencia), " días")) end if ``` ### Manejo de Valores Vacíos/Cero [#manejo-de-valores-vacíoscero] #### Verificación de Valores [#verificación-de-valores] ```javascript // Texto vacío txt nombre = "" if v.nombre = "" v.nombre = "Sin nombre" end if // Número cero num cantidad = 0 if v.cantidad = 0 F.Write("Cantidad no especificada") end if // Booleano (como número) num activo = 0 if v.activo = 0 v.activo = 1 // Activar por defecto end if // Verificación múltiple txt valor1 = "" txt valor2 = "algo" num tieneValores = 0 if v.valor1 <> "" or v.valor2 <> "" v.tieneValores = 1 end if ``` ### Patrones Comunes [#patrones-comunes] #### Validación de Formulario [#validación-de-formulario] ```javascript num formularioValido = 1 txt errores = "" txt nombre = "" txt email = "test@test" num edad = 15 if v.nombre = "" v.formularioValido = 0 v.errores = F.Concat(v.errores, "- Nombre requerido\n") end if if v.email = "" or not F.Contains(v.email, "@") v.formularioValido = 0 v.errores = F.Concat(v.errores, "- Email inválido\n") end if if v.edad < 18 or v.edad > 120 v.formularioValido = 0 v.errores = F.Concat(v.errores, "- Edad fuera de rango\n") end if if v.formularioValido = 1 F.Write("Formulario enviado correctamente") else F.Write(F.Concat("Errores encontrados:\n", v.errores)) end if ``` #### Switch-like con IF [#switch-like-con-if] ```javascript txt dia = "lunes" txt tipo = "" if v.dia = "lunes" or v.dia = "martes" or v.dia = "miércoles" or v.dia = "jueves" or v.dia = "viernes" v.tipo = "laborable" elseif v.dia = "sábado" or v.dia = "domingo" v.tipo = "fin de semana" else v.tipo = "día no válido" end if ``` #### Conversión entre Tipos [#conversión-entre-tipos] ```javascript // Número a Texto num cantidad = 42 txt cantidadTexto = F.Cast_NumToText(v.cantidad) // Texto a Número txt precio = "99.99" num precioNum = F.Cast_TextToNum(v.precio) // Booleano como número num estaActivo = 1 txt estadoTexto = "" if v.estaActivo = 1 v.estadoTexto = "Activo" else v.estadoTexto = "Inactivo" end if ``` #### Cálculo con Condiciones [#cálculo-con-condiciones] ```javascript // Sistema de puntos con múltiples criterios num puntoBase = 100 num multiplicador = 1 txt categoria = "oro" num esNuevoCliente = 0 num comprasEsteMes = 5 // Multiplicador por categoría if v.categoria = "bronce" v.multiplicador = 1 elseif v.categoria = "plata" v.multiplicador = 1.5 elseif v.categoria = "oro" v.multiplicador = 2 elseif v.categoria = "platino" v.multiplicador = 3 end if // Bonus adicionales num bonus = 0 if v.esNuevoCliente = 1 v.bonus = v.bonus + 50 end if if v.comprasEsteMes >= 5 v.bonus = v.bonus + 100 elseif v.comprasEsteMes >= 3 v.bonus = v.bonus + 50 end if // Cálculo final num puntosFinales = (v.puntoBase * v.multiplicador) + v.bonus ``` #### Control de Flujo con Flags [#control-de-flujo-con-flags] ```javascript // Usar números como banderas (flags) num continuar = 1 num error = 0 txt mensajeError = "" // Validación paso a paso txt codigoProducto = "PRD123" num stock = 5 num cantidadSolicitada = 10 if v.codigoProducto = "" v.error = 1 v.mensajeError = "Código de producto vacío" v.continuar = 0 end if if v.continuar = 1 and v.stock < v.cantidadSolicitada v.error = 1 v.mensajeError = "Stock insuficiente" v.continuar = 0 end if if v.continuar = 1 F.Write("Pedido procesado correctamente") else F.Write(F.Concat("Error: ", v.mensajeError)) end if ``` ### Notas Importantes sobre Variables [#notas-importantes-sobre-variables] 1. **Solo existen `txt` y `num`** - Todo lo demás se maneja con estas dos 2. **Booleanos son números** - `1` = true, `0` = false 3. **Fechas son texto** - Usar funciones F. para manipularlas 4. **GUIDs son texto** - Se almacenan como cadenas 5. **No hay arrays nativos** - Usar DataTables para colecciones 6. **Variables siempre con prefijo** - `v.` para locales, `I.` para iterador 7. **Conversión explícita** - Usar F.Cast\_\* para convertir entre tipos
# Recetas de scripts (/docs/desarrollo/flex/dinascript/recetas-de-scripts) Cada receta resuelve una necesidad concreta con un script real: son los mismos patrones que ejecutan las secciones del núcleo de Dinaup (Ventas, Tareas de Proyectos, líneas de factura…), adaptados para que los copies y cambies los campos por los tuyos. Los conceptos (eventos, ámbitos, tipos) están en [Scripts y eventos](/docs/desarrollo/flex/scripts); la sintaxis de `C.` en [el registro del formulario](/docs/desarrollo/flex/dinascript/c.-registro-del-formulario). Un detalle que verás repetido: `salir` corta la ejecución del script en ese punto. Es la guarda habitual para salir pronto cuando el script no aplica. ## Rellenar valores por defecto al iniciar un alta [#rellenar-valores-por-defecto-al-iniciar-un-alta] **Evento:** Formulario para agregar iniciado — se dispara al abrir el formulario de un registro nuevo, antes de que el usuario escriba. ```javascript @ La clave definitiva la asigna el servidor al guardar C.Clave = 'DRAFT' F.Field_SetFocus(S.Fields.TareasDeProyectos.Resumen.ID, 0) @ La tarea hereda el tipo inicial definido en el flujo del proyecto C.ReferenciaTipo = F.GetRowById(S.Sections.TiposDeTareaDeProyectos.ID, C.ReferenciaProyecto.ReferenciaFlujo.ReferenciaTipo) @ Y el bono de horas del proyecto, si no trae uno if C.ReferenciaBono = '' C.ReferenciaBono = F.GetRowById(S.Sections.BonosHoras.ID, C.ReferenciaProyecto.ReferenciaBono) C.ImporteBonoPrecioHorasinImpuestos = C.ReferenciaProyecto.ImporteBonoPrecioHorasinImpuestos end if ``` Así arranca una tarea de Proyectos: foco en el campo que toca escribir primero y los campos heredados del proyecto ya puestos. ## Autorrellenar campos al elegir una relación [#autorrellenar-campos-al-elegir-una-relación] **Evento:** Campo cambiado, sobre el campo de relación. Al seleccionar el cliente, la venta copia sus condiciones y calcula el vencimiento. ```javascript txt condicionesDePago = C.ReferenciaCliente.CondicionesPagoVenta num condicionesDePagoDias = C.ReferenciaCliente.PlazoDiasCobroVentas if v.condicionesDePago <> '' C.CondicionesDePago = v.condicionesDePago end if if v.condicionesDePagoDias <> 0 or v.condicionesDePago <> '' C.FechaDeVencimiento = F.Date_AddDays(D.DatosEspeciales.FechaActual, v.condicionesDePagoDias) end if ``` El script lee la ficha del cliente a través de la relación y solo pisa los campos cuando la ficha aporta valor. El [autorrellenado declarativo](/docs/desarrollo/flex/campos#autorrellenado) cubre el caso simple (copiar campo a campo); el script entra cuando hay condiciones o cálculo por medio. ## Derivar campos cuando cambia el estado [#derivar-campos-cuando-cambia-el-estado] **Evento:** Campo cambiado, sobre el campo de estado. El registro mantiene solos sus indicadores y fechas reales. ```javascript if C.ReferenciaEstado.EstadoTarea = S.Enums.tareaestado.enproceso C.EnProceso = 1 ¿C.FechaInicioConfirmado = '' ? C.FechaInicioConfirmado = D.DatosEspeciales.FechaActual else C.EnProceso = 0 end if @ Volver al backlog borra la fecha de inicio real if C.ReferenciaEstado.EstadoTarea = S.Enums.tareaestado.backlog or C.ReferenciaEstado.EstadoTarea = S.Enums.tareaestado.pendiente C.FechaInicioConfirmado = '' end if ¿C.ReferenciaEstado.EstadoTarea = S.Enums.tareaestado.completado ? C.ProgresoPorciento = 100 ``` La comparación no es contra el nombre del estado, sino contra el enum de su ficha: el usuario puede renombrar estados sin romper el script. ## Bloquear el guardado si algo no cuadra [#bloquear-el-guardado-si-algo-no-cuadra] **Evento:** Antes de aceptar. Es el último control antes de que el registro se guarde: si la validación falla, `F.CancelEvent()` lo impide. ```javascript if C.ReferenciaDepartamento <> '' and C.ReferenciaSubdepartamento <> '' if C.ReferenciaSubdepartamento.ReferenciaDepartamentoQuePertenece <> C.ReferenciaDepartamento F.MsgBox('El subdepartamento seleccionado no pertenece al departamento.', 1) F.CancelEvent() end if end if ``` El mensaje dice qué está mal y el guardado no ocurre. El segundo parámetro de `F.MsgBox` es la acción en emulación REST, para cuando el script lo dispara una escritura por API en vez de un usuario; ver [funciones de interacción](/docs/desarrollo/flex/dinascript/funciones/interaccion-y-formulario). ## Pedir confirmación en vez de bloquear [#pedir-confirmación-en-vez-de-bloquear] **Evento:** Antes de aceptar. Cuando la situación es sospechosa pero puede ser legítima, pregunta en lugar de prohibir. ```javascript if C.ImportePrecioMinimoUnidad > 0 and C.ImportePrecioMinimoUnidad > C.ImportePrecioUnidad if F.PromptYesNo('Precio demasiado bajo', 'El precio de venta por unidad es inferior al precio de venta mínimo. ¿Desea continuar?', 1) = 0 F.CancelEvent() end if end if ``` Así protegen las líneas de venta el precio mínimo: vender por debajo se permite, pero nunca sin querer. ## Un botón que crea un registro relacionado [#un-botón-que-crea-un-registro-relacionado] **Evento:** Click, sobre un campo que actúa como botón. Guarda el registro actual y abre el alta del relacionado con los campos clave ya puestos. ```javascript F.Save() if C.ReferenciaTipo.SeLePuedeImputarTiempo = 0 F.MsgBox('No se le puede imputar tiempo al tipo ' + C.ReferenciaTipo.TextoPrincipal, 1) else F.AddElement_Begin(S.Sections.ActividadEnTareasDeProyectos.ID) F.AddElement_SetValue(S.Fields.ActividadEnTareasDeProyectos.ReferenciaTarea.ID, C.ID) F.AddElement_SetValue(S.Fields.ActividadEnTareasDeProyectos.ReferenciaProyecto.ID, C.ReferenciaProyecto) F.AddElement_Commit() end if ``` El `F.Save()` inicial importa: un registro nuevo aún no tiene `C.ID` utilizable hasta que se guarda. Este patrón (guardar, validar, `AddElement_Begin` → `SetValue` → `Commit`) es el botón "Agregar" de media interfaz de Dinaup: tickets desde el proyecto, actividades desde la tarea, asientos desde el cobro. ## Filtrar las opciones de un desplegable [#filtrar-las-opciones-de-un-desplegable] **Evento:** Aplicar filtro desplegable, sobre el campo de relación. Antes de mostrar opciones, el script acota qué registros aparecen. ```javascript F.Field_ListDropdownWarning('Mostrando direcciones activas del cliente seleccionado.', 1) F.Field_DropdownApplyFilter(S.Fields.DireccionesDeEnviosBase.ReferenciaEntidad.ID, '=', C.ReferenciaCliente) F.Field_DropdownApplyFilter(S.Fields.DireccionesDeEnviosBase.Activa.ID, '=', 1) ``` Los filtros se encadenan y pueden depender de otros campos del formulario: aquí las direcciones se filtran por el cliente ya elegido. Es el evento más usado del núcleo: casi todo desplegable filtra por activos, por tipo o por el registro padre. ## Bloquear campos con el motivo a la vista [#bloquear-campos-con-el-motivo-a-la-vista] **Evento:** Tick de recálculo o Recalcular listado. `F.Field_SetLockedWithReason` bloquea o desbloquea según una condición, y el usuario ve el porqué al pasar por el campo. ```javascript txt motivo = 'Únicamente puede seleccionar 1: Recurso o Producto' num bloquearRecurso = 0 num bloquearProducto = 0 ¿C.ReferenciaProducto <> '' ? v.bloquearRecurso = 1 ¿C.ReferenciaRecurso <> '' ? v.bloquearProducto = 1 F.Field_SetLockedWithReason(S.Fields.VentasIngresosLista.ReferenciaProducto.ID, v.motivo, v.bloquearProducto) F.Field_SetLockedWithReason(S.Fields.VentasIngresosLista.ReferenciaRecurso.ID, v.motivo, v.bloquearRecurso) ``` El tercer parámetro activa (`1`) o levanta (`0`) el bloqueo, así que el mismo script sirve para los dos sentidos: se ejecuta en cada tick y el formulario siempre queda coherente. La variante `F.Field_SetRequiredWithReason` hace lo mismo con la obligatoriedad. ## Recalcular un importe mientras se edita [#recalcular-un-importe-mientras-se-edita] **Evento:** Tick de recálculo. Mantiene un campo derivado al día sin esperar al guardado. ```javascript if C.TiempoDeActividad_AutoCalculo = 0 or C.ImporteBonoPrecioHorasinImpuestos = 0 C.ImporteBonoCosteDeTareaACliente = 0 else @ Minutos de actividad a precio/hora del bono C.ImporteBonoCosteDeTareaACliente = F.Round(C.TiempoDeActividad_AutoCalculo * (C.ImporteBonoPrecioHorasinImpuestos / 60), 2) end if ``` Redondea siempre los importes derivados (`F.Round(..., 2)`): el usuario ve el mismo número que se guardará. ## Ofrecer autocompletado en un campo de texto [#ofrecer-autocompletado-en-un-campo-de-texto] **Evento:** Formulario Cargado. Sugiere valores canónicos en un campo de texto libre, sin convertirlo en desplegable cerrado. ```javascript F.Field_TextAddAutoComplete(S.Fields.ActividadesDeEmpresas.Clave.ID, '1 - Actividades sujetas al Impuesto sobre Actividades Económicas') F.Field_TextAddAutoComplete(S.Fields.ActividadesDeEmpresas.Clave.ID, '2 - Actividades sujetas al IAE (Profesionales y Artísticas)') F.Field_TextAddAutoComplete(S.Fields.ActividadesDeEmpresas.Clave.ID, '3 - Arrendadores de Locales de Negocios y garajes') ``` El usuario puede escribir cualquier cosa, pero las opciones esperadas están a un clic. En el núcleo alimenta desde claves de la AEAT hasta tipos de vía de direcciones. *** → [Scripts y eventos](/docs/desarrollo/flex/scripts) → [C.: el registro del formulario](/docs/desarrollo/flex/dinascript/c.-registro-del-formulario) → [Funciones (F.)](/docs/desarrollo/flex/dinascript/funciones) → [Buenas prácticas de DinaScript](/docs/desarrollo/flex/dinascript/buenas-practicas) # Espacio de Nombres (S.) (/docs/desarrollo/flex/dinascript/s.-espacio-de-nombre-schema) El espacio **`S.`** (Sistema) es la puerta de acceso al **esquema** de [Dinaup Flex](/docs/desarrollo/flex) desde [DinaScript](/docs/desarrollo/flex/dinascript). Con él consultas la estructura y configuración de tu sistema (secciones, campos, relaciones, algoritmos, informes) **durante la ejecución** de algoritmos, scripts y documentos dinámicos. La idea clave: en vez de escribir a mano el identificador de un campo o una sección, lo referencias por su nombre. Así tu código no depende de identificadores internos y sigue funcionando aunque la configuración cambie.
S. es el esquema: te da referencias y propiedades de la configuración (qué secciones y campos existen). I. es el iterador: te da los valores del registro que estás recorriendo en ese momento. Sueles usar S. para preparar la consulta y I. para leer cada resultado.
S. es solo lectura: sirve para consultar el esquema y obtener referencias. Para crear o modificar registros usas las funciones del espacio F.
v. con el nombre que le diste. Por ejemplo, una pregunta llamada FechaInicio se lee como v.FechaInicio. Son las mismas variables v. que usas para tus variables locales.
S.UsuarioSesionActual obtienes el usuario de la sesión actual. Lo usas para personalizar la salida o para dejar constancia de quién lanzó la operación.
S.Fields.Ventas.Cliente.ID. El valor de esa relación en un registro concreto lo lees con el iterador mientras recorres la lista: I.Ventas.Cliente.
2. Pincha sobre `listado` en `Documentos dinámicos`
3. Dale a + Agregar
4. Elige la plantilla que quieras, por ejemplo `HTML`.
5. Dale un `Nombre` al documento, una `Categoría` y pincha sobre `Código`
6. Borra todo el contenido que hay dentro y sustitúyelo por un "Hola".
7. Pincha sobre `Variables`.
8. Dale a `Añadir nueva pregunta`.
9. En `Nombre de variable` escribe "tu nombre". El valor se le asignará posteriormente cuando se haga la consulta al documento.
10. Modifica el `Formato` para que sea tipo `Tipo Texto`, como se ve en la captura.
11. Dale a la pestaña del `Código` de nuevo.
12. Sitúate al final de la línea del texto `Hola` que has escrito anteriormente y pincha sobre `Bloque Script`.
13. Ahora dentro del bloque de scripts escribe `F.Write(v.tuNombre)`
14. Dale a ✔ Aceptar para guardar el documento creado.
### Acceder al documento dinámico [#acceder-al-documento-dinámico]
#### A través de Dinaup Desktop [#a-través-de-dinaup-desktop]
Para acceder al documento dinámico en la aplicación de escritorio necesitas ser usuario administrador.
1. Colócate en el panel adecuado donde vas a agregar el acceso al documento y pulsa sobre los 3 puntos de la parte superior y elige `Agregar acceso directo a Documento`.
2. En el desplegable selecciona el documento deseado, por ejemplo el que has creado antes.
3. Abre el documento agregado.
4. Escribe el valor para la variable `tu nombre` y dale a ✔ Aceptar.
#### A través de API [#a-través-de-api]
Para acceder al documento dinámico, primero necesitas conocer la ID del documento y luego consultarlo a través de la API.
# Envío de emails (/docs/desarrollo/flex/documentos-dinamicos/envio-de-emails)
Un [documento dinámico](/docs/desarrollo/flex/documentos-dinamicos) se manda por correo desde su propia vista previa. Los metadatos que declaras con `F.MetaData_Set` llegan ya rellenos a ese correo: remitente, destinatario, asunto, cuerpo y nombre del archivo adjunto.
Todos estos metadatos son **opcionales**: lo que no fijes lo rellena a mano quien envía, en la vista previa. `email_body` incluido — sin él, el correo se envía igual, con el cuerpo en blanco para escribirlo antes de mandarlo.
```
F.MetaData_Set('email_subject','Purchase Order Confirmation')
F.MetaData_Set('email_body','Dear customer, please find attached your invoice.')
F.MetaData_Set('email_to','john.doe@example.com')
F.MetaData_Set('email_to_name','John Doe')
F.MetaData_Set('email_attachment_name','invoice_12345.pdf')
F.MetaData_Set('email_from','pedidos@midominio.com')
F.MetaData_Set('email_from_name','Mi Empresa')
```
***
## Las dos formas de enviar [#las-dos-formas-de-enviar]
La barra del documento tiene dos botones, y no mandan lo mismo:
| Botón | Cuerpo del correo | Adjunto |
| ------------------------------- | ---------------------------- | ------------------- |
| **Enviar por email** | El documento renderizado | Ninguno |
| **Adjuntar y enviar por email** | Lo que digas en `email_body` | El documento en PDF |
`email_body` solo interviene en **Adjuntar y enviar por email**. En el otro botón el documento *es* el correo, así que ese metadato se ignora.
Con email_body
***
## Metadatos disponibles [#metadatos-disponibles]
| Metadato | Qué hace |
| ----------------------- | ----------------------------------------------------------------------------------------------- |
| `email_subject` | Asunto del correo. |
| `email_body` | Cuerpo del correo al adjuntar. Admite HTML, o el ID de otro documento dinámico (ver más abajo). |
| `email_to` | Dirección del destinatario. |
| `email_to_name` | Nombre del destinatario. Sin él, el correo no se puede enviar. |
| `email_from` | Dirección del remitente. Exige dominio verificado. |
| `email_from_name` | Nombre visible del remitente. |
| `email_attachment_name` | Nombre con el que viaja el PDF adjunto. Sustituye al nombre del documento. |
***
## El cuerpo puede ser otra plantilla [#el-cuerpo-puede-ser-otra-plantilla]
`email_body` acepta el **ID de otro documento dinámico**. Cuando lo detecta, Dinaup ejecuta esa plantilla con las mismas variables del documento original y usa su HTML como cuerpo del correo.
```
F.MetaData_Set('email_body','a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d')
```
Con eso separas las dos piezas: la plantilla de impresión viaja como PDF adjunto y la plantilla del correo se diseña aparte, con su propio HTML y los mismos datos del registro.
***
## Remitente y dominio verificado [#remitente-y-dominio-verificado]
Por defecto el correo sale de **Dinaup `
El documento se convierte en PDF y
email_body
se usa como cuerpo del mensaje.
El email
De
Mi Empresa
Para
Ana López
Asunto
Factura F-2026/154
Hola Ana,
te envío la factura para que la revises. Un saludo.
Este texto sale de
email_body
. Sin él, llega en blanco.
PDF
Factura F-2026-154.pdf
El adjunto
Factura F-2026-154.pdf
PDF
FACTURA F-2026/154
31/07/2026
Faro delantero izquierdo
180,00 €
Mano de obra · 2 h
820,00 €
Total
1.210,00 €
El documento, convertido a PDF. Su nombre lo fija
email_attachment_name
.
Te envío la factura para que la revises.
Si hay algo que ajustar o cualquier duda, cuéntamelo sin problema.
¡Quedo atento para avanzar cuando tú quieras!
Un saludo.') F.MetaData_Set('email_to',v.Factura.ReferenciaCliente.IdentificadorAcceso) F.MetaData_Set('email_to_name',v.Factura.ReferenciaCliente.NombrePersonalRazonSocial) F.MetaData_Set('email_attachment_name',F.Concat('Factura ',D.EmpresaActual.TextoPrincipal,' n ',v.Factura.NumeroDeFacturaCompleto,' - ',v.Factura.ReferenciaCliente.NombrePersonalRazonSocial,'.pdf')) ```
Te envío el pedido para que lo revises.
Si hay algo que ajustar o cualquier duda, cuéntamelo sin problema.
¡Quedo atento para avanzar cuando tú quieras!
Un saludo.') F.MetaData_Set('email_to',v.Pedido.ReferenciaCliente.IdentificadorAcceso) F.MetaData_Set('email_to_name',v.Pedido.ReferenciaCliente.NombrePersonalRazonSocial) F.MetaData_Set('email_attachment_name',F.Concat('Pedido ',D.EmpresaActual.TextoPrincipal,' n ',v.Pedido.NumeroDePedido,' - ',v.Pedido.NombreDeCliente,'.pdf')) ```
innerHTML, el iframe lleva sandbox sin allow-scripts, o el PDF se capturó antes de que la página terminara de montarse.
printBackground: true en Puppeteer, o la opción equivalente en tu servicio de render. Es una opción del navegador, no de la plantilla.
sandbox="allow-scripts" sin allow-same-origin— el documento se pinta pero no puede leer la sesión ni las cookies de tu página. Reserva el mismo origen para tus propios documentos dentro de tu propia aplicación.
| Tipo | Base | Cuota IVA | RE % | Cuota RE |
|---|---|---|---|---|
| Tipo | Base | Cuota | ||
| {{ bi.IVAPorciento }}% | {{ euro(bi.BaseImponible) }} | {{ euro(bi.CuotaIVA) }} | {{ bi.REPorciento }} | {{ euro(bi.CuotaRE) }} |
| {{ bi.IVAPorciento }}% | {{ euro(bi.BaseImponible) }} | {{ euro(bi.CuotaIVA) }} |
Los informes sincronizables incluyen, además de las columnas necesarias, las columnas requeridas para la sincronización (por ejemplo `ID`, `Eliminado` o `FechaIA`). No contienen datos relacionados. En términos SQL, corresponden a consultas sencillas del tipo:
```
SELECT a, b, c FROM xx;
```
(sin JOIN, GROUP BY ni subconsultas)
Ejemplo: en un informe sincronizable de ventas, se puede incluir la columna `Ventas > Cliente ID`, pero no se deben incluir niveles adicionales como `Ventas > Cliente ID > Nombre`.
Estos informes son compatibles con [Dinaup PG Sync](/docs/desarrollo/integraciones/dinaup-pg-sync).
### Non-Syncable (No sincronizable) [#non-syncable-no-sincronizable]
Los informes no sincronizables contienen datos complejos, como relaciones, filtros avanzados, agrupaciones, algoritmos o datos indirectos.
Debido a esta complejidad, estos informes no son compatibles con [Dinaup PG Sync](/docs/desarrollo/integraciones/dinaup-pg-sync).
# API REST: Referencia de endpoints (/docs/desarrollo/integraciones/webhook/entrantes)
La API REST de Dinaup lee y escribe tus datos con peticiones HTTP desde cualquier lenguaje. Todos los endpoints se sirven desde `https://webhook.dinaup.com`.
***
## Autenticación [#autenticación]
Toda petición (salvo el ping) lleva un **Token Bearer** en la cabecera HTTP:
```
Authorization: Bearer 
### Atajos rápidos [#atajos-rápidos]
### 2. Asientos contables automáticos [#2-asientos-contables-automáticos]
Genera los asientos contables de forma masiva a partir de esas operaciones.
# Inmovilizados (/docs/rtg/pymes/contabilidad/inmovilizados)
Da de alta cada activo de la empresa, amortízalo y dale de baja cuando llegue el momento, con su control contable y fiscal.
Los **libros registro de venta** en Dinaup permiten agrupar y clasificar las facturas emitidas según su tipo: nacionales, simplificadas, intracomunitarias, exportaciones, etc.\
Cada factura se vincula sola a un libro en función del **tipo de venta** que se utilice. Así organizas la contabilidad, mantienes la trazabilidad y exportas los datos para tus declaraciones de IVA.
## Agregar Factura [#agregar-factura]
Para registrar una factura de exportación, sigue esta guía:
***
*Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
# Libro de Ventas Intracomunitarias (/docs/rtg/pymes/libros-registros-de-venta/libro-de-ventas-intracomunitarias)
En Dinaup, las **ventas intracomunitarias** son, por defecto, **entregas o servicios realizados a clientes de la UE que están dados de alta en el VIES**.
No deben confundirse con:
* Las [**ventas OSS**](/docs/rtg/pymes/procesos/emision-de-facturas/emitir-factura-oss), que aunque se hagan a países de la UE, **siguen un régimen distinto** y se declaran aparte.
* Las **ventas a particulares (B2C)** en la UE, cuando el cliente **no tiene NIF-IVA intracomunitario**. En estos casos, la operación se **registra como nacional**, aplicando el **IVA español**.
## Gestión de Libros [#gestión-de-libros]
Desde la **Aplicación de Pymes**, accede a **Configuración > Ventas / Ingresos > Libros**
Ahí verás el listado de libros existentes. De forma predeterminada, Dinaup ya incluye uno llamado **“Intracomunitarias”**, que sirve como **clasificación para identificar las ventas intracomunitarias**.\
No requiere apenas configuración adicional, ya que su objetivo es agrupar este tipo de operaciones.
## Agregar Factura [#agregar-factura]
Para dar de alta una venta intracomunitaria, sigue esta guía:
***
*Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
# Libro de Ventas Nacionales (/docs/rtg/pymes/libros-registros-de-venta/libro-de-ventas-nacionales)
En Dinaup, las **ventas nacionales** son, por defecto, aquellas realizadas a clientes establecidos en España, ya sea a empresas, profesionales o particulares. Estas operaciones **llevan IVA español**, salvo que estén exentas por algún motivo legal.
No deben confundirse con:
* Las **ventas intracomunitarias**, que están exentas si el cliente está en el VIES.
* Las **ventas OSS**, que aplican a consumidores finales en la UE y siguen un régimen diferente.
## Gestión de Libros [#gestión-de-libros]
Desde la **Aplicación de Pymes**, accede a **Configuración > Ventas / Ingresos > Libros**
Ahí verás el listado de libros existentes. De forma predeterminada, Dinaup ya incluye uno llamado **“Nacionales”**, que sirve como clasificación para identificar las ventas realizadas dentro del territorio nacional.
No requiere apenas configuración adicional, ya que su objetivo es **agrupar estas operaciones por tipo de venta**.
## Agregar Factura [#agregar-factura]
Para registrar una venta nacional, sigue esta guía:
***
*Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
# Libro de Ventas Simplificadas / Tickets (/docs/rtg/pymes/libros-registros-de-venta/libro-de-ventas-simplificadas-tickets)
En Dinaup, las **facturas simplificadas** son aquellas operaciones documentadas sin identificar al cliente, normalmente para **ventas al por menor**, **tickets de TPV** o **servicios sin necesidad de facturación nominativa**. Estas operaciones están **sujetas al IVA correspondiente**, igual que una factura completa.
## Gestión de Libros [#gestión-de-libros]
Desde la **Aplicación de Pymes**, accede a **Configuración > Ventas / Ingresos > Libros**
Ahí verás el listado de libros existentes. De forma predeterminada, Dinaup ya incluye uno llamado **“Simplificadas”**, que sirve para **clasificar este tipo de operaciones** (TPV, tickets, albaranes sin datos de cliente, etc.).
Este libro no requiere apenas configuración. Su función principal es **agrupar las ventas simplificadas** para facilitar su control y exportación.
## Agregar Factura [#agregar-factura]
Para registrar una factura simplificada, sigue esta guía:
***
*Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
# Nóminas (/docs/rtg/pymes/nominas)
Una nómina en Dinaup es un registro con un **empleado**, un **periodo** y una lista de **conceptos** (salario base, pluses, retenciones, cuota patronal). Puedes registrarla a mano o dejar que la IA la lea desde el PDF de tu gestoría. Al guardar, Dinaup calcula los totales y la deja lista para contabilizar.
## Qué encuentras en Pymes → Nóminas [#qué-encuentras-en-pymes--nóminas]
| Pestaña | Qué contiene |
| ---------------------- | --------------------------------------------------------------------------------------- |
| **Nóminas** | El listado de nóminas registradas, con el botón **Nuevo** para el alta manual. |
| **Archivos** | La cola de digitalización: subes los PDF, la IA los analiza y tú los revisas. |
| **Tipos de Conceptos** | El catálogo de conceptos: define cómo calcula y contabiliza cada línea. |
| **Tipos de Nóminas** | Catálogo de tipos de nómina (mensual, paga extra, finiquito). |
| **Estados de Nóminas** | Catálogo de estados para seguir el ciclo de cada nómina (pendiente, tramitada, pagada). |
## Tipo y estado de cada nómina [#tipo-y-estado-de-cada-nómina]
Al registrar una nómina eliges su **tipo** y su **estado** en la cabecera, junto al empleado y el periodo.
El **tipo de nómina** clasifica el recibo. Un catálogo habitual:
| Tipo de nómina | Cuándo se usa |
| ------------------- | ------------------------------------------------ |
| Mensual ordinaria | La nómina de cada mes |
| Paga extraordinaria | Junio y diciembre, cuando no van prorrateadas |
| Finiquito | Liquidación al terminar el contrato |
| Atrasos de convenio | Diferencias de una subida con efecto retroactivo |
El **estado** sigue el ciclo de la nómina. Un catálogo habitual:
| Estado | Qué significa |
| --------- | --------------------------- |
| Pendiente | Registrada, aún sin revisar |
| Tramitada | Revisada y lista para pagar |
| Pagada | Ya abonada al trabajador |
En **Configuración del negocio → RRHH** fijas el **estado inicial**, que la nómina toma sola al crearse, para no elegirlo cada vez.
## Lo que Dinaup calcula en cada nómina [#lo-que-dinaup-calcula-en-cada-nómina]
Al guardar una nómina, el servidor recorre sus conceptos y rellena los totales según el tipo de cada uno:
| Total | Qué suma |
| -------------------------------- | -------------------------------------------------------------------------- |
| **Total devengos** | Todo lo que gana el trabajador |
| **Deducciones del empleado** | Anticipos y otras deducciones que se le restan |
| **Retenciones del empleado** | IRPF y cuota obrera que se retienen e ingresan |
| **Retenciones de empresa** | Cuota patronal y demás costes a cargo de la empresa |
| **Líquido a percibir** | Devengos que afectan al neto, menos deducciones y retenciones del empleado |
| **Coste de empresa** | Devengos más retenciones de empresa: lo que la nómina te cuesta de verdad |
| **Pago en especie** | Los devengos marcados como especie |
| **Pago a TGSS, AEAT y terceros** | Las retenciones agrupadas por su destino de ingreso |
## Digitalización con IA [#digitalización-con-ia]
Sube el PDF de una nómina y la IA extrae el empleado (por su NIF), el periodo y cada concepto con su importe, distinguiendo devengos, retenciones del trabajador y aportaciones de la empresa. Tú revisas el resultado con el PDF al lado y guardas. El coste por documento se muestra antes de analizar.
## Contabilidad [#contabilidad]
Cada tipo de concepto lleva su **Cuenta Debe** y su **Cuenta Haber**: cada línea de la nómina anota contra ellas. Desde **Contabilidad automática** generas en bloque los asientos de las nóminas del periodo que aún no lo tienen, y cada nómina queda enlazada a su asiento. Si el empleado tiene sus subcuentas configuradas (640, 460, 465), el asiento usa la subcuenta del trabajador.
## Configuración a nivel de empresa [#configuración-a-nivel-de-empresa]
En **Configuración del negocio → RRHH** defines los ajustes generales del ciclo de nómina:
* **Estado inicial de nóminas** y **estado de nóminas pagadas**: los estados de tu catálogo con los que sigues el ciclo.
* **Instrucciones IA para procesamiento de nóminas**: texto libre que guía a la IA al clasificar los conceptos de tus PDF.
## Quién ve las nóminas [#quién-ve-las-nóminas]
El acceso al módulo se controla por permisos de sección: quien tiene lectura sobre la sección Nóminas ve el listado y la cola de archivos. Concede ese permiso solo a quien lleve la administración de personal.
***
3. Marca el campo `Factura emitida con otro Software (Importada)`.
4. Guarda el registro.
# Procesos (/docs/rtg/pymes/procesos)
Los procesos más habituales en Pymes:
* [Emisión de Facturas](/docs/rtg/pymes/procesos/emision-de-facturas): cómo emitir facturas según el tipo de operación.
* [Exportación](/docs/rtg/pymes/procesos/exportacion): generar y exportar libros y extractos.
* [Contabilidad Automática](/docs/rtg/pymes/procesos/contabilidad-automatica): generar cuentas y asientos contables sin hacerlos a mano.
# Auditoría de reglas y clasificación de movimientos (/docs/rtg/pymes/tesoreria/auditoria-de-reglas-y-clasificacion-de-movimientos)
Dinaup te permite auditar la clasificación bancaria desde la propia ficha de cada cuenta. Podrás revisar qué reglas se han aplicado, detectar movimientos sin clasificar y asegurarte de que todo encaja.
## Qué hace la conciliación [#qué-hace-la-conciliación]
La herramienta de conciliación relaciona los movimientos bancarios con operaciones reales como cobros, pagos, ingresos extraordinarios o devoluciones.
Dinaup analiza tus extractos y busca coincidencias con ventas, compras u otras operaciones. Cuando encuentra una coincidencia, te la muestra como **sugerencia de conciliación**, para que la confirmes, la rechaces o la gestiones a mano.
## Conciliar una cuenta [#conciliar-una-cuenta]
***
### 2. Agrega comentarios explicativos [#2-agrega-comentarios-explicativos]
Puedes dejar comentarios internos en cualquier movimiento bancario para aclaraciones, validaciones o seguimiento en equipo. O para informar a tu asesor.
### 3. Opciones de reglas rápidas [#3-opciones-de-reglas-rápidas]
Desde el menú `⋮` de cada movimiento puedes:
1. **Aplicar mismo concepto**\
Asigna la misma entidad y tipo a todos los movimientos con el mismo texto.
2. **Crear regla general**\
Aplica a todas las cuentas bancarias.
3. **Crear regla para esta cuenta**\
Solo se aplica a la cuenta donde estás trabajando.
### 4. Conciliación manual (avanzada) [#4-conciliación-manual-avanzada]
Si no hay sugerencias o decides rechazar una, puedes pulsar **“Manual”** o **“No”** para abrir la ventana de **conciliación avanzada**.
Desde ahí puedes:
* Etiquetar el movimiento con categoría y entidad.
* Buscar manualmente operaciones existentes.
* Crear una nueva operación (venta, compra, etc.)
* Usar **punteo rápido** si ya sabes que encaja.
# Cuentas bancarias (/docs/rtg/pymes/tesoreria/cuentas-bancarias)
Una **cuenta bancaria** es un depósito monetario que refleja en Dinaup el saldo que tienes en una entidad bancaria. Es el hermano de la [caja de efectivo](/docs/rtg/pymes/tesoreria/cajas): ambos son depósitos de tu tesorería, pero la cuenta guarda saldo en el banco en lugar de billetes y monedas. Cada cuenta está asociada a un [banco](/docs/rtg/pymes/tesoreria/bancos) y se identifica por su **IBAN**.
Sus movimientos son los **cobros**, los **pagos** y los apuntes que llegan en el **extracto** que importas. Y se cuadra de una forma muy concreta: importando ese extracto y [conciliándolo](/docs/rtg/pymes/tesoreria/conciliacion-bancaria) contra tus operaciones.
***
## Cuenta bancaria frente a caja [#cuenta-bancaria-frente-a-caja]
Las dos viven juntas bajo el mismo concepto de depósito, y en cualquier proceso de tesorería eliges una u otra como origen o destino del dinero. La diferencia está en dónde vive ese dinero y en cómo se cuadra.
| | [Cuenta bancaria](/docs/rtg/pymes/tesoreria/cuentas-bancarias) | [Caja (efectivo)](/docs/rtg/pymes/tesoreria/cajas) |
| ------------------ | --------------------------------------------------------------------------------------- | -------------------------------------------------- |
| Qué contiene | Saldo en una entidad bancaria | Dinero físico (billetes y monedas) |
| Identificador | IBAN | Nombre del punto de efectivo |
| Movimientos | Cobros, pagos y apuntes del extracto | Ingresos y salidas que registras tú |
| Cómo se cuadra | Importando el extracto y [conciliando](/docs/rtg/pymes/tesoreria/conciliacion-bancaria) | Contando el dinero en el cierre |
| Vínculo con bancos | Asociada a un [banco](/docs/rtg/pymes/tesoreria/bancos) | Ninguno |
Puedes [crear reglas](/docs/rtg/pymes/tesoreria/reglas-de-movimientos-bancarios) que identifiquen movimientos por nombre o patrones. Por ejemplo, todos los movimientos que incluyan `Microsoft` se pueden asociar automáticamente a esa empresa y al tipo `Factura recibida`.
### ¿Y luego qué? [#y-luego-qué]
Una vez creada, la regla se aplicará automáticamente en el momento de importar el extracto.\
Esto garantiza que los movimientos se clasifiquen correctamente desde el primer momento.
1. Navega hacia `Apps` > `Pymes` > `Configuración` > `Empresa Administradas`
2. Abre tu empresa
3. Navega hacia la pestaña `Compra - Venta`
4. Selecciona el Tipo en `Tipo predeterminado de venta`
1. `Texto principal`: Nombre del producto
2. Medida: Unidades
3. `Evaluar Stock`: En este ejemplo no se evalúa stock porque está pensado para hostelería.
4. En la pestaña `Compra - Venta`: Rellena las categorías de compra y de Venta.
* **Da de alta la caja**
* **Vinculación Cuenta Bancaria.**\
Dentro de la ficha de cada caja encontrarás un campo para asignar una **Cuenta Bancaria**.\
Esto es esencial para que, al cobrar con tarjeta, el dinero se registre correctamente en la cuenta vinculada.
# Jornadas (/docs/rtg/recursos-humanos/horarios/jornadas)
Una **jornada** es la definición de las horas de un **día de trabajo**: a qué hora se entra, cuándo se descansa, a qué hora se sale y cuánto margen de flexibilidad hay. Es la pieza base de RRHH: con jornadas montas los [horarios](/docs/rtg/recursos-humanos/horarios) de tu empresa y asignas los [turnos](/docs/rtg/recursos-humanos/turnos) de cada empleado.
Piensa en la jornada como un **molde de un día**. No es el calendario de la semana ni la planificación de una persona concreta: es la plantilla de horas que luego se reutiliza una y otra vez.
***
## Anatomía de una jornada [#anatomía-de-una-jornada]
Cada jornada se define con cuatro piezas. Juntas describen exactamente cómo es un día de trabajo:
| Pieza | Qué define | Ejemplo |
| ---------------- | ----------------------------------------------------------------- | ------------- |
| **Entrada** | Hora a la que empieza el día | 09:00 |
| **Descanso** | Pausa intermedia (comida, café) que no cuenta como trabajo | 14:00 – 15:00 |
| **Salida** | Hora a la que termina el día | 18:00 |
| **Flexibilidad** | Margen de minutos para entrar o salir sin que cuente como retraso | ±30 min |
Con esas cuatro piezas, Dinaup sabe cuántas **horas efectivas** tiene ese día: el tiempo entre la entrada y la salida, menos el descanso.
Las horas esperadas se crean cada día según el horario asignado al usuario. Si deseas planificar un día futuro, puedes abrir el editor de fichaje y pulsar sobre `Copiar del horario`.
#### Configuración Horas Ordinarias o Extras [#configuración-horas-ordinarias-o-extras]
#### Configuración de Ausencias [#configuración-de-ausencias]
* **Programado**: El horario que estaba previsto, según los turnos asignados. Si el empleado no tenía turno programado o está en modo fichaje flexible, esta fila puede aparecer vacía.
* **Realizado**: El total de tiempo que se le reconoce como trabajado, tras validar los fichajes y aplicar cualquier ajuste necesario.
* **Fichaje**: Los momentos exactos en que el empleado fichó. Son registros técnicos, no editables, que sirven como base para contrastar con lo realizado.
## ¿Cómo editar el turno realizado? [#cómo-editar-el-turno-realizado]
Si necesitas corregir una jornada (por ejemplo, por olvido de fichaje o error en la imputación), puedes hacerlo desde la Línea de Tiempo:
1. Inicia sesión en [play.dinaup.com](https://play.dinaup.com/)
2. Navega hacia *`Recursos Humanos` → `Línea de Tiempo` .*
3. Localiza el **día** y **empleado** que quieres corregir.
4. En la esquina inferior derecha del registro, haz clic en **`“Editar”`**.
5. Ajusta el bloque donde pone **"Trabajado"** para reflejar el tiempo real que debe computarse.
6. Guarda los cambios.
# Motivos de Ausencias (/docs/rtg/recursos-humanos/vacaciones-y-ausencias/motivos-de-ausencias)
Aquí se categorizan las diferentes razones por las cuales un empleado puede ausentarse, como enfermedad, permiso personal o licencia especial. Esta clasificación ayuda a mantener un control detallado sobre la asistencia.
# Badges y estados (/docs/desarrollo/dotnet/dinazen/componentes/badges-y-estados)
Pintas un estado (`Pagado`, `Vencido`, `Pendiente`) y quieres que salga del color que toca sin sentarte a elegir hex ni mantener un diccionario. Le pasas el texto a `DnzBadgetAutoColor` y deduce el color: verde lo bueno, rojo lo malo, cyan lo pendiente. La familia completa la cierran banderas de país, deltas con flecha de tendencia, etiquetas de producto (PRO, Beta, IA) y un punto pulsante para estados en vivo.
Sincronizando
```
**Parametros**
| Parametro | Tipo | Por defecto | Que hace |
| ------------ | ------ | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Horizontal` | `bool` | `false` | `false` pinta el loader vertical centrado en el hueco; `true` usa la variante horizontal compacta (tira de puntos), util en barras o cabeceras estrechas |
***
## DnzSkeleton [#dnzskeleton]
Reserva el hueco con rectangulos animados que imitan la forma del contenido que va a llegar. A diferencia del loader, el usuario ve cuantas lineas y que tamano va a ocupar, asi que la espera se siente mas corta.
```razor
@if (Movimientos.IsNull())
{
El widget fallo: @context.Message
boundary.Recover()) />
`.
### Botones en FooterContent [#botones-en-footercontent]
A la derecha: Guardar (Success, `IsBusy=@isBusy`) y Cerrar (Danger, Text). Al guardar bien, cierras con `DialogService.Close(...)`.
Para confirmar algo destructivo (borrar, dar de baja, desvincular) NO montes un `DnzDialogLayout`. Eso es trabajo de `DnzConfirmDialog.OpenAsync`, que ya trae el icono de alerta, el color según gravedad y los dos botones. Te ahorra el diálogo entero.
***
## DnzDialogLayout [#dnzdialoglayout]
Estructura fija de cualquier diálogo: cabecera arriba, cuerpo con scroll en medio y pie abajo. Tú rellenas los tres `RenderFragment` y el componente pone el grid y el botón de cerrar. Solo el cuerpo hace scroll; cabecera y pie quedan anclados.
```razor
@(ID.IsEmpty() ? "Nueva Retención" : "Editar Retención")
@if (cargando)
{
}
```
Si omites `TitleContent` o `FooterContent`, el layout genera una cabecera automática (con `Title` + `Icon` + botón de cerrar) y un pie con un botón "Cerrar" por defecto. Pero el patrón Dinaup es darle tu propio pie con Guardar + Cancelar.
### Cabecera: automática o a medida [#cabecera-automática-o-a-medida]
Si solo pasas `Title` (y opcionalmente `Icon`), el componente pinta la cabecera por ti con el título, el icono y el botón de cerrar. Si necesitas algo más, usa `TitleContent` y mandas tú.
```razor
@* ... *@
```
```razor
@* ... *@
```
### Convención del pie [#convención-del-pie]
El pie de página de Dinaup siempre sigue el mismo orden: Cancelar a la izquierda en estilo discreto, Aceptar a la derecha y destacado.
| Botón | Estilo | Variante |
| ------------ | --------- | ---------------------------------- |
| **Cancelar** | `Danger` | `Text` (discreto) |
| **Aceptar** | `Success` | sólido + `IsBusy` mientras procesa |
Marca el botón de Aceptar con `IsBusy=@variable` durante la operación: el propio botón muestra el spinner y bloquea el doble clic.
**Parámetros**
| Parámetro | Tipo | Por defecto | Qué hace |
| --------------- | ---------------- | ----------- | ---------------------------------------------------------------------------------- |
| `Title` | `string` | `null` | Texto del título cuando NO pasas `TitleContent`. |
| `Icon` | `string` | `null` | Icono Material Design de la cabecera automática cuando NO pasas `TitleContent`. |
| `TitleContent` | `RenderFragment` | `null` | Cabecera a medida. Si la omites, se genera con `Title` + `Icon` + botón de cerrar. |
| `BodyContent` | `RenderFragment` | `null` | Cuerpo del diálogo (formulario, contenido). Es la única zona con scroll. |
| `FooterContent` | `RenderFragment` | `null` | Pie a medida con los botones. Si lo omites, sale un "Cerrar" por defecto. |
| `ContentStyle` | `string` | `null` | `style` inline para el contenedor del cuerpo (usar con cabeza). |
| `HeaderStyle` | `string` | `null` | `style` inline para la cabecera. |
| `Flat` | `bool` | `false` | `true` deja el diálogo blanco y plano, sin el fondo gris ni los degradados. |
`DnzDialogLayout` expone también `SetWidth(width)` y `SetHeight(height)` por referencia (`@ref`) para ajustar el tamaño del diálogo desde código, y `Cerrar()`, que llama a `DialogService.Close()`. En la mayoría de casos basta con definir el tamaño en las `DialogOptions` al abrir el diálogo.
***
## DnzConfirmDialog [#dnzconfirmdialog]
Diálogo de "¿seguro?" para acciones que no se pueden deshacer. No lo pintas en tu markup: lo abres con el método estático `OpenAsync`, que devuelve `true` si el usuario confirma y `false` si cancela o cierra.
```razor
@code {
async Task EliminarDominioAsync(string dominio)
{
if (await DnzConfirmDialog.OpenAsync(DialogService, $"¿Eliminar el dominio '{dominio}'?", "Eliminar dominio", DnzConfirmSeverity.Danger, "Eliminar") == false) return;
// ... borrar el dominio
NotificationService.Notify(NotificationSeverity.Success, "Dominio eliminado");
}
}
```
El patrón es siempre el mismo: `if (await ...OpenAsync(...) == false) return;` y, si pasa, ejecutas la acción.
**Firma de `OpenAsync`**
```csharp
public static async Task OpenAsync(DialogService dialogService, string message, string title = "Confirmar", DnzConfirmSeverity severity = DnzConfirmSeverity.Warning, string okText = "Confirmar", string cancelText = "Cancelar")
```
Devuelve `Task`: `true` si el usuario pulsa aceptar, `false` si cancela, cierra o pulsa fuera. Solo `dialogService` y `message` son obligatorios; el resto tiene valor por defecto.
| Argumento | Tipo | Por defecto | Qué hace |
| --------------- | -------------------- | ------------- | ------------------------------------------------------------------------------- |
| `dialogService` | `DialogService` | — | El servicio de diálogos de Radzen inyectado. |
| `message` | `string` | — | Texto que explica la consecuencia. Aquí describes qué va a pasar. |
| `title` | `string` | `"Confirmar"` | Título de la cabecera. |
| `severity` | `DnzConfirmSeverity` | `Warning` | Color, icono y estilo del botón de aceptar según gravedad. |
| `okText` | `string` | `"Confirmar"` | Texto del botón de aceptar. Mejor en imperativo: "Eliminar", "Sí, dar de baja". |
| `cancelText` | `string` | `"Cancelar"` | Texto del botón de cancelar. |
### Valores de `DnzConfirmSeverity` [#valores-de-dnzconfirmseverity]
El `severity` cambia el color de acento, el icono y el estilo del botón de aceptar. Elige el que case con la gravedad de la acción.
| Valor | Cuándo usarlo |
| --------- | -------------------------------------------------------------------------- |
| `Info` | Aviso informativo, sin riesgo. |
| `Warning` | Acción que conviene revisar (valor por defecto). |
| `Danger` | Acción destructiva o irreversible (borrar, anular). El botón sale en rojo. |
| `Success` | Confirmación positiva de algo que va a completarse. |
El mensaje es el único parámetro obligatorio de verdad; el resto tiene valores por defecto, pero un `title` y un `okText` claros marcan la diferencia entre un diálogo entendible y un "¿Confirmar? \[Confirmar]" que no dice nada. Para borrados usa siempre `DnzConfirmSeverity.Danger`.
```razor
if (await DnzConfirmDialog.OpenAsync(DialogService, $"¿Eliminar el dominio '{dominio}'?", "Eliminar dominio", DnzConfirmSeverity.Danger, "Eliminar") == false) return;
```
```razor
if (await DnzConfirmDialog.OpenAsync(DialogService, "¿Instalar esta app externa? Tendrá acceso a tus datos.", "Instalar app externa", DnzConfirmSeverity.Warning, "Instalar") == false) return;
```
***
## DnzItemPickerDialog [#dnzitempickerdialog]
Selector de ficha sobre un informe de Dinaup. Abre un diálogo con una tabla buscable y devuelve la fila que elija el usuario, o `null` si cancela. Igual que el de confirmación, se abre con `OpenAsync`.
```razor
@code {
async Task ElegirClienteAsync()
{
var fila = await DnzItemPickerDialog.OpenAsync(DialogService, Client, "clientes");
if (fila == null) return;
// fila es la DinaupDynamicRowDTO seleccionada
var nombre = fila.GetLegible("nombre");
}
}
```
**Firma de `OpenAsync`**
```csharp
public static async Task OpenAsync(DialogService dialogService, DinaupClientC client, string reportId)
```
Devuelve `Task` con la fila seleccionada, o `null` si el usuario cancela o cierra el diálogo. Por dentro monta un `DnzReportView` sobre el informe que le pases y cierra devolviendo la fila al pulsar sobre ella.
| Argumento | Tipo | Por defecto | Qué hace |
| --------------- | --------------- | ----------- | --------------------------------------------------- |
| `dialogService` | `DialogService` | — | El servicio de diálogos de Radzen inyectado. |
| `client` | `DinaupClientC` | — | El cliente Dinaup con el que se ejecuta el informe. |
| `reportId` | `string` | — | Id del informe que alimenta la tabla de selección. |
El diálogo es redimensionable y arrastrable, y muestra hasta 50 filas. El informe (`reportId`) debe existir y devolver las columnas que quieras enseñar; la fila completa vuelve como `DinaupDynamicRowDTO`. Si necesitas el selector embebido en un formulario en vez de un diálogo aparte, mira los [selectores](/docs/desarrollo/dotnet/dinazen/componentes/selectores).
***
## Relacionado [#relacionado]
* [Intro a DinaZen](/docs/desarrollo/dotnet/dinazen): la librería de componentes al completo.
* [Índice de componentes](/docs/desarrollo/dotnet/dinazen/componentes) · [Selectores](/docs/desarrollo/dotnet/dinazen/componentes/selectores) · [Tablas e informes](/docs/desarrollo/dotnet/dinazen/componentes/tablas-e-informes)
* [Cookbook de patrones](/docs/desarrollo/dotnet/dinazen/patrones): recetas de diálogos y otros patrones de UI.
* [Cliente Dinaup](/docs/desarrollo/dotnet/sdk/cliente): el cliente que alimenta el selector de ficha.
* [Informes de Dinaup Flex](/docs/desarrollo/flex/informes): los informes que usa `DnzItemPickerDialog`.
# Componentes (/docs/desarrollo/dotnet/dinazen/componentes)
Aquí tienes **DinaZen** partido en familias. Cada una cubre un tipo de necesidad en pantalla; entra por la que te haga falta, no de arriba abajo.
DinaZen no es un catálogo cerrado de "todo lo que existe": es la **selección de piezas que de verdad usas** al construir una app sobre el [SDK .NET](/docs/desarrollo/dotnet/sdk). Los componentes internos del producto (recursos humanos, terminal, asistente) no se documentan aquí porque no están pensados para integrarse fuera de Play.
***
## Elige por necesidad [#elige-por-necesidad]
| Necesito... | Familia |
| ----------------------------------------------------------------------- | ---------------------------------------------------------------------------------------- |
| Mostrar dinero, fechas, decimales o duraciones con el formato de Dinaup | [Datos tipados (Spans)](/docs/desarrollo/dotnet/dinazen/componentes/datos-tipados) |
| Estructurar la pantalla con cabeceras, tarjetas y bloques | [Tarjetas y layout](/docs/desarrollo/dotnet/dinazen/componentes/tarjetas-y-layout) |
| Señalizar estados con color automático, banderas o deltas | [Badges y estados](/docs/desarrollo/dotnet/dinazen/componentes/badges-y-estados) |
| Montar un dashboard con cifras y comparativas | [KPIs y métricas](/docs/desarrollo/dotnet/dinazen/componentes/kpis-y-metricas) |
| Pintar un informe del SDK como tabla, tarjetas o gráfica | [Tablas e informes](/docs/desarrollo/dotnet/dinazen/componentes/tablas-e-informes) |
| Que el usuario elija un valor, una ficha o un enum | [Selectores](/docs/desarrollo/dotnet/dinazen/componentes/selectores) |
| Indicar carga o aplazar contenido pesado | [Carga y rendimiento](/docs/desarrollo/dotnet/dinazen/componentes/carga-y-rendimiento) |
| Capturar datos: ficheros, texto rico, imágenes, pasos | [Inputs y formularios](/docs/desarrollo/dotnet/dinazen/componentes/inputs-y-formularios) |
| Abrir un diálogo o confirmar una acción destructiva | [Diálogos](/docs/desarrollo/dotnet/dinazen/componentes/dialogos) |
| Gantt, código resaltado o rangos de fechas | [Vistas avanzadas](/docs/desarrollo/dotnet/dinazen/componentes/vistas-avanzadas) |
***
## Cómo leer cada página [#cómo-leer-cada-página]
Cada componente trae **una frase de para qué sirve**, un **ejemplo mínimo copiable** y una **tabla de parámetros** sacada directamente del código fuente, no de la memoria. Si un parámetro no aparece en la tabla, es porque es estado interno del componente y no lo necesitas.
Los ejemplos siguen las convenciones Blazor de Dinaup: expresiones con `@` sin comillas, strings literales con comillas, `nameof` para nombres de propiedad y maquetación con clases Bootstrap. Respétalas y tu app se comporta como Play. Detalle en las [guías de estilo C# y Blazor](/docs/desarrollo/dotnet/c-code-style-guidelines).
→ [Volver a DinaZen](/docs/desarrollo/dotnet/dinazen) · [Cookbook de patrones](/docs/desarrollo/dotnet/dinazen/patrones) · [SDK .NET](/docs/desarrollo/dotnet/sdk) · [Informes](/docs/desarrollo/flex/informes)
# Inputs y formularios (/docs/desarrollo/dotnet/dinazen/componentes/inputs-y-formularios)
Lo que el usuario teclea, pega o sube. Esta familia agrupa los inputs autónomos de DinaZen (una caja de búsqueda, un botón de subida, un editor de etiquetas, un recortador de imagen…). A ellos se suma el sistema de formularios dinámicos de **Flex**, que pinta una ficha completa a partir de un GUID de sección. Recurre a ella cuando montas una pantalla de alta o edición y no quieres pelearte con cada `` a mano.
Casi todos son componentes de **dos vías**: les pasas el dato con `Value` y te avisan del cambio con `ValueChanged`. En Razor eso se escribe con `@bind-Value=@Modelo.Campo`.
Los que suben ficheros (`DnzFileUploaderButton`, `DnzImageEditor`) hablan con un **endpoint de presign** que firma la subida directa a S3. El fichero no viaja por SignalR. Por defecto apuntan a `/file/upload/sign`.
***
## DnzSearchInput [#dnzsearchinput]
Caja de búsqueda con icono de lupa y **debounce de 500 ms**: no dispara en cada tecla, espera a que el usuario pare de escribir. Ideal para filtrar una tabla o una lista sin machacar el servidor.
```razor
` | | Se dispara 500 ms después de la última tecla, con el texto escrito. |
| `Class` | `string` | `""` | Clases CSS del contenedor. |
| `Style` | `string` | `""` | Estilo inline del contenedor. |
Usa `BounceValueChanged`, no `ValueChanged`: la gracia de este componente es que ya trae el debounce hecho. Si enganchas tu recarga ahí, solo se ejecuta cuando el usuario deja de teclear.
Los atributos extra que pongas (por ejemplo `autofocus` o `maxlength`) se pasan tal cual al elemento `` raíz.
***
## DnzFileUploaderButton [#dnzfileuploaderbutton]
Botón que abre el selector nativo, sube los ficheros a S3 (vía presign + Uppy) y te devuelve los `DinaupFileDTO` ya registrados en Dinaup. Si subes una sola imagen, abre antes el editor de imagen.
```razor
ficheros)
{
foreach (var f in ficheros)
Factura.Adjuntos.Add(f);
await InvokeAsync(StateHasChanged);
}
private void OnErrorSubida(string mensaje)
{
NotificationService.Notify(NotificationSeverity.Error, "Subida", mensaje);
}
}
```
**Parámetros**
| Parámetro | Tipo | Por defecto | Qué hace |
| -------------------- | ------------------------------------ | --------------------- | ------------------------------------------------------------------------------------------------- |
| `Client` | `DinaupClientC` | | Cliente que registra el fichero subido (`File_UploadURLAsync`). Necesario en modo por lotes. |
| `PresignEndpoint` | `string` | `"/file/upload/sign"` | Endpoint que firma la subida a S3. |
| `OnFilesUploaded` | `EventCallback>` | | Se dispara cuando termina el lote, con los ficheros ya registrados. |
| `OnEachFileUploaded` | `EventCallback` | | Se dispara por cada fichero subido. Si lo enganchas, tú gestionas el registro y se salta el lote. |
| `AcceptExtensions` | `string[]` | `[]` | Extensiones permitidas (`.pdf`, `.png`...). Vacío = todas. |
| `MaxSizeBytes` | `long` | `157286400` (150 MB) | Tamaño máximo por fichero. |
| `MaxFiles` | `int` | `1000` | Número máximo de ficheros por subida. |
| `Disabled` | `bool` | `false` | Inhabilita el botón. |
| `ButtonText` | `string` | | Texto del botón. |
| `ButtonIcon` | `string` | `"attach_file"` | Icono del botón. |
| `ButtonStyle` | `ButtonStyle` | `Secondary` | Estilo Radzen del botón. |
| `ButtonSize` | `ButtonSize` | `Small` | Tamaño Radzen del botón. |
| `ButtonVariant` | `Variant` | `Outlined` | Variante visual del botón. |
| `UseDashboard` | `bool` | `false` | Abre el dashboard de Uppy (drag\&drop) en vez de un botón simple. |
| `Note` | `string` | | Nota opcional para el dashboard. |
| `EditBeforeUpload` | `bool` | `true` | Si subes 1 imagen, la pasa por el editor antes de subir. |
| `OnError` | `EventCallback` | | Se dispara con el mensaje cuando falla una subida o el registro. |
`Client` es opcional, pero si no lo pasas en modo por lotes, los ficheros suben a S3 sin registrarse en Dinaup. Para registrar manualmente engancha `OnEachFileUploaded` y haz tú la llamada.
***
## DnzFileName [#dnzfilename]
Pinta un fichero **ya subido**: icono según su extensión, nombre, tamaño y un botón de descarga o una acción propia. Es lo que enseñas en una lista de adjuntos; no sube nada.
```razor
@foreach (var adjunto in Factura.Adjuntos)
{
` | | Se dispara al cambiar el contenido. |
| `Context` | `string` | `""` | Contexto que recibe la barra (placeholders/variables disponibles). |
| `EditorStyle` | `string` | `"min-height:300px;"` | Estilo del área de edición (altura mínima, etc.). |
| `UploadUrl` | `string` | `"upload/image"` | Endpoint donde sube las imágenes pegadas/insertadas. |
| `Class` | `string` | `""` | Clases CSS del contenedor. |
| `Style` | `string` | `""` | Estilo inline del contenedor. |
***
## DnzImageEditor [#dnzimageeditor]
Editor de imagen completo embebido: recorte, rotación, volteo, ajustes, mejora automática y herramientas externas (`IDnzImageTool`). Trabaja sobre una URL o sobre `byte[]`. Lo normal es usarlo dentro del diálogo (ver abajo), pero puedes incrustarlo suelto.
```razor
` | | Herramientas extra que se añaden a la barra (p. ej. quitar fondo). |
| `OnSave` | `EventCallback` | | Se dispara al guardar, con los bytes del resultado. |
| `OnCancel` | `EventCallback` | | Se dispara al cancelar. |
| `Style` | `string` | | Estilo inline (sobre todo la altura). |
Para sacar el resultado tienes dos métodos en el `@ref`: `GetResultBytesAsync()` devuelve el `byte[]` del canvas, y `UploadResultToS3Async(endpoint)` lo sube directo a S3 y te da la URL. Úsalos desde el padre o el diálogo.
***
## DnzImageEditorDialog [#dnzimageeditordialog]
El editor de imagen ya envuelto en un diálogo modal con Aceptar/Cerrar. No lo pones en el markup: lo abres con un método estático y te devuelve el resultado. Es la forma recomendada de editar imágenes.
```razor
@code {
private async Task EditarFoto()
{
var bytes = await DnzImageEditorDialog.OpenAsync(DialogService, imageUrl: Producto.FotoUrl);
if (bytes.IsNull()) return; // cancelado
// ...persistir bytes
}
}
```
```razor
@code {
private async Task EditarYSubir()
{
var result = await DnzImageEditorDialog.OpenAndUploadToS3Async(DialogService, "/file/upload/sign", imageUrl: Producto.FotoUrl);
if (result.IsNull()) return; // cancelado
Producto.FotoUrl = result.Url;
}
}
```
**Parámetros**
| Parámetro | Tipo | Por defecto | Qué hace |
| ----------------- | -------- | ----------- | ------------------------------------------------------------------------------------- |
| `ImageUrl` | `string` | | URL de la imagen a editar. |
| `ImageBytes` | `byte[]` | | Imagen en bytes, alternativa a `ImageUrl`. |
| `PresignEndpoint` | `string` | | Endpoint de presign. Si lo pasas, Aceptar sube a S3 y devuelve `PresignUploadResult`. |
**Métodos estáticos**
| Método estático | Devuelve | Para qué |
| ------------------------------------------------------------------ | -------------------------------- | ----------------------------------------------------------------- |
| `OpenAsync(dialogService, imageUrl, imageBytes)` | `byte[]` (o `null` si cancela) | Edita y devuelve los bytes del resultado. |
| `OpenAndUploadToS3Async(dialogService, presignEndpoint, imageUrl)` | `PresignUploadResult` (o `null`) | Edita, sube a S3 y devuelve la URL final. Sin imagen por SignalR. |
***
## DnzTagListEditor [#dnztaglisteditor]
Editor de una lista de etiquetas (`List`). Se escribe y se pulsa Enter para añadir, click en la X para quitar. Admite pegar varias separadas por coma o punto y coma, validación por valor y transformación.
```razor
v.Trim().ToLower()) />
```
**Parámetros**
| Parámetro | Tipo | Por defecto | Qué hace |
| ----------------- | ----------------------------- | --------------- | -------------------------------------------------------------------------------------------- |
| `Value` | `List` | `new()` | La lista de etiquetas. Úsalo con `@bind-Value`. |
| `ValueChanged` | `EventCallback>` | | Se dispara al añadir o quitar una etiqueta. |
| `Title` | `string` | `""` | Título de la cabecera. Vacío = sin cabecera ni botón Clear. |
| `Icon` | `string` | `""` | Icono junto al título. |
| `Placeholder` | `string` | `"Add item..."` | Texto guía del input. |
| `EmptyText` | `string` | `"No items"` | Texto cuando no hay etiquetas. |
| `ReadOnly` | `bool` | `false` | Solo lectura (oculta el input y las X). |
| `Validator` | `Func` | | Devuelve un mensaje de error si el valor no vale, o vacío si vale. |
| `Transform` | `Func` | | Transforma cada valor antes de añadirlo (Trim, ToLower...). |
| `AllowMultiPaste` | `bool` | `true` | Permite pegar varias etiquetas de golpe separadas por coma, `;`, salto de línea o tabulador. |
| `Class` | `string` | `""` | Clases CSS del contenedor. |
| `Style` | `string` | `""` | Estilo inline del contenedor. |
***
## DnzJsonKVEditor [#dnzjsonkveditor]
Editor de pares clave/valor que entra y sale como JSON (`string`). Para metadatos sueltos, configuración de una integración, cabeceras HTTP... Trae copiar, pegar JSON e importar. Usa notación con punto (`app.apikey`) para agrupar visualmente.
```razor
` | | Se dispara al editar, añadir o quitar un par. Devuelve el JSON indentado. |
| `ReadOnly` | `bool` | `false` | Solo lectura. |
| `Class` | `string` | `""` | Clases CSS del contenedor. |
| `Style` | `string` | `""` | Estilo inline del contenedor. |
***
## DnzStepper [#dnzstepper]
Lista vertical de pasos numerados con la línea que los une. Es **presentacional**: muestra un proceso ("cómo empezar", "qué pasa después"), no controla un wizard ni navega. Los pasos van dentro como `DnzStepperStep`.
```razor
Crea la factura
Revisa los importes
Emite y envía
```
**Parámetros**
| Parámetro | Tipo | Por defecto | Qué hace |
| -------------- | ---------------- | ----------- | ------------------------------------------- |
| `ChildContent` | `RenderFragment` | | Los `DnzStepperStep` que componen la lista. |
***
## DnzStepperStep [#dnzstepperstep]
Un paso suelto dentro del `DnzStepper`: el círculo numerado y el contenido al lado.
```razor
Configura el almacén
```
**Parámetros**
| Parámetro | Tipo | Por defecto | Qué hace |
| -------------- | ---------------- | ----------- | -------------------------------------------- |
| `Index` | `int` | `0` | Número que se pinta en el círculo. |
| `ChildContent` | `RenderFragment` | | Contenido del paso (título, descripción...). |
***
## DnzFormView [#dnzformview]
El **formulario dinámico de Flex**. No declaras campos: le pasas el GUID de una sección y el cliente, y pinta la ficha completa (cabecera, pestañas, controles, botones, guardar/cancelar) tal cual está definida en Dinaup. Es lo que usas para dar de alta o editar un registro de cualquier sección sin escribir un solo ``.
```razor
>` | | Callback para formatear códigos contables (subcuenta). |
| `OnClosed` | `EventCallback` | | Se dispara al cerrar el formulario, con el resultado (guardado, cancelado...). |
| `OnAnnotationOpen` | `EventCallback` | | Se dispara al abrir comentarios/archivos/galería. La app host puede personalizar el diálogo. |
| `WindowId` | `string` | | ID de la ventana flotante que lo contiene. Si tiene valor, el form vive dentro de una ventana. |
| `PreFillValues` | `Dictionary` | | Valores a precargar en un alta nueva (clave de campo → valor). Solo si `DatoId` está vacío. |
| `PreFillList` | `List>` | | Filas a precargar en los campos de lista de un alta nueva. Solo si `DatoId` está vacío. |
| `AttachFileId` | `Guid` | | ID de un fichero a adjuntar automáticamente al guardar. |
Los formularios de Flex requieren un **ancho mínimo de 1.000 px**. No hay versión responsive más pequeña: por debajo aparece scroll horizontal. Para pantallas pequeñas, escala el contenedor padre con `zoom` o `transform: scale(...)`.
En vez de incrustarlo en el markup, lo habitual es abrirlo como modal o como ventana flotante con sus helpers estáticos:
```razor
@code {
private async Task EditarCliente(string clienteId)
{
var result = await DnzFormView.OpenAsync(DialogService, Cliente, SeccionClientesId, clienteId);
if (result.Reason == DinaupFormCloseReason.Saved)
RecargarLista();
}
}
```
Firma: `OpenAsync(DialogService dialogService, DinaupClientC client, string sectionId, string datoId = "", string title = "", string width = "1000px", string height = "85%")` → devuelve `Task`.
```razor
@code {
private void AbrirFichaFlotante(string clienteId)
{
DnzFormView.OpenAsWindow(WindowManager, Cliente, SeccionClientesId, clienteId, title: "Cliente");
}
}
```
Firma: `OpenAsWindow(DnzWindowManagerService windowManager, DinaupClientC client, string sectionId, string datoId = "", string title = "", string icon = "")` → devuelve el `windowId` (`string`).
***
## DnzFormTab [#dnzformtab]
Es la **pieza interna** que `DnzFormView` usa para renderizar cada pestaña del formulario: el título, los contenedores, los controles y los botones de esa pestaña. No lo montas tú directamente; lo gestiona `DnzFormView`. Lo listamos para que, si depuras un formulario de Flex, sepas qué estás viendo en el árbol de componentes.
```razor
@* DnzFormView monta esto por cada pestaña; no se usa suelto *@
` | | Se dispara cuando cambia un control de la pestaña. |
| `OnButtonClick` | `EventCallback` | | Se dispara al pulsar un botón de la pestaña. |
| `OnDeleteItemPrimaryList` | `EventCallback` | | Se dispara al borrar un ítem de la lista principal. |
| `OnMostrarDialogRequiereGuardar` | `EventCallback` | | Se dispara cuando una acción exige guardar primero. |
| `OnOpenListItem` | `EventCallback` | | Se dispara al abrir un ítem de una lista. |
| `OnAddItem` | `EventCallback` | | Se dispara al añadir un ítem a una lista. |
| `OnFormatearCodigo` | `Func>` | | Callback para formatear códigos contables. |
***
## Relacionado [#relacionado]
* [Selectores](/docs/desarrollo/dotnet/dinazen/componentes/selectores): elegir opciones (enum, memoria o catálogo remoto), con `DnzSearchInput` por dentro.
* [Tablas e informes](/docs/desarrollo/dotnet/dinazen/componentes/tablas-e-informes): pintar un informe del SDK como tabla, tarjetas o gráfica.
* [Cookbook de patrones](/docs/desarrollo/dotnet/dinazen/patrones): recetas que combinan estos inputs con el SDK.
* [Cliente Dinaup](/docs/desarrollo/dotnet/sdk/cliente): conexión, `WriteOperations` y `File_UploadURLAsync` para persistir lo que capturan estos inputs.
* [Informes de Dinaup Flex](/docs/desarrollo/flex/informes): el origen de datos que rellenan las tablas y los formularios.
→ [Volver a Componentes](/docs/desarrollo/dotnet/dinazen/componentes) · [DinaZen](/docs/desarrollo/dotnet/dinazen) · [SDK .NET](/docs/desarrollo/dotnet/sdk)
# KPIs y métricas (/docs/desarrollo/dotnet/dinazen/componentes/kpis-y-metricas)
Para un cuadro de mando lo que manda es la cifra: número grande, etiqueta corta y, si puedes, una tendencia que diga si va bien o mal. Esta familia te da las piezas para montar ese panel sin pelearte con HTML. La tarjeta destacada la pones con `DnzKpiCard`. Cuando quieres una tira compacta de varios números (cabeceras, pies de ficha) tiras de `DnzKpiInline`. Para agrupar varias tarjetas en rejilla responsive usas `DnzKpiRow`. Para grupos de estadísticas dentro de una card, `DnzStatsDisplay` o `DnzStatItem`. Y para comparar tiempo planificado contra real, `DnzTimeComparisonDisplay`.
## Qué componente uso [#qué-componente-uso]
| Quieres... | Componente |
| ------------------------------------------------------------ | ----------------------------------- |
| Una cifra destacada, con icono, color y tendencia | `DnzKpiCard` |
| Varias tarjetas KPI en rejilla que se adapta sola | `DnzKpiRow` (envuelve `DnzKpiCard`) |
| Una tira horizontal compacta de números (estilo GitHub) | `DnzKpiInline` |
| Un grupo de estadísticas valor + etiqueta dentro de una card | `DnzStatsDisplay` |
| Un stat suelto con icono y contenido libre como valor | `DnzStatItem` |
| Comparar tiempo previsto contra tiempo real (semáforo) | `DnzTimeComparisonDisplay` |
| Resumir totales de un informe Flex automáticamente | `DnzSummaryBar` |
Casi todos reciben la cifra **ya formateada como texto** (`"1.250 €"`, `"42"`). El separador de miles, el símbolo de moneda y los decimales los pones tú antes. La excepción son los deltas (`DeltaPercent`), que entran como `decimal` para que el componente elija color y flecha solo.
Regla rápida: si vas a poner más de una tarjeta, mete los `DnzKpiCard` dentro de un `DnzKpiRow` y olvídate del grid. La rejilla se ajusta al ancho disponible con `MinCardWidth`.
***
## DnzKpiCard [#dnzkpicard]
La tarjeta de un KPI: título, cifra grande, icono opcional, color, badge de comparativa porcentual y mini-gráfico de tendencia. Tiene tres modos según cómo la configures.
Cifra, título, delta y descripción en una card sobria.
```razor
Con `IsCompact=true`, una versión mini de una sola línea, para meter muchas en poco espacio.
```razor
Con `HighlightColor`, la card se pinta entera con un degradado y texto en blanco.
```razor
El delta se colorea solo: positivo en verde, negativo en rojo, cero en gris, con su flecha. Si tu métrica es "cuanto menos mejor" (gastos, tiempos), pon `DeltaInvertColors=true` para que bajar salga en verde.
**Parámetros**
| Parámetro | Tipo | Default | Qué hace |
| ------------------- | -------------------- | ----------- | ---------------------------------------------------------------- |
| `Title` | `string` | `""` | Etiqueta de la cifra. |
| `Value` | `string` | `""` | La cifra en sí, ya formateada. |
| `Icon` | `string` | `""` | Icono Material. Vacío = sin icono. |
| `Color` | `string` | `"black"` | Color del texto y del icono (modo estándar/compacto). |
| `Description` | `string` | `""` | Texto pequeño bajo la cifra (modo estándar). |
| `IsCompact` | `bool` | `false` | Variante compacta de una línea. |
| `HighlightColor` | `HighlightColorType` | `Undefined` | Degradado de fondo. `Auto` deduce verde/rojo según el valor. |
| `DeltaPercent` | `decimal?` | | Porcentaje de cambio. Pinta badge con flecha y signo. |
| `DeltaLabel` | `string` | `""` | Texto junto al delta, ej. "vs mes anterior". |
| `DeltaInvertColors` | `bool` | `false` | Invierte verde/rojo (útil cuando subir es malo, ej. gastos). |
| `TrendContent` | `RenderFragment` | | Contenido libre para un mini-gráfico de tendencia (sparkline). |
| `ButtonText` | `string` | `""` | Si lo rellenas, pinta un botón de acción al pie (modo estándar). |
| `ButtonIcon` | `string` | `""` | Icono de ese botón. |
| `OnClick` | `EventCallback` | | Se dispara al pulsar el botón. |
| `Tooltip` | `string` | `""` | Tooltip al pasar el ratón por la card. |
| `Variant` | `Radzen.Variant` | `Filled` | Variante de la card base (modo estándar/compacto). |
| `Class` | `string` | `""` | Clases CSS extra de la card. |
| `Style` | `string` | `""` | Estilo inline extra de la card. |
`HighlightColorType` admite: `Undefined`, `Auto`, `Red`, `Blue`, `Green`, `Yellow`, `Orange`, `Purple`, `Black`, `White`, `Gray`.
`HighlightColorType.Auto` mira los dígitos del `Value`: si hay un número distinto de cero lo pinta verde, y rojo si además hay un signo menos. Si tu cifra lleva formato raro (separadores, símbolos), mejor fija el color a mano.
***
## DnzKpiRow [#dnzkpirow]
Contenedor en rejilla responsive para tus `DnzKpiCard`. Mete dentro cuantas tarjetas quieras y el grid se reparte solo según el ancho mínimo que le digas. No tienes que tocar el grid: las columnas se ajustan al ancho disponible y bajan de línea cuando no caben.
```razor
```
**Parámetros**
| Parámetro | Tipo | Default | Qué hace |
| -------------- | ---------------- | ------- | ------------------------------------------------------------------- |
| `ChildContent` | `RenderFragment` | | Las tarjetas KPI que van dentro de la rejilla. |
| `MinCardWidth` | `int` | `220` | Ancho mínimo (px) de cada tarjeta. Define cuántas caben por fila. |
| `Class` | `string` | `""` | Clases CSS extra del contenedor. |
| `Style` | `string` | `""` | Estilo inline extra (se concatena con la variable de ancho mínimo). |
***
## DnzKpiInline [#dnzkpiinline]
Tira horizontal compacta de varios números, separados por punto, barra o pipe (estilo GitHub). Ideal para cabeceras de ficha, pies de card o líneas de meta-información. Los items se pasan como lista, no como markup hijo.
```razor
KpiItems = new()
{
new("Horas oficiales", "40h 00m", Icon: "calendar_month"),
new("Realizado", "38h 30m", Icon: "work", ValueColor: "#d97706"),
new("Horas extra", "2h 15m", Icon: "more_time"),
};
}
```
**Parámetros**
| Parámetro | Tipo | Default | Qué hace |
| ----------- | ----------------- | ----------- | ------------------------------------------------------------------------- |
| `Items` | `List` | `new()` | Los números a pintar. Ver `ItemModel` abajo. |
| `Separator` | `SeparatorType` | `MiddleDot` | Separador entre items: `None`, `MiddleDot` (·), `Pipe` (\|), `Slash` (/). |
| `Class` | `string` | `""` | Clases CSS extra del contenedor. |
| `Style` | `string` | `""` | Estilo inline extra del contenedor. |
`ItemModel` es un record con estos campos (todos menos los dos primeros son opcionales): `Label`, `Value`, `Icon`, `ValueColor`, `IconColor`, `Tooltip`. Si `IconColor` va vacío, el icono hereda el color del valor.
***
## DnzStatItem [#dnzstatitem]
Un stat suelto: icono a la izquierda, valor grande y etiqueta debajo. A diferencia de `DnzKpiCard`, el valor es contenido libre (`ChildContent`), así que puedes meter un `DnzSpanMoney`, un badge o lo que necesites.
```razor
1.234
89
```
El `Icon` acepta tanto un nombre de icono Material como una ruta de imagen: si empieza por `/` o `http`, lo pinta como `![]()
`.
**Parámetros**
| Parámetro | Tipo | Default | Qué hace |
| -------------- | ---------------- | --------------------- | ---------------------------------------------------------------- |
| `ChildContent` | `RenderFragment` | | El valor, como contenido libre. Obligatorio. |
| `Label` | `string` | `""` | Etiqueta bajo el valor. |
| `Icon` | `string` | `""` | Icono Material, o una URL (`/...` o `http...`) para imagen. |
| `IconColor` | `string` | `"var(--rz-primary)"` | Color del icono Material. |
| `IconSize` | `string` | `"40px"` | Tamaño del icono (CSS). |
| `ValueColor` | `string` | `""` | Color del valor. Vacío = color del tema. |
| `ValueSize` | `string` | `"fs-3"` | Clase Bootstrap de tamaño del valor (`fs-1`, `fs-3`, `fs-5`...). |
| `Visible` | `bool` | `true` | Si es `false`, no se renderiza nada. |
| `Class` | `string` | `""` | Clases CSS extra del contenedor. |
***
## DnzStatsDisplay [#dnzstatsdisplay]
Grupo de estadísticas valor + etiqueta + unidad dentro de una card, repartidas en horizontal. Le pasas una lista de `StatisticModel` como datos (no como hijos) y él se encarga del layout, pintando una celda por cada métrica.
```razor
@code {
private List stats = new()
{
new() { Value = "12", Label = "Usuarios" },
new() { Value = "45,3", Label = "Base de datos", Unit = "GB" },
new() { Value = "8,1", Label = "Archivos", Unit = "GB" },
};
}
```
**Parámetros**
| Parámetro | Tipo | Default | Qué hace |
| ------------ | ---------------------- | ------- | ----------------------------------------------------------- |
| `Statistics` | `List` | `new()` | Las estadísticas a pintar. Requerido (`EditorRequired`). |
| `Variant` | `Variant` | | Variante de la card base (`Text`, `Filled`, `Outlined`...). |
`StatisticModel` tiene tres campos: `Value` (string), `Label` (string) y `Unit` (string).
### DnzStatsDisplay.Item (subcomponente) [#dnzstatsdisplayitem-subcomponente]
Es la celda que pinta cada cifra individual: valor grande, unidad más pequeña al lado y etiqueta debajo. **No lo usas directamente**: `DnzStatsDisplay` lo instancia por ti, uno por cada elemento de `Statistics`. Lo documentamos para que veas qué recibe cada celda.
Patrón padre/hijo: el padre (`DnzStatsDisplay`) recorre la lista `Statistics` y, por cada métrica, renderiza un hijo (`DnzStatsDisplay.Item`) con `@key=@stat` para que Blazor reutilice bien las celdas. Tú solo tocas el padre y le das la lista; el hijo es detalle interno.
**Parámetros**
| Parámetro | Tipo | Default | Qué hace |
| --------- | -------- | ------- | -------------------------------------------------- |
| `Value` | `string` | `""` | El número grande de la celda. |
| `Label` | `string` | `""` | Etiqueta debajo del valor. |
| `Unit` | `string` | `""` | Unidad pequeña junto al valor. Vacía = sin unidad. |
***
## DnzTimeComparisonDisplay [#dnztimecomparisondisplay]
Compara tiempo planificado contra tiempo real y lo pinta con color de semáforo: verde si vas holgado, amarillo si te acercas al límite, rojo si te pasas. Pensado para tareas, partes de trabajo y presupuestos de horas. Los tiempos entran en **minutos** y se formatean solos a `h`/`m`.
```razor
Con barra de progreso, badge de diferencia e icono de estado. El modo por defecto.
```razor
Con `Compact=true`, todo en una línea para meterlo en una fila de tabla o un pie de card.
```razor
Si no pasas `PlannedTime` (queda en 0), pinta solo el tiempo real sin comparativa ni barra.
```razor
El color y el icono de estado salen solos del porcentaje: verde hasta el 80%, amarillo entre 80% y 100%, rojo al pasarse o si el tiempo real es negativo.
**Parámetros**
| Parámetro | Tipo | Default | Qué hace |
| ----------------- | --------- | ------- | ----------------------------------------------------------------- |
| `PlannedTime` | `decimal` | `0` | Tiempo planificado, en minutos. En `0` desactiva la comparativa. |
| `ActualTime` | `decimal` | `0` | Tiempo real consumido, en minutos. |
| `ShowProgressBar` | `bool` | `true` | Pinta la barra de progreso (solo si hay tiempo planificado). |
| `ShowDiff` | `bool` | `true` | Muestra el badge con la diferencia (`+30m`, `-1h 10m`, `=`). |
| `Compact` | `bool` | `false` | Modo de una sola línea. |
| `Label` | `string` | `""` | Etiqueta encima de la comparativa. También aparece en el tooltip. |
Si tanto `PlannedTime` como `ActualTime` son 0, el componente **no pinta nada**. Es deliberado: una tarea sin tiempo ni estimación no aporta a un panel.
***
## DnzSummaryBar [#dnzsummarybar]
Barra de totales para informes Flex. No le pasas datos a mano: lee el `ReportContext` de la cascada y suma las columnas de dinero, numéricas, minutos, booleanas (cuenta los `true`, ej. `5 / 20`) y el rango de la fecha principal. La pones dentro de un informe y se rellena sola.
```razor
```
**Parámetros**
| Parámetro | Tipo | Default | Qué hace |
| --------- | --------------- | ------- | ------------------------------------------------------------------------------------------------------- |
| `Context` | `ReportContext` | | Llega por `[CascadingParameter]`. No se pasa como atributo: lo aporta el informe que envuelve la barra. |
`DnzSummaryBar` solo aparece si el contexto trae filas. Si el informe está vacío no pinta nada, así que no tienes que esconderlo tú. Más sobre informes en [Informes (Flex)](/docs/desarrollo/flex/informes).
***
## Relacionado [#relacionado]
Ver tambien: [Índice de componentes](/docs/desarrollo/dotnet/dinazen/componentes) · [Intro DinaZen](/docs/desarrollo/dotnet/dinazen) · [Cookbook de patrones](/docs/desarrollo/dotnet/dinazen/patrones) · [Badges y estados](/docs/desarrollo/dotnet/dinazen/componentes/badges-y-estados) · [Tarjetas y layout](/docs/desarrollo/dotnet/dinazen/componentes/tarjetas-y-layout) · [Tablas e informes](/docs/desarrollo/dotnet/dinazen/componentes/tablas-e-informes) · [Informes (Flex)](/docs/desarrollo/flex/informes) · [Cliente Dinaup](/docs/desarrollo/dotnet/sdk/cliente)
# Selectores (/docs/desarrollo/dotnet/dinazen/componentes/selectores)
Casi todo lo que el usuario "elige" en Dinaup pasa por uno de estos componentes. La pregunta de fondo siempre es la misma: ¿de dónde salen las opciones? De ahí cuelga todo lo demás. No fuerces un componente equivocado: cada uno está pensado para un origen de datos distinto y mezclarlos te trae problemas de rendimiento o de UX.
Antes de mirar props, decide cuál te toca con la regla de los 3 segundos.
## Regla de los 3 segundos [#regla-de-los-3-segundos]
| Lo que tienes | Componente | Por qué |
| --------------------------------------------------------------------- | --------------------------------------------- | ------------------------------------------------------------------------ |
| Un `enum` de C# | [`DnzEnumDropDown`](#dnzenumdropdown) | Las opciones SON el enum. Cero datos, cero query. |
| Una lista corta ya cargada en memoria (impuestos, almacenes, estados) | [`DnzDataGridDropDown`](#dnzdatagriddropdown) | Le pasas la colección y filtra en cliente. Sin ir al servidor. |
| Buscar/elegir una ficha de un catálogo grande (clientes, productos) | [`DnzRowSelector`](#dnzrowselector) | No le pasas datos: consulta un informe remoto con búsqueda y paginación. |
Si la lista cabe en memoria sin sudar (decenas, pocos cientos), `DnzDataGridDropDown`. Si es un catálogo que crece sin límite y vive en el servidor, `DnzRowSelector`. El primero te ahorra una consulta; el segundo te evita cargar 10.000 filas en el navegador para elegir una.
Los tres últimos de esta página (`DnzDropDown`, `DnzSearchInput`, `DnzItemPickerDialog`) son piezas de apoyo: el dropdown de datos en su versión cruda, la caja de búsqueda con debounce que monta el selector remoto por dentro, y un picker en diálogo para cuando no quieres un desplegable embebido sino una ventana de selección.
***
## DnzEnumDropDown [#dnzenumdropdown]
Desplegable directo sobre un `enum` de C#. No le pasas opciones: las saca del propio tipo, y usa el `[Display(Name=...)]` de cada valor como texto visible si lo tiene.
```razor
` | | Se dispara al cambiar la selección (lo cablea `@bind-Value`). |
| `Placeholder` | `string` | `""` | Texto cuando no hay nada elegido. |
| `Disabled` | `bool` | `false` | Bloquea el control. |
| `Style` | `string` | `"width:200px"` | Estilo inline del desplegable, normalmente el ancho. |
| `Name` | `string` | `""` | Nombre del campo (para formularios/validación Radzen). |
El texto de cada opción sale de `[Display(Name = "Pendiente de pago")]` sobre el valor del enum. Sin el atributo, se muestra el nombre técnico del miembro. Decóralo en la definición del enum y aquí no tocas nada.
***
## DnzDataGridDropDown [#dnzdatagriddropdown]
Selector para una lista que ya tienes en memoria. Le pasas la colección por `Data`, le dices qué propiedad pintar con `TextProperty`, y él monta un desplegable con buscador, columna y acciones (limpiar, abrir ficha, añadir). El tipo `T` tiene que implementar `IDinaupRow`.
```razor
await Recalcular()) Style="width:100%" />
```
Con color por estado (badge automático) y columnas a medida:
```razor
` | `new List()` | La colección en memoria a elegir. |
| `Value` | `T` | | Fila seleccionada. Úsalo con `@bind-Value`. |
| `ValueChanged` | `EventCallback` | | Se dispara al cambiar la selección. |
| `TextProperty` | `string` | | Nombre de la propiedad a mostrar. **Obligatorio**; usa `@nameof(...)`. |
| `Label` | `string` | | Etiqueta del campo. |
| `ColorProperty` | `string` | | Propiedad con el estilo de color; pinta la opción como badge. |
| `IconoProperty` | `string` | | Propiedad que aporta el icono de cada opción. |
| `IsRequired` | `bool` | `false` | Marca visual de obligatorio si no hay valor. |
| `Disabled` | `bool` | `false` | Bloquea el control. |
| `Width` | `string` | `"280px"` | Ancho del campo. |
| `Style` | `string` | | Estilo inline adicional del campo. |
| `Icon` | `string` | | Icono al inicio del campo. |
| `OpenInWindow` | `bool` | `true` | Permite abrir la ficha del seleccionado en ventana (necesita `Client`). |
| `Client` | `DinaupClientC` | | Cliente para abrir la ficha en ventana. |
| `OnAdd` | `EventCallback` | | Se dispara al pulsar el "+" cuando no hay nada seleccionado. |
| `OnRemove` | `EventCallback` | | Se dispara al limpiar. Si no lo cableas, limpia el valor solo. |
| `OnOpen` | `EventCallback` | | Se dispara al pulsar "abrir ficha". |
| `Columns` | `RenderFragment` | | Columnas custom para el popup (override de la columna por defecto). |
| `ValueTemplate` | `RenderFragment` | | Plantilla del valor seleccionado mostrado en el campo. |
| `IconTemplate` | `RenderFragment` | | Plantilla del icono por fila. |
| `ColumnWidth` | `string` | `""` | Ancho de columna por defecto del desplegable. |
| `Visible` | `bool` | `true` | Oculta el componente entero. |
`TextProperty` es obligatorio. Sin él, el componente pinta un aviso en rojo en vez del desplegable. Pásalo siempre con `@nameof(Tipo.Propiedad)`, nunca como string suelto.
***
## DnzRowSelector [#dnzrowselector]
No le pasas `Data`: le das un `ReportId` (el informe de la sección) y un `Client`, y él busca contra el servidor con paginación. Para catálogos grandes (clientes, productos, proveedores) donde cargar todo en memoria no tiene sentido.
```razor
Si ya tienes la fila (`IDinaupRow`), pásala por `@bind-SelectedRow` y el componente la pinta directa, sin ir al servidor.
```razor
Si solo tienes el `Guid`, usa `DefaultID`: el componente lanza una consulta al informe para resolver la fila y mostrar su etiqueta. Una query de más, úsalo solo cuando no tengas la fila a mano.
```razor
| Parámetro | Tipo | Default | Para qué |
| -------------------- | --------------------------- | ------------ | ------------------------------------------------------------------------------ |
| `Client` | `DinaupClientC` | | Cliente contra el que consulta el informe. **Obligatorio** (`EditorRequired`). |
| `ReportId` | `string` | | GUID del informe (`SeccionD._SectionID`) que alimenta la búsqueda. |
| `SelectedRow` | `IDinaupRow` | | Fila seleccionada. Úsalo con `@bind-SelectedRow`. |
| `SelectedRowChanged` | `EventCallback` | | Se dispara al cambiar la selección. |
| `DefaultID` | `Guid` | `Guid.Empty` | ID inicial a resolver (lanza una consulta al informe). |
| `Label` | `string` | | Etiqueta del campo. |
| `Placeholder` | `string` | | Texto cuando no hay nada elegido. |
| `IsRequired` | `bool` | `false` | Marca visual de obligatorio si está vacío. |
| `Disabled` | `bool` | `false` | Bloquea el control. |
| `AdvancedFilter` | `List` | | Filtro aplicado al informe (acota el universo buscable). |
| `AdminMode` | `bool` | `false` | Consulta el informe en modo admin. |
| `Width` | `string` | `"280px"` | Ancho del campo. |
| `Style` | `string` | `"flex:1"` | Estilo inline del campo. |
| `Class` | `string` | `""` | Clases CSS extra del contenedor. |
| `Icon` | `string` | | Icono al inicio del campo. |
| `KeyboardShortcut` | `string` | | Atajo de teclado asociado al selector. |
| `OpenInWindow` | `bool` | `true` | Permite abrir la ficha seleccionada en ventana. |
| `OnAdd` | `EventCallback` | | Se dispara al pulsar el "+" para crear una ficha nueva. |
| `OnOpenRecord` | `EventCallback` | | Se dispara al pulsar "abrir"; si no lo cableas, abre la ficha en ventana. |
`AdvancedFilter` es tu palanca para acotar: pásale un `List` y el usuario solo busca dentro de ese subconjunto (ej. clientes activos, productos de un almacén). Combínalo con `OnAdd` para que pueda crear sobre la marcha si no encuentra lo que busca.
Además del binding, `DnzRowSelector` expone métodos públicos para preseleccionar desde código: `SelectByIdAsync(Guid id)` resuelve la fila por id contra el informe, y `SelectAsync(...)` acepta una fila (`IDinaupRow`), una `DinaupBasicInformation` o incluso otro `DnzRowSelector` como origen.
***
## DnzDropDown [#dnzdropdown]
La versión cruda del desplegable de datos sobre `IDinaupRow`, sin la capa de overlay de acciones ni resolución de color/icono de `DnzDataGridDropDown`. En la práctica usa `DnzDataGridDropDown`; este queda para casos donde quieras el grid pelado. Igual que aquel, `TextProperty` es obligatorio.
```razor
` | `new List()` | La colección a elegir. |
| `Selected` | `T` | | Fila seleccionada. Úsalo con `@bind-Selected`. |
| `SelectedChanged` | `EventCallback` | | Se dispara al cambiar la selección. |
| `TextProperty` | `string` | | Propiedad a mostrar. **Obligatorio**; usa `@nameof(...)`. |
| `ColorProperty` | `string` | | Propiedad de estilo de color de cada opción. |
| `IconoProperty` | `string` | | Propiedad que aporta el icono de cada opción. |
| `Label` | `string` | | Etiqueta del campo. |
| `Icon` | `string` | | Icono al inicio del campo. |
| `Style` | `string` | | Estilo inline del control. |
| `Class` | `string` | | Clases CSS extra. |
| `Disabled` | `bool` | `false` | Bloquea el control. |
| `Visible` | `bool` | `true` | Oculta el componente entero. |
| `OnAdd` | `EventCallback` | | Se dispara al pulsar el "+". |
| `OnRemove` | `EventCallback` | | Se dispara al limpiar; si no lo cableas, limpia solo. |
| `OnOpen` | `EventCallback` | | Se dispara al pulsar "abrir ficha". |
***
## DnzSearchInput [#dnzsearchinput]
Caja de búsqueda con icono de lupa y debounce de 500 ms. No es un selector: es la pieza que dispara el filtro sin lanzar una consulta por cada tecla. La usa por dentro `DnzRowSelector` para buscar contra el informe, y te sirve para tu propio buscador sobre una lista o un informe.
```razor
` | | Se dispara 500 ms después de que el usuario deja de teclear, con el texto actual. |
| `Value` | `string` | | Texto del campo. |
| `Placeholder` | `string` | `"Buscar..."` | Texto cuando está vacío. |
| `Class` | `string` | `""` | Clases CSS extra para el contenedor. |
| `Style` | `string` | `""` | Estilo inline del contenedor. |
El debounce es de 500 ms y va por dentro con el `Debouncer` de Dinaup. No montes tu propio temporizador encima: engancha tu carga a `BounceValueChanged` y listo.
***
## DnzItemPickerDialog [#dnzitempickerdialog]
Cuando no quieres un desplegable embebido sino abrir una ventana de selección a pantalla completa sobre un informe. Lo lanzas con `OpenAsync` y te devuelve la fila elegida (o `null` si el usuario cierra).
```razor
@inject DialogService DialogService
@code {
async Task ElegirCliente() {
var fila = await DnzItemPickerDialog.OpenAsync(DialogService, SessionPlay, EntidadesD._SectionID);
if (fila.IsNotNull()) clienteSeleccionado = fila;
}
}
```
| Parámetro | Tipo | Default | Para qué |
| ---------- | --------------- | ------- | ---------------------------------------------- |
| `Client` | `DinaupClientC` | | Cliente contra el que consulta el informe. |
| `ReportId` | `string` | | GUID del informe que se muestra en el diálogo. |
El método estático `OpenAsync(DialogService, DinaupClientC, string reportId)` abre el diálogo (800×600, redimensionable y arrastrable) y devuelve un `DinaupDynamicRowDTO` con la fila seleccionada, o `null` si se cancela.
Para elegir una ficha dentro de un formulario, casi siempre prefieres `DnzRowSelector` embebido. Reserva este diálogo para cuando la selección es una acción aparte (un botón "Elegir cliente…" que abre la ventana) y no un campo más del layout.
***
Relacionado: [Introducción a DinaZen](/docs/desarrollo/dotnet/dinazen) · [Índice de componentes](/docs/desarrollo/dotnet/dinazen/componentes) · [Informes (Flex)](/docs/desarrollo/flex/informes) · [Cliente Dinaup](/docs/desarrollo/dotnet/sdk/cliente) · [Guías de estilo C#/Blazor](/docs/desarrollo/dotnet/c-code-style-guidelines)
# Tablas e informes (/docs/desarrollo/dotnet/dinazen/componentes/tablas-e-informes)
Un informe de [Dinaup Flex](/docs/desarrollo/flex/informes) vive en el servidor: tú lo pides por su `ReportId` con el [SDK .NET](/docs/desarrollo/dotnet/sdk) y te devuelve filas tipadas con sus columnas, formatos y totales. Esta familia coge ese resultado y lo pinta (tabla, tarjetas, gráfica o ranking) **con el mismo aspecto que Play** y sin que escribas una sola `RadzenDataGridColumn` a mano.
La decisión es una sola: ¿quieres **una rejilla completa** o **varias vistas del mismo informe a la vez**? Para lo primero, `DnzReportView` directo. Para lo segundo, `DnzReportProvider` como contenedor que carga el informe una vez y lo reparte por cascada a sus hijos.
El `ReportId` es el GUID del informe definido en [Flex / Informes](/docs/desarrollo/flex/informes). Lo mismo que alimenta los listados de Play alimenta estos componentes.
***
## ¿Tabla suelta o dashboard? [#tabla-suelta-o-dashboard]
`DnzReportView` resuelve el caso completo: cabecera, buscador, exportar CSV, paginación server-side y filtros por columna.
```razor
`DnzReportProvider` carga el informe una vez y lo expone como cascada (`ReportContext`). Dentro metes las vistas que quieras, todas leyendo de la misma carga: una llamada al servidor, varias representaciones.
```razor
```
`DnzReportView` con `OnItemSelect` te da la fila pulsada como `DinaupDynamicRowDTO`. Es la base de los selectores relacionales y de los pickers de Play; mira [Selectores](/docs/desarrollo/dotnet/dinazen/componentes/selectores) si tu caso es "elige una ficha".
`DnzReportView` pinta una tabla por sí solo. `DnzReportProvider` **no dibuja nada**: es el grifo de datos para `DnzCardList`, `DnzChartView` y `DnzTopN`. No los mezcles esperando que el Provider muestre una rejilla.
***
## DnzReportView [#dnzreportview]
La tabla completa de Play a partir de un `ReportId`: columnas tipadas, orden multi-columna, filtros avanzados, paginación server-side, exportar CSV y doble clic para abrir la ficha.
```razor
@code {
private async Task AbrirFactura(DinaupDynamicRowDTO fila) {
await DnzFormView.OpenAsync(DialogService, Client, fila.SectionId, fila.ID);
}
}
```
Para embeberlo dentro de otra ficha sin barra de título ni botón de añadir:
```razor
` | — | Valores de las variables del informe; si faltan, se pregunta al usuario antes de pintar. |
| `QuerySearch` | `string` | `""` | Texto de búsqueda inicial. Cambiarlo en caliente recarga el informe. |
| `AdvancedFilter` | `List` | — | Filtro server-side aplicado de entrada, además de los que ponga el usuario. |
| `Limit` | `int` | `50` | Tamaño de página inicial. El usuario puede subirlo (25–3000). |
| `Orden` | `Dictionary` | — | Orden inicial por columna (`true` = ascendente). |
| `ShowTitle` | `bool` | `true` | Muestra la cabecera con icono, título y selector de columnas visibles. |
| `Title` | `string` | `""` | Sobrescribe el título; si está vacío, usa el del informe. |
| `ShowSearch` | `bool` | `true` | Muestra el buscador de la cabecera. |
| `Filtrable` | `bool` | `true` | Habilita los filtros por columna en las cabeceras. |
| `ShowAdd` | `bool` | `true` | Muestra el botón "+" para crear un registro de la sección del informe. |
| `AdminMode` | `bool` | `false` | Carga el informe en modo administrador (sin algunos filtros de visibilidad). |
| `ToolBarTemplate` | `RenderFragment` | — | Contenido extra inyectado en la barra de herramientas de la rejilla. |
| `OnItemSelect` | `EventCallback` | — | Se dispara al seleccionar una fila. Si lo defines, sustituye la apertura automática de la ficha. |
| `OnDataChanged` | `EventCallback` | — | Se dispara cada vez que el informe (re)carga sus datos. |
Las columnas visibles se recuerdan por URL + `ReportId` en `localStorage`, igual que en Play: el usuario ajusta una vez y se mantiene. Las columnas de moneda salen con `DnzSpanMoney` (rojo en negativos) y suma en el pie automáticamente.
### Las columnas se pintan solas [#las-columnas-se-pintan-solas]
No declaras columnas. `DnzReportView` lee el formato de cada campo del informe (`DEC`, `INT`, `DATE`, `BOOL`, texto…) y elige la plantilla adecuada: importes con `DnzSpanMoney` y suma en el pie, fechas en formato local, booleanos como badge Sí/No, estados con color. Tú solo le das el `ReportId`; el informe manda.
Lo único que personalizas por plantilla es la **barra de herramientas**, vía `ToolBarTemplate`:
```razor
```
### Abrirlo sin colocarlo en el markup [#abrirlo-sin-colocarlo-en-el-markup]
`DnzReportView` expone dos métodos estáticos para abrirlo bajo demanda como diálogo o ventana flotante:
```razor
await DnzReportView.OpenAsync(DialogService, Client, "3f2a9c10-8b4e-4d21-9f77-1a2b3c4d5e6f", title: "Facturas");
```
Firma real:
```csharp
public static Task OpenAsync(DialogService ds, DinaupClientC client, string reportId, Dictionary vars = null, string title = "Informe", string width = "90%", string height = "80%")
```
```razor
DnzReportView.OpenAsWindow(WindowManager, Client, "3f2a9c10-8b4e-4d21-9f77-1a2b3c4d5e6f", title: "Facturas", icon: "receipt_long");
```
Firma real:
```csharp
public static string OpenAsWindow(DnzWindowManagerService wm, DinaupClientC client, string reportId, Dictionary vars = null, string title = "Informe", string icon = "analytics")
```
***
## DnzReportProvider [#dnzreportprovider]
Contenedor "headless": carga el informe una vez y lo reparte por cascada a sus hijos vía `ReportContext`. No dibuja tabla; es el grifo de datos para dashboards con varias vistas del mismo informe.
```razor
```
Las vistas hijas van dentro de `ChildContent` (el contenido entre las etiquetas del Provider), así que es un `RenderFragment`: metes el markup que quieras y las vistas leen el contexto por cascada.
**Parámetros**
| Parámetro | Tipo | Por defecto | Qué hace |
| ----------------- | ---------------------------- | ----------- | --------------------------------------------------------------------------------------- |
| `Client` | `DinaupClientC` | — | **Requerido.** Cliente del SDK que ejecuta el informe. |
| `ReportId` | `string` | `""` | **Requerido.** GUID del informe a cargar. |
| `VariablesValues` | `Dictionary` | — | Valores de las variables del informe; si faltan, se pregunta antes de pintar los hijos. |
| `QuerySearch` | `string` | `""` | Búsqueda aplicada a la carga. |
| `AdvancedFilter` | `List` | — | Filtro server-side aplicado a la carga. |
| `Limite` | `int` | `500` | Número de filas que trae para alimentar los hijos. |
| `Orden` | `Dictionary` | — | Orden de las filas que se cargan. |
| `AdminMode` | `bool` | `false` | Carga el informe en modo administrador. |
| `ChildContent` | `RenderFragment` | — | Las vistas que consumen el contexto (tarjetas, gráficas, ranking). |
| `OnDataLoaded` | `EventCallback` | — | Se dispara cuando termina la carga del informe. |
El Provider analiza las columnas del informe y deja preparado el mapeo del `ReportContext` (qué columna es la numérica principal, cuál es la de categoría/estado, cuál es de moneda…). Por eso `DnzChartView`, `DnzTopN` y `DnzCardList` funcionan sin que les digas qué columna pintar: lo adivinan del informe. Si no aciertan, se lo fuerzas con `ValueColumn` / `CategoryColumn`.
***
## DnzCardList [#dnzcardlist]
Pinta las filas del informe como tarjetas en vez de rejilla: título, una imagen de preview si la fila la trae, unos pocos campos y el importe destacado. Va dentro de un `DnzReportProvider`.
```razor
@code {
private async Task AbrirFicha(DinaupDynamicRowDTO fila) {
await DnzFormView.OpenAsync(DialogService, Client, fila.SectionId, fila.ID);
}
}
```
**Parámetros**
| Parámetro | Tipo | Por defecto | Qué hace |
| -------------- | ------------------------------------ | ----------- | ---------------------------------------------------------------------------------------------- |
| `MaxFields` | `int` | `4` | Cuántos campos secundarios muestra cada tarjeta (sin contar el título ni el importe). |
| `OnItemSelect` | `EventCallback` | — | Se dispara al pulsar una tarjeta. Si lo defines, sustituye la apertura automática de la ficha. |
Además acepta **atributos extra** (`class`, `style`, `data-*`…) que se aplican al `div` raíz de la lista.
La columna de moneda y el campo principal los elige el componente leyendo el mapeo del informe: el importe sale destacado a la derecha con `DnzSpanMoney`, las fechas en formato local y los estados con badge de color. Si la fila trae imagen de preview, la pinta redonda o cuadrada según el propio dato.
***
## DnzChartView [#dnzchartview]
Gráfica del informe (columnas, barras, líneas, área o tarta) agrupando por una categoría y sumando una métrica. Vive dentro de `DnzReportProvider`.
```razor
```
**Parámetros**
| Parámetro | Tipo | Por defecto | Qué hace |
| ---------------- | ------------ | ----------- | ------------------------------------------------------------------------------------------------ |
| `ChartType` | `ChartTypeE` | `Column` | Tipo de gráfica: `Column`, `Bar`, `Line`, `Area` o `Pie`. |
| `ValueColumn` | `string` | — | Keyword de la métrica a representar. Si lo omites, usa la numérica principal del informe. |
| `CategoryColumn` | `string` | — | Keyword de la categoría del eje X. Si lo omites, usa la columna de estado o la primera de texto. |
| `MaxItems` | `int` | `20` | Máximo de categorías (las de mayor valor); el resto se descarta. |
Además acepta **atributos extra** que se aplican al `div` raíz de la gráfica.
`ChartTypeE` es un enum anidado del propio componente, por eso en el markup va como `DnzChartView.ChartTypeE.Column`. Las filas se agrupan por `CategoryColumn` y se **suma** `ValueColumn` por grupo, así que un informe de líneas de factura se convierte en "total por cliente" sin más.
***
## DnzTopN [#dnztopn]
Ranking visual de barras horizontales con las N filas de mayor (o menor) valor del informe. Va dentro de un `DnzReportProvider`.
```razor
```
**Parámetros**
| Parámetro | Tipo | Por defecto | Qué hace |
| ------------- | -------- | ----------- | ------------------------------------------------------------------------------------- |
| `N` | `int` | `10` | Cuántas filas mostrar en el ranking. |
| `ShowTitle` | `bool` | `true` | Muestra la cabecera "Top N — Columna". |
| `ValueColumn` | `string` | — | Keyword de la columna a rankear. Si lo omites, usa la numérica principal del informe. |
| `Ascending` | `bool` | `false` | `true` para mostrar los valores más bajos primero. |
Si la columna es de tipo moneda o minutos, el valor se formatea solo con `DnzSpanMoney` / `DnzSpanMinutes`. No tienes que indicar el formato: lo hereda del informe. Si el informe no tiene ninguna columna numérica representable, `DnzTopN` no pinta nada.
***
## DnzFilter [#dnzfilter]
El sistema de filtros por columna de `DnzReportView`. No lo colocas tú: la propia tabla lo inserta en la cabecera de cada columna y elige el filtro adecuado según el tipo del campo.
```razor
```
**Parámetros**
| Parámetro | Tipo | Por defecto | Qué hace |
| ------------ | ------------------------------------------- | ----------- | --------------------------------------------------------------------------- |
| `Column` | `DinaupFieldDTO` | — | Definición de la columna del informe (tipo, formato, valores predefinidos). |
| `DataColumn` | `RadzenDataGridColumn` | — | La columna de la rejilla a la que se ata el filtro. |
`DnzFilter` es un **router**: según el formato de la columna delega en el filtro especializado correspondiente. La familia completa:
| Filtro | Cuándo entra |
| ------------------------------------------------------- | ------------------------------------------- |
| `DnzTextFilter` | Texto libre (por defecto). |
| `DnzIntegerFilter` | Columnas `INT`. |
| `DnzDecimalFilter` | Columnas `DEC`. |
| `DnzDateFilter` / `DnzDateTimeFilter` / `DnzTimeFilter` | Fechas, fecha-hora y hora. |
| `DnzBoolFilter` | Booleanos. |
| `DnzBadgeFilter` | Columnas con estilo de badge. |
| `DnzPredefinedFilter` | Columnas con lista de valores predefinidos. |
No documentamos cada filtro por separado porque no los instancias a mano: pones `DnzReportView` y el filtro correcto aparece según el informe. El concepto de filtrado server-side y cómo definir filtros de entrada vive en [Flex / Informes](/docs/desarrollo/flex/informes).
***
## Leer una fila [#leer-una-fila]
Las filas que reparten estos componentes son `DinaupDynamicRowDTO`. Para sacar el texto de una columna usa `.GetLegible("columna")`; `ID` y `SectionId` vienen rellenos para abrir la ficha.
```razor
@code {
private async Task AbrirFila(DinaupDynamicRowDTO fila) {
var nombre = fila.GetLegible("cliente");
await DnzFormView.OpenAsync(DialogService, Client, fila.SectionId, fila.ID);
}
}
```
***
## Relacionado [#relacionado]
* [Selectores](/docs/desarrollo/dotnet/dinazen/componentes/selectores): cuando el caso es "elige una ficha" a partir de un informe.
* [KPIs y métricas](/docs/desarrollo/dotnet/dinazen/componentes/kpis-y-metricas): cifras y comparativas para completar el dashboard.
* [Datos tipados (Spans)](/docs/desarrollo/dotnet/dinazen/componentes/datos-tipados): `DnzSpanMoney`, `DnzSpanMinutes` y demás, lo que estas vistas usan por dentro.
* [Cookbook de patrones](/docs/desarrollo/dotnet/dinazen/patrones): recetas de extremo a extremo que combinan estos componentes con el SDK.
* [Informes de Dinaup Flex](/docs/desarrollo/flex/informes): qué es un informe, su `ReportId`, variables y filtros. · [Filtrar un informe por rango de fechas](/docs/desarrollo/flex/informes/filtrar-informe-por-rango-de-fechas)
* [SDK / Cliente Dinaup](/docs/desarrollo/dotnet/sdk/cliente): cómo ejecutar el informe con `Report_GetAsync`.
→ [Volver a Componentes](/docs/desarrollo/dotnet/dinazen/componentes) · [DinaZen](/docs/desarrollo/dotnet/dinazen) · [SDK .NET](/docs/desarrollo/dotnet/sdk)
# Tarjetas y layout (/docs/desarrollo/dotnet/dinazen/componentes/tarjetas-y-layout)
Casi toda pantalla de Dinaup es lo mismo: una `RadzenCard`, una cabecera arriba y un cuerpo debajo. La cabecera la pones con `DnzCardTitle` y el cuerpo con el contenido que toque. Con estas piezas montas vistas con la estructura visual de Play.
`RadzenCard` envuelve, `DnzCardTitle` titula, y dentro va tu grid, tu formulario o tu lista. El resto de la familia son atajos para casos concretos (KPIs, fichas clicables, avatares, bloques con zoom).
## El patrón base [#el-patrón-base]
Toda subpage parte del mismo esqueleto. Cabecera con icono y título, acciones a la derecha, cuerpo debajo.
### Envuelve en RadzenCard [#envuelve-en-radzencard]
La tarjeta da el fondo, la sombra y el padding. Nunca pintes contenido suelto sin contenedor.
### Pon la cabecera con DnzCardTitle [#pon-la-cabecera-con-dnzcardtitle]
`Icon` + `Title` y listo. Si necesitas botones (agregar, refrescar), van en el slot ``.
### Mete el cuerpo [#mete-el-cuerpo]
Tu `RadzenDataGrid`, tu formulario o una lista. Si quieres que el bloque se pegue a los bordes de la tarjeta, usa `DnzCardBody`.
```razor
@if (productos.IsEmpty())
{
...
}
```
***
## DnzCardTitle [#dnzcardtitle]
Cabecera de tarjeta con icono, título, subtítulo opcional, botones de acción y panel de ayuda desplegable.
```razor
```
| Parámetro | Tipo | Default | Para qué |
| ------------- | ----------------------------- | ------- | --------------------------------------------------------------------------------------- |
| `Title` | `string` | `""` | Texto principal de la cabecera. |
| `Subtitle` | `string` | `""` | Segunda línea bajo el título. Si va vacío, no se pinta. |
| `Icon` | `string` | `""` | Icono Material a la izquierda. Si es una ruta (`/...`, `http...`) lo pinta como imagen. |
| `BadgeType` | `DnzSpecialBadges.BadgeType?` | | Badge especial junto al título (Beta, New\...). |
| `Compact` | `bool` | `false` | Versión reducida con borde inferior, para cabeceras secundarias. |
| `HelpLink` | `string` | `""` | URL de documentación. Activa el botón de ayuda con enlace externo. |
| `HelpContent` | `RenderFragment` | | Contenido de ayuda inline (texto rico) en el panel desplegable. |
| `Actions` | `RenderFragment` | | Slot de botones a la derecha de la cabecera. |
Los botones del slot `Actions` que disparan operaciones async deben llevar `IsBusy=@variable` para que el usuario vea el spinner. Es UX, no opcional.
El botón de ayuda (icono de interrogación a la derecha) solo aparece si pones `HelpContent` o `HelpLink`. Con `HelpContent` escribes el panel a mano; con `HelpLink` el componente pinta un enlace "Ver documentación" que abre en pestaña nueva. Si pones los dos, manda `HelpContent`.
```razor
Configura los tipos impositivos que se ofrecen al crear lineas de factura. El marcado como predeterminado se aplica a productos nuevos.
```
```razor
Además de los parámetros de arriba, `DnzCardTitle` acepta **atributos extra que pasan al elemento raíz** (`[Parameter(CaptureUnmatchedValues = true)]`): útil para colar un `id`, un `data-*` o una clase suelta sin tocar el componente.
## DnzCardBody [#dnzcardbody]
Bloque que escapa del padding de la `RadzenCard` padre con margen negativo, para que un grid o una tabla llegue a ras de borde dentro de la tarjeta.
```razor
...
```
| Parámetro | Tipo | Default | Para qué |
| -------------- | ---------------- | ------- | --------------------------------------------------- |
| `ChildContent` | `RenderFragment` | | Contenido del bloque a ancho completo. |
| `Class` | `string` | `""` | Clases CSS extra sobre el contenedor. |
| `Style` | `string` | `""` | Estilos inline extra (se suman al margen negativo). |
## DnzCardKV [#dnzcardkv]
Tarjeta clave-valor para KPIs: icono coloreado a la izquierda, etiqueta arriba y valor grande debajo. Pensada para filas de metricas (uptime, total facturado, stock).
```razor
`Tile` existe por compatibilidad con consumidores antiguos. En código nuevo usa siempre `Title`.
## DnzCardList [#dnzcardlist]
Renderiza el resultado de un informe Flex como lista de fichas clicables, con imagen, título y hasta 4 campos. Se alimenta del `ReportContext` cascada, no le pasas los datos a mano. Al pulsar una ficha abre el registro o dispara tu callback.
```razor
```
| Parámetro | Tipo | Default | Para qué |
| -------------- | ------------------------------------ | ------- | --------------------------------------------------------------------------------- |
| `MaxFields` | `int` | `4` | Número máximo de campos a mostrar por ficha. |
| `OnItemSelect` | `EventCallback` | | Se dispara al pulsar una ficha. Si no lo enganchas, abre el registro por defecto. |
`DnzCardList` vive dentro del sistema de informes Flex y consume el `ReportContext` por cascada. Para entender de donde sale ese contexto, mira [Informes Flex](/docs/desarrollo/flex/informes).
## DnzContainer [#dnzcontainer]
Contenedor de formularios virtuales (Flex). Posiciona una `RadzenCard` con coordenadas absolutas y dentro pinta una lista de informe, una lista primaria o botones, según la definición del `Container`. Es infraestructura del motor de formularios: rara vez lo instancias a mano, lo coloca el renderizador de formularios.
```razor
` | | Se dispara al pulsar un botón del contenedor. |
| `OnTabChanged` | `EventCallback` | | Se dispara al cambiar de pestaña en una lista primaria. |
| `OnAddItem` | `EventCallback` | | Se dispara al añadir un item a la lista primaria. |
| `OnOpenListItem` | `EventCallback` | | Se dispara al abrir un item de la lista. |
| `OnDeleteItemPrimaryList` | `EventCallback` | | Se dispara al eliminar un item de la lista primaria. |
## DnzControl [#dnzcontrol]
El campo individual de un formulario virtual (Flex): elige el input correcto (texto, número, fecha, checkbox, selector, editor HTML) según el `FieldFormatE` del `DataControl`. Como `DnzContainer`, es motor de formularios; lo pinta el renderizador, no tu código de pantalla.
```razor
` | | Se dispara cuando el usuario cambia el valor del campo. |
| `ModoCelda` | `bool` | `false` | Modo compacto sin label, para edición en celda de tabla. |
| `OnFormatearCodigo` | `Func>` | | Hook para reformatear un código de subcuenta al pulsar Enter. |
## DnzScalableBlock [#dnzscalableblock]
Envuelve cualquier contenido con dos botones de zoom (más/menos) y recuerda la escala en `localStorage`. Útil para tablas anchas o vistas densas que el usuario quiere agrandar. Cada bloque necesita un `Key` único para no pisar la escala de otro.
```razor
...
```
| Parámetro | Tipo | Default | Para qué |
| -------------- | ---------------- | ------- | ------------------------------------------------------------------------------ |
| `Key` | `string` | | (Requerido) Identificador unico. Con el se guarda la escala en `localStorage`. |
| `ChildContent` | `RenderFragment` | | Contenido que se escala con el zoom. |
El `Key` debe ser unico por bloque escalable. Si dos bloques comparten `Key`, comparten la escala guardada y se pisan.
## DnzAvatarInitial [#dnzavatarinitial]
Avatar circular con la inicial del nombre y un color de fondo derivado de esa letra (siempre el mismo color para la misma inicial). Para listas de usuarios, clientes o empleados sin foto.
```razor
```
| Parámetro | Tipo | Default | Para qué |
| ----------------- | ---------------- | --------- | -------------------------------------------------------------------------------------------------------------- |
| `Style` | `DnzBannerStyle` | `Primary` | Tema visual: `Primary`, `Gold`, `Love`, `Danger`, `Success`, `Warning`, `Pro`, `Beta`, `New`, `Premium`, `IA`. |
| `Title` | `string` | `""` | Titulo principal. Si va vacío, no se pinta. |
| `Icon` | `string` | `""` | Icono Material Symbols (`"check_circle"`, `"update"`, `"bolt"`). Si va vacío, no hay icono. |
| `ChildContent` | `RenderFragment` | | Cuerpo del banner: párrafos, ``, lo que necesites. |
| `ButtonText` | `string` | `""` | Texto del botón. Solo aparece junto con `DnzButtonrl`. |
| `DnzButtonrl` | `string` | `""` | URL de destino del botón. |
| `OpenInNewTab` | `bool` | `true` | Abre el enlace del botón en pestaña nueva. |
| `AdditionalClass` | `string` | `""` | Clases CSS extra sobre el contenedor. |
`DnzBanner` también aparece en [Badges y estados](/docs/desarrollo/dotnet/dinazen/componentes/badges-y-estados) por su faceta de señalizador: es el mismo componente, úsalo donde te encaje en la pantalla.
***
Relacionado: [Intro a DinaZen](/docs/desarrollo/dotnet/dinazen) · [Índice de componentes](/docs/desarrollo/dotnet/dinazen/componentes) · [Badges y estados](/docs/desarrollo/dotnet/dinazen/componentes/badges-y-estados) · [Datos tipados (Spans)](/docs/desarrollo/dotnet/dinazen/componentes/datos-tipados) · [Informes Flex](/docs/desarrollo/flex/informes) · [Guías de estilo C#/Blazor](/docs/desarrollo/dotnet/c-code-style-guidelines)
# Vistas avanzadas (/docs/desarrollo/dotnet/dinazen/componentes/vistas-avanzadas)
Piezas más especializadas, fuera del CRUD de cada día. Aquí tienes la planificación en línea de tiempo con `DnzGenericGantt`, el código resaltado para documentar dentro de la app (`DnzHighlightCode` y `DnzCodeWindow`) y los selectores de rango de fechas con presets para alimentar informes y dashboards (`DnzDateRangeSelector` y `DnzDateTimeRangeSelector`).
## Qué componente uso [#qué-componente-uso]
Tres familias dentro de la página:
| Necesito... | Componente |
| ----------------------------------------------------------------------- | -------------------------- |
| Pintar tareas/recursos en una línea de tiempo con zoom y navegación | `DnzGenericGantt` |
| Mostrar un snippet con resaltado de sintaxis, copiar y números de línea | `DnzHighlightCode` |
| Lo mismo pero con aspecto de ventana (dots de macOS, temas, footer) | `DnzCodeWindow` |
| Elegir un rango de fechas (solo día) con presets tipo "Últimos 7 días" | `DnzDateRangeSelector` |
| Elegir un rango con fecha y hora (incluye el HH:mm) | `DnzDateTimeRangeSelector` |
`DnzGanttToolBar` no se usa suelto: lo monta `DnzGenericGantt` por dentro para la barra de navegación y zoom. Lo documentamos abajo por transparencia, pero tú solo tocas el Gantt.
***
## DnzGenericGantt [#dnzgenericgantt]
Línea de tiempo tipo Gantt: filas por grupo (empleado, recurso, tarea) y barras por intervalo de tiempo, con barra superior para navegar, cambiar de vista (Horas / Semana / Mes / Año) y hacer zoom.
Le pasas dos listas: los `Groups` (las filas) y los `SourceItems` (las barras). Cada item se asocia a su fila por `GroupId`. El componente recalcula el layout solo cuando cambias de vista o de fecha.
```razor
_grupos = new();
private List _citas = new();
protected override void OnInitialized()
{
_grupos.Add(new GanttGroup { Id = "tecnico-1", Text = "Laura (Taller A)" });
_grupos.Add(new GanttGroup { Id = "tecnico-2", Text = "Marcos (Taller B)" });
_citas.Add(new GanttItem("c-1001", "tecnico-1", "Revision 8430-KLM", DateTime.Today.AddHours(9), DateTime.Today.AddHours(11), null));
_citas.Add(new GanttItem("c-1002", "tecnico-2", "ITV 1190-ZRT", DateTime.Today.AddHours(10), DateTime.Today.AddHours(12), null, "background:#0d6efd;color:#fff"));
}
private void AbrirCita(GanttItem item) { /* item.Data trae tu objeto de negocio */ }
}
```
| Parámetro | Tipo | Default | Para qué |
| ------------- | -------------------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| `Groups` | `List` | | Filas del Gantt. Cada `GanttGroup` tiene `Id`, `Text` y `Template` opcional para pintar la celda de la fila. |
| `SourceItems` | `List` | | Barras a colocar. Cada `GanttItem` se ata a su fila por `GroupId` y lleva `From`/`To`, `Text`, `Tooltip` y `RowStyle` (CSS inline de la barra). |
| `OnItemClick` | `EventCallback` | | Se dispara al hacer clic en una barra. Recupera tu entidad desde `item.Data`. |
Por encima de 20.000 items el componente deja de pintar y muestra un aviso de "demasiados resultados". Es a propósito: filtra antes de pasarle los datos, no le eches el listado entero.
`GanttItem` se construye con el constructor `new GanttItem(id, groupId, text, from, to, data, styleX)`. El ultimo parametro es CSS inline opcional para colorear la barra.
## DnzGanttToolBar [#dnzgantttoolbar]
Barra de control del Gantt: flechas anterior/siguiente, botón "Hoy", selector de vista (Horas / Semana / Mes / Año) y zoom. La monta `DnzGenericGantt` internamente; normalmente no la instancias tú.
```razor
` | | Se dispara al navegar, cambiar de vista o tocar el zoom. Devuelve una copia nueva del viewport. |
## DnzHighlightCode [#dnzhighlightcode]
Bloque de código con resaltado de sintaxis (highlight.js), cabecera con el lenguaje y el nombre de fichero, botón de copiar y números de línea opcionales. Para documentar dentro de la app: snippets de setup, ejemplos de uso, comandos.
```razor
Razor (`razor` / `cshtml`) se resalta como XML por dentro. Es el truco de highlight.js, tú solo pasas `Language="razor"`.
## DnzCodeWindow [#dnzcodewindow]
Lo mismo que `DnzHighlightCode` pero con estética de ventana: los tres puntos rojo/amarillo/verde de macOS, título, temas de color y un footer opcional. Para landings, demos o documentación donde quieras que el código "se vea bonito".
```razor
Registra DinaZen en el arranque.
@code {
private string _setup = "builder.Services.AddDinaZen();";
}
```
| Parámetro | Tipo | Default | Para qué |
| ----------------- | -------------------- | --------- | ---------------------------------------------------------------------------------------------------- |
| `Code` | `string` | `""` | El código a mostrar. |
| `Language` | `string` | `""` | Lenguaje del resaltado (mismos alias que `DnzHighlightCode`, más `py`, `go`, `rs`, `dockerfile`...). |
| `Title` | `string` | `""` | Titulo de la ventana (nombre de fichero o descripcion). |
| `ShowCopy` | `bool` | `true` | Muestra el boton de copiar. |
| `ShowLineNumbers` | `bool` | `false` | Pinta los números de línea. |
| `Tilted` | `bool` | `false` | Aplica un efecto 3D inclinado, útil en landings. |
| `Size` | `DnzCodeWindowSize` | `Default` | `Small`, `Default` o `Large`. |
| `Theme` | `DnzCodeWindowTheme` | `Dark` | Tema visual: `Dark`, `Light`, `Monokai` o `Dracula`. |
| `ChildContent` | `RenderFragment` | | Contenido del footer de la ventana (nota, enlace, etc.). |
Si solo quieres mostrar un snippet copiable con resaltado en una ficha o subpage, tira de `DnzHighlightCode`. Es más plano y ocupa menos.
Si es una landing o una demo donde el código es parte del diseño, `DnzCodeWindow` con `Theme` y `Tilted` queda mucho mejor.
## DnzDateRangeSelector [#dnzdaterangeselector]
Selector de rango de fechas (solo día, sin hora) con un desplegable de presets: Hoy, Ayer, Últimos 7 días, Este mes, Este trimestre, Este año, etc. Al elegir "Personalizado" aparecen dos date pickers Desde/Hasta. El componente devuelve el rango ya calculado como `DateOnly`; tú solo recargas datos.
```razor
` | | Se dispara al cambiar de preset (lo usa el binding). |
| `OnRangeChanged` | `EventCallback<(DateOnly From, DateOnly To)>` | | Se dispara con el rango ya calculado cada vez que cambia. Aquí recargas tus datos. |
`OnRangeChanged` salta tambien en el primer render con el preset por defecto, asi que el listado carga solo sin tener que disparar nada a mano.
## DnzDateTimeRangeSelector [#dnzdatetimerangeselector]
Gemelo del anterior pero con hora: los date pickers personalizados incluyen `HH:mm` y el rango se devuelve como `DateTime` (no `DateOnly`). Úsalo cuando el intervalo importa al minuto: logs, fichajes, eventos, auditoría.
```razor
` | | Se dispara al cambiar de preset (lo usa el binding). |
| `OnRangeChanged` | `EventCallback<(DateTime From, DateTime To)>` | | Se dispara con el rango ya calculado (con hora) cada vez que cambia. |
Regla rápida: si el dato es "por día" (ventas, stock, facturación) usa `DnzDateRangeSelector`. Si necesitas el minuto exacto (logs, fichajes, trazabilidad) usa `DnzDateTimeRangeSelector`. No mezcles tipos: uno te da `DateOnly` y el otro `DateTime`.
***
Relacionado: [Intro a DinaZen](/docs/desarrollo/dotnet/dinazen) · [Índice de componentes](/docs/desarrollo/dotnet/dinazen/componentes) · [SDK .NET](/docs/desarrollo/dotnet/sdk) · [Informes Flex](/docs/desarrollo/flex/informes) · [Guías de estilo C#/Blazor](/docs/desarrollo/dotnet/c-code-style-guidelines)
# Ejemplo: agregar un cliente desde Dinaup (.NET) (/docs/desarrollo/dotnet/sdk/cliente/ejemplo-agregar-cliente)
Este ejemplo usa [WriteOperation](/docs/desarrollo/dotnet/sdk/cliente/ejemplo-writeoperations-por-lotes) del [SDK Dinaup (.NET)](/docs/desarrollo/dotnet/sdk/cliente) para agregar un cliente en la sección **Entidades**, con la opción de Cliente (bool) activada.
```csharp
public async Task AddCustomer()
{
var datosCliente = new Dictionary
{
{ SectionsD.EntidadesD.EntidadesES.TextoPrincipal, $"Cliente {Guid.NewGuid()}" },
{ SectionsD.EntidadesD.EntidadesES.NombrePersonalRazonSocial, "Juan García S.A." },
{ SectionsD.EntidadesD.EntidadesES.Apellidos, "García López" },
{ SectionsD.EntidadesD.EntidadesES.Cliente, "1" }
};
var writeOperation = new WriteOperation(string.Empty, datosCliente);
var seccionID = SectionsD.EntidadesD._SectionIDGUID;
try
{
await Client.RunWriteOperationAsync(seccionID, writeOperation, false);
writeOperation.EnsureSuccess();
return writeOperation.WriteOperationResult.RowID;
}
catch (Exception ex)
{
Dinaup.Logs.Error(ex, "AddCustomer");
throw;
}
}
```
# Ejemplo: agregar un recambio en Dinaup (.NET) (/docs/desarrollo/dotnet/sdk/cliente/ejemplo-agregar-recambio)
Agregar un nuevo recambio utilizando el [SDK Dinaup para .NET](/docs/desarrollo/dotnet/sdk/cliente) se hace mediante la clase [WriteOperation](/docs/desarrollo/dotnet/sdk/cliente/ejemplo-writeoperations-por-lotes), enviando los campos requeridos a la sección de recambios.
### Requisitos previos [#requisitos-previos]
Antes de agregar un recambio asegúrate de contar con:
* `vehiculoID`: El ID de un vehículo válido para desguace.
* `numeracionID`: Una numeración activa (serie de recambio).
* `tipoID`: El tipo de recambio.
* `estadoID`: El estado del recambio.
Si no tienes los valores puedes obtenerlos usando los métodos para consultar informes. [Reports](/docs/desarrollo/flex/informes)
### Preparar los datos [#preparar-los-datos]
Crea un diccionario con los datos del recambio:
```csharp
var datosRecambio = new Dictionary
{
{ RecambiosES.TextoPrincipal, "Motor diésel completo" },
{ RecambiosES.ReferenciaRecursoDeOrigen, vehiculoID },
{ RecambiosES.ReferenciaNumeracion, numeracionID },
{ RecambiosES.ReferenciaEstado, estadoID },
{ RecambiosES.ReferenciaTipo, tipoID }
};
```
`RecambiosES` se encuentra en el espacio de nombres `MyDinaup.SectionsD.RecambiosD`. \
Debes tener instalada en el proyecto la librería de mapeo personalizada [MyDinaup](/docs/desarrollo/dotnet/mydinaup).
### Crear y ejecutar la operación [#crear-y-ejecutar-la-operación]
Crea la operación de escritura:
```csharp
var writeOperation = new WriteOperation(string.Empty, datosRecambio);
```
Ejecuta la operación
```csharp
var seccionID = MyDinaup.SectionsD.RecambiosD._SectionIDGUID;
var resultado = await client.RunWriteOperationAsync(
seccionID,
writeOperation,
false // false = escritura directa, true = virtualizada (ejecuta scripts)
);
resultado.EnsureSuccess(); // Provoca excepción si algo falla.
```
# Ejemplo: ejecución de WriteOperations por lotes (.NET) (/docs/desarrollo/dotnet/sdk/cliente/ejemplo-writeoperations-por-lotes)
### Aprende a crear WriteOperations [#aprende-a-crear-writeoperations]
Puedes aprender a crear **WriteOperations** consultando la guía del [Cliente Dinaup](/docs/desarrollo/dotnet/sdk/cliente).
### Crea una lista de WriteOperations [#crea-una-lista-de-writeoperations]
```csharp
var bulkOperations = new List();
/// Agregar WriteOperation
```
Todos los WriteOperations deben tener las mismas columnas.
### Ejecuta la colección [#ejecuta-la-colección]
```csharp
var bulkOperations = new List();
/// Agregar WriteOperation
var sectionId = MyDinaup.SectionsD.TareasDeProyectosD.TareasDeProyectosES._SectionIDGUID;
var result = await dinaupClient.RunWriteOperationAsync(sectionId, bulkOperations, true);
result.EnsureSuccess(); // Provoca excepción si algo falla.
```
## Ejemplo [#ejemplo]
```csharp
var bulkOperations = new List();
for (int i = 1; i <= 5; i++)
{
var itemData = new Dictionary
{
{ MyDinaup.SectionsD.TareasDeProyectosD.TareasDeProyectosES.Resumen, $"Tarea #{i}" },
{ MyDinaup.SectionsD.TareasDeProyectosD.TareasDeProyectosES.TextoPrincipal, $"Contenido para la tarea {i}" },
{ MyDinaup.SectionsD.TareasDeProyectosD.TareasDeProyectosES.Prioridad, (i % 3).ToString() }
};
bulkOperations.Add(new WriteOperation(string.Empty, itemData));
}
var sectionId = MyDinaup.SectionsD.TareasDeProyectosD.TareasDeProyectosES._SectionIDGUID;
var result = await dinaupClient.RunWriteOperationAsync(sectionId, bulkOperations, true);
result.EnsureSuccess(); // Provoca excepción si algo falla.
```
# Escribir en secciones (/docs/desarrollo/dotnet/sdk/cliente/escritura-autorrellenado-y-scripts)
Un WriteOperation envía un diccionario campo → valor. Pero la sección no es un almacén pasivo: al escribir, el servidor **autorrellena** campos dependientes, **calcula** totales y puede ejecutar la **misma lógica interna** que usa la interfaz. Entender estos tres comportamientos evita la mayoría de sorpresas al integrar.
## 1. El orden de los campos importa [#1-el-orden-de-los-campos-importa]
Los campos se procesan en el orden en que los envías, y escribir uno dispara los autorrellenados que dependen de él.
Ejemplo real de **Ventas**: al rellenar `Cliente`, se copia automáticamente su descuento a la venta. Si envías primero el descuento manual y después el cliente, el autorrellenado del cliente **pisa** tu descuento. Regla práctica: **primero las referencias** (cliente, proceso, producto...), **después los valores manuales**.
Otro ejemplo, de **Oportunidades CRM**: al escribir el `Proceso` comercial, la `Fase` se autorrellena con la fase inicial de ese proceso. El proceso va antes que cualquier campo que dependa de la fase.
## 2. Autorrellenado «Siempre» copia incondicionalmente [#2-autorrellenado-siempre-copia-incondicionalmente]
Cuando un campo está definido como autorrellenado «Siempre» desde otro, la copia se ejecuta **cada vez** que cambia el origen:
* Si seleccionas un cliente **sin** descuento, el descuento de la venta se copia **vacío** (no se conserva el anterior).
* Si **deseleccionas** el cliente, el destino también se vacía.
No es un valor por defecto: es una copia viva. Si necesitas un valor manual distinto, escríbelo **después** del campo que lo autorrellena.
## 3. Los scripts hacen el trabajo por ti [#3-los-scripts-hacen-el-trabajo-por-ti]
Cada sección puede llevar scripts internos: cálculos, validaciones y filtros que en la interfaz se ejecutan solos. Al escribir por API con **scripts activados**, se ejecutan igual:
```csharp
// Tercer parámetro a true: el servidor ejecuta los scripts de la sección
// (calcula totales, valida y aplica su lógica, igual que en la interfaz).
var result = await dinaupClient.RunWriteOperationAsync(sectionId, bulkOperations, true);
```
En una **venta**, rellenas `Cantidad` y `PrecioPorUnidad` de una línea y el total del concepto —y los totales del documento— se calculan solos. En **turnos**, los scripts calculan duraciones. Sin scripts, esos campos quedarían a tu cargo: actívalos y reduce tu responsabilidad a los datos de negocio.
Los campos marcados como auto-gestionados (fechas UTC, autor del alta, empresa, calculados como los totales) **los pone el servidor**: enviarlos es en el mejor caso inútil y en el peor un error. En el SDK, el comentario de cada campo (`///`) indica su política de escritura: `Required`, `Auto-filled (Siempre)`, `Read-only via REST` o `can be set when creating, but read-only on update`.
## 4. En las listas, el servidor solo toca las líneas que envías [#4-en-las-listas-el-servidor-solo-toca-las-líneas-que-envías]
Una sección con lista (una venta y sus conceptos, un asiento y sus apuntes) se escribe siempre por su sección principal: la cabecera en `DataMainRow` y las líneas en `DataListRows`, dentro del mismo WriteOperation. La sección de lista no admite escrituras directas — sus scripts y cálculos viven en la principal.
Enviar líneas **no reemplaza la lista**. El servidor procesa una a una las que recibe, decide por su `"id"`, y deja intactas las que no están en el envío:
| La línea enviada lleva | El servidor |
| --------------------------------- | ------------------------------ |
| `"id"` vacío, o sin `"id"` | crea la línea |
| el `"id"` de una línea existente | edita solo los campos enviados |
| su `"id"` y `"eliminado"` a `"1"` | borra la línea |
Puedes corregir el precio de un concepto enviando una única línea con su `"id"`, sin releer ni reenviar el resto del documento.
## Resumen operativo [#resumen-operativo]
| Situación | Qué hacer |
| ---------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| Alta con referencias (cliente, producto, proceso...) | Referencias primero, valores manuales después |
| Un valor manual "desaparece" | Un autorrellenado «Siempre» posterior lo pisó: reordena |
| Totales o campos derivados | No los calcules: `withScripts: true` y los pone el servidor |
| Editar o borrar una línea concreta | Envíala en `DataListRows` con su `id` (`eliminado` a `1` para borrarla); el resto de líneas no se toca |
| Campo rechazado o ignorado | Mira su política REST en el comentario del SDK |
| ¿Qué sección uso para este dato? | [Catálogo de secciones del núcleo](/docs/desarrollo/recursos/secciones-nucleo) |
Ejemplos completos de escritura: [WriteOperations por lotes](/docs/desarrollo/dotnet/sdk/cliente/ejemplo-writeoperations-por-lotes), [agregar un cliente](/docs/desarrollo/dotnet/sdk/cliente/ejemplo-agregar-cliente) y [agregar un recambio](/docs/desarrollo/dotnet/sdk/cliente/ejemplo-agregar-recambio).
# Cliente Dinaup (/docs/desarrollo/dotnet/sdk/cliente)
El cliente `Dinaup` en .NET te conecta al servicio para consultar informes, gestionar archivos, añadir anotaciones, generar documentos dinámicos, leer/escribir datos de secciones y trabajar con paginación y filtros.
## Conectar y operar [#conectar-y-operar]
### Instala [#instala]
```bash
dotnet add package Dinaup
dotnet add package Demoup.MyDinaup
```
### Conecta [#conecta]
```csharp
var client = await DinaupClientC.ConnectAsync(
endPoint: "https://api.dinaup.com/v2/tu-codigo",
publicKey: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
secretKey: "tu-secret-key-aqui"
);
if (client == null || client.IsConnected == false)
{
throw new Exception("No se pudo conectar a Dinaup");
}
```
```csharp
using Dinaup;
// Las unicas credenciales en variables de entorno
var vault = new VaultData(
Environment.GetEnvironmentVariable("VAULT_URL"),
Environment.GetEnvironmentVariable("VAULT_PASSWORD")
);
vault.Initialize();
// Todo lo demas viene del Vault
var client = await DinaupClientC.ConnectAsync(
endPoint: vault.Read("dinaup.endpoint"),
publicKey: vault.Read("dinaup.publickey"),
secretKey: vault.Read("dinaup.secretkey")
);
if (client == null || client.IsConnected == false)
{
throw new Exception("No se pudo conectar a Dinaup");
}
```
```csharp
using Dinaup;
var builder = WebApplication.CreateBuilder(args);
// Cargar Vault
var vault = new VaultData(
Environment.GetEnvironmentVariable("VAULT_URL"),
Environment.GetEnvironmentVariable("VAULT_PASSWORD")
);
vault.Initialize();
// Conectar a Dinaup
var client = await DinaupClientC.ConnectAsync(
endPoint: vault.Read("dinaup.endpoint"),
publicKey: vault.Read("dinaup.publickey"),
secretKey: vault.Read("dinaup.secretkey")
);
if (client == null || client.IsConnected == false)
throw new Exception("No se pudo conectar a Dinaup");
// Registrar como Singleton
builder.Services.AddSingleton(client);
var app = builder.Build();
```
### Opera [#opera]
```csharp
// Use pre-built reports from DemoUp.MyDinaup
using DemoUp.MyDinaup.Reports.FuncionalidadD;
// Create and execute the report
var ventasReport = new APIVentasC();
await ventasReport.ExecuteQueryAsync(
dinaupClient: client,
page: 1,
resultsPerPage: 50
);
// Access results
Console.WriteLine($"Total: {ventasReport.TotalResults} records");
foreach (var row in ventasReport.Rows)
{
Console.WriteLine($"- {row.NumerodefacturaCompleto}: {row.Total}");
}
```
```csharp
Guid sectionId = /* sección destino */;
var data = new Dictionary
{
{
SeccionDePruebasAPIES.TextoPrincipal,
$"Prueba {Guid.NewGuid()}"
}
};
var wOp = new WriteOperation("", data); // "" => alta
// El sectionId es un Guid: usa _SectionIDGUID (no _SectionID, que es string)
await dinaupClient.RunWriteOperationAsync(SeccionDePruebasAPIES._SectionIDGUID, wOp, false);
// Lanza excepción si la operación falló o no se ejecutó
wOp.EnsureSuccess();
// Tras EnsureSuccess, WriteOperationResult está garantizado (no nulo)
Guid newId = wOp.WriteOperationResult.RowID;
```
```csharp
Guid rowId = /* Id del registro a editar */;
var data = new Dictionary
{
{
SeccionDePruebasAPIES.TextoPrincipal,
$"Prueba {Guid.NewGuid()}"
}
};
var wOp= new WriteOperation(rowId, data);
await dinaupClient.RunWriteOperationAsync(sectionId, wOp, false);
// Lanza excepción si la operación falló o no se ejecutó
wOp.EnsureSuccess();
Guid updatedId = wOp.WriteOperationResult.RowID;
```
## Referencias [#referencias]
### Dinaup .NET [#dinaup-net]
Antes de empezar, instala el paquete Dinaup, que incluye el Cliente base: conexión, autenticación, sesiones, archivos, anotaciones, WriteOperations, etc.
[https://www.nuget.org/packages/Dinaup](https://www.nuget.org/packages/Dinaup)
### MyDinaup [#mydinaup]
Cada empresa tiene su propio modelo de datos. Para trabajarlo tipado, añade tu biblioteca **MyDinaup**: las secciones, informes y documentos de tu tenant convertidos en clases con sus nombres reales. Qué contiene, qué paquete elegir y cómo se regenera, en [MyDinaup](/docs/desarrollo/dotnet/mydinaup).
### Informes [#informes]
Los informes son consultas predefinidas y tipadas para acceder a datos de manera eficiente. Están en el espacio de nombres:
* `{Empresa}.MyDinaup.Reports.{CategoriaD}`
* Convención de nombres de clases: API + NombreDeSeccion + C
* Los nombres de secciones/clases están en español porque se generan a partir de tu licencia (por ejemplo, “Ventas”, “Impuestos”, etc.).
Ejemplos de clases:
* DemoUp.MyDinaup.Reports.FuncionalidadD.APISeccionDePruebasAPIC
* DemoUp.MyDinaup.Reports.FuncionalidadD.APIEntidadesC
* DemoUp.MyDinaup.Reports.VentasD.APIVentasC
* DemoUp.MyDinaup.Reports.ImpuestosD.APIImpuestosC
Usa ExecuteQueryAsync para obtener resultados paginados. Accede a filas fuertemente tipadas desde report.Rows.
```csharp
using DemoUp.MyDinaup.Reports.FuncionalidadD;
var report = new APISeccionDePruebasAPIC(); //
await report.ExecuteQueryAsync(dinaupClient, page: 1, resultsPerPage: 10);
Console.WriteLine($"Total resultados: {report.TotalResults}");
if (report.Rows.IsNotEmpty())
{
foreach (var fila in report.Rows)
{
// Accede a propiedades tipadas de cada fila
// Ej.: fila.TextoPrincipal, fila.ValorEntero, etc.
}
}
```
Ajusta resultsPerPage a tus necesidades. Si esperas muchos resultados, usa paginación.
* **Filtrar resultados** \
Filtro simple por campo de la misma sección
```csharp
var report = new APISeccionDePruebasAPIC();
// Igualdad estricta
report.AddFilter(
SeccionDePruebasAPIES.ValorEntero,
"=",
3);
await report.ExecuteQueryAsync(dinaupClient, page: 1, resultsPerPage: 10);
if (report.Rows.IsNotEmpty())
{
foreach (var fila in report.Rows)
{
// Usar fila...
}
}
```
* **Filtrar utilizando datos relacionados** (composición de rutas):
Construye una clave de relación combinando el ID de sección y el campo de interés en la entidad relacionada.
```csharp
// Clave de relación (ruta compuesta)
var relationKey =
SeccionDePruebasAPIES._SectionID.STR() + "." +
SeccionDePruebasAPIES.ReferenciaAutorDelAlta + "." +
EntidadesBaseES._SectionID.STR() + "." +
EntidadesBaseES.VIP;
var report = new APISeccionDePruebasAPIC();
report.AddFilter(relationKey, "=", 3);
await report.ExecuteQueryAsync(dinaupClient, page: 1, resultsPerPage: 10);
if (report.Rows.IsNotEmpty())
{
foreach (var fila in report.Rows)
{
// Usar fila...
}
}
```
* **Filtrado Between**
```csharp
// Between (ej.: 1 a 2999)
var reportBetween = new APISeccionDePruebasAPIC();
reportBetween.AddFilterBetween(
SeccionDePruebasAPIES.ValorEntero,
1,
2999
);
await reportBetween.ExecuteQueryAsync(dinaupClient, page: 1, resultsPerPage: 10);
```
* **Solapamiento de rangos de fechas (overlap)**
```csharp
var eventosReport = new APIEventosDeCRMC();
var campoInicio = EventosDeCRMES.InicioEvento_UTC;
var campoFin = EventosDeCRMES.FinEvento_UTC;
var rangoInicio = DateOnly.FromDateTime(new DateTime(2000, 1, 1));
var rangoFin = DateOnly.FromDateTime(DateTime.Today.AddYears(50));
eventosReport.AddFilterDateRangeOverlapFilter(campoInicio, campoFin, rangoInicio, rangoFin);
await eventosReport.ExecuteQueryAsync(dinaupClient, page: 1, resultsPerPage: 25);
```
* **Búsqueda de texto libre**
El parámetro `querySearch` de `ExecuteQueryAsync` busca en los campos de texto del informe, como el buscador de la interfaz web.
```csharp
var report = new APISeccionDePruebasAPIC();
await report.ExecuteQueryAsync(dinaupClient, 1, 25, "iPhone Pro Max");
```
* **Filtro IN (varios valores a la vez)**
```csharp
// Con textos
report.AddFilter(SeccionDePruebasAPIES.TextoPrincipal, new[] { "Valor A", "Valor B" });
// Con Guids (relaciones)
report.AddFilterIn(SeccionDePruebasAPIES.ReferenciaAutorDelAlta, new[] { id1, id2 });
```
* **OR implícito**
Dos filtros sobre el mismo campo se combinan con OR, no con AND.
```csharp
report.AddFilter(PaisesD.PaisesES.CodigoDePaisAlfabeticoDe2Caracteres, "=", "ES");
report.AddFilter(PaisesD.PaisesES.CodigoDePaisAlfabeticoDe2Caracteres, "=", "IT");
// Devuelve España e Italia
```
* **Variables de informe**
Si el informe define variables (por ejemplo, un rango de fechas parametrizado), pásalas con `AddVariable`. Admite `string`, `Guid`, `int`, `decimal`, `bool`, `Date` y `DateOnly`.
```csharp
report.AddVariable("ClienteId", clienteId);
report.AddVariable("FechaDesde", new DateOnly(2026, 1, 1));
```
Cuando el informe tiene muchos resultados, recorre página a página con ExecuteQuery\_NextPage\_Async.
```csharp
var report = new APISeccionDePruebasAPIC();
await report.ExecuteQueryAsync(_dinaupClient, 1, 300);
if (report.Rows.IsNotEmpty())
{
do
{
foreach (var row in report.Rows)
{
}
} while (await report.ExecuteQuery_NextPageAsync());
}
```
Para exportar o procesar **todas** las filas de un informe, usa `LoadAllRowsAsync`. Pagina por keyset (cursor sobre el id), sin `OFFSET`, con coste constante por página y sin filas repetidas ni saltadas. Escala a millones.
```csharp
// Devuelve TODAS las filas del informe, ordenadas por id.
var report = new APISeccionDePruebasAPIC();
var todas = await report.LoadAllRowsAsync(dinaupClient, pageSize: 10000, adminMode: true);
Console.WriteLine($"{todas.Count} filas volcadas");
```
Es para exportar y procesar por lotes, no para mostrar en pantalla. El orden es por id (un GUID), así que **no** tiene orden de presentación. Si necesitas otro orden, ordénalo en memoria después. No llames a `AddOrder` antes: el keyset impone su propio orden por id y lanza excepción si ya hay uno.
Ver la guía [Listados de alto rendimiento](/docs/desarrollo/dotnet/sdk/listados-de-alto-rendimiento) para el detalle, los límites y las excepciones.
Cada informe expone tiempos del servidor para diagnóstico: `DatabaseTimeMS` (lo que tardó Postgres), `PrepareTimeMS`, `PostProcessTimeMS` y `ServerTimeMS` (la suma). `TraceId` correlaciona la consulta con los logs del servidor y `SQL` devuelve la sentencia ejecutada. Todos valen `0`/vacío hasta la primera consulta.
#### Columnas ausentes en la respuesta [#columnas-ausentes-en-la-respuesta]
Si el modelo tipado declara una columna que el servidor ya no devuelve, el informe lanza una excepción por defecto: así detectas de inmediato un desajuste entre tu MyDinaup y la estructura real. Para tolerarlo (registrar un aviso y dejar esas propiedades en su valor por defecto), activa `TolerateMissingColumns`:
```csharp
// Por informe:
var report = new APISeccionDePruebasAPIC();
report.TolerateMissingColumns = true;
// O como valor por defecto de todo el proceso, una vez al arrancar:
DinaupReportSettings.TolerateMissingColumns = true;
```
Cada informe hereda el valor de `DinaupReportSettings.TolerateMissingColumns` (por defecto `false`) al crearse, y puede sobrescribirlo por instancia.
### Archivos [#archivos]
Dinaup permite subir archivos desde memoria o URL y obtener URLs firmadas para su consumo.
* **Subir desde un array de bytes**
```csharp
var bytes = System.Text.Encoding.UTF8.GetBytes("hola " + Guid.NewGuid());
var upload = await dinaupClient.File_UploadBytesAsync(bytes, "prueba.txt");
Guid fileId = upload.FileId;
```
* **Subir desde una URL**
```csharp
var upload = await dinaupClient.File_UploadURLAsync(
"https://cdn.dinaup.com/dinaup/web/portal/img/dinabot_marca.png",
"dinabot.png"
);
Guid fileId = upload.FileId;
```
* **Obtener una URL firmada (lectura)**
```csharp
var signed = await dinaupClient.File_SignURLGetAsync(fileId);
var url = signed.url_original; // URL lista para usar
```
Calcula el SHA1 en cliente y consulta antes de subir. Ahorra almacenamiento y ancho de banda.
```csharp
private async Task GetExistingFileAsync(string sha1)
{
var report = new MyDinaup.Reports.FuncionalidadD.APIIndiceDeArchivosEnSistemaC();
report.AddFilter("crcbase", "=", sha1);
await report.ExecuteQueryAsync(_dinaupClient, 1, 1, "", true, true);
return report.Files.Values.FirstOrDefault();
}
private async Task GetExistingFileAsync(byte[] data)
{
string sha1 = Dinaup.extensions.ToSHA1(data);
return await GetExistingFileAsync(sha1);
}
```
### Anotaciones [#anotaciones]
Todas las filas (registros) de Dinaup admiten 3 tipos de anotaciones:
* `AnnotationTypeE.`**`Comments`**: Mensajería tipo chat para el equipo, dentro del contexto del registro.
* `AnnotationTypeE.`**`PublicGallery`**: Archivos públicos en el CDN (p. ej., fotos de productos).
* `AnnotationTypeE.`**`Files`**: Documentos privados asociados (contratos, presupuestos, soportes, etc.).
Los archivos en **PublicGallery** son públicos: cualquiera con el enlace puede verlos.
A continuación, ejemplos usando AnnotationTypeE.Comments.
* **Agregar un comentario (solo texto)**
```csharp
Guid sectionId = /* tu sección */;
Guid rowId = /* registro al que agregas el comentario */;
var anotacion = new AnotationParameters(sectionId, rowId, AnnotationTypeE.Comments)
.WithText("¡Hola mundo! Este es mi primer comentario.");
await dinaupClient.Annotation_PutAsync(anotacion);
```
* **Agregar un comentario con archivo adjunto**
```csharp
var bytes = System.Text.Encoding.UTF8.GetBytes("contenido adjunto");
var upload = await dinaupClient.File_UploadBytesAsync(bytes, "nota.txt");
var anotacion = new AnotationParameters(sectionId, rowId, AnnotationTypeE.Comments)
.WithText("Comentario con adjunto")
.WithFile(upload.FileId); // adjuntamos el archivo
await dinaupClient.Annotation_PutAsync(anotacion);
```
* **Leer anotaciones**
```csharp
var resultado = await dinaupClient.Annotations_GetAsync(
sectionId,
rowId,
AnnotationTypeE.Comments
);
foreach (var anotacion in resultado.Annotations)
{
var texto = anotacion.Text;
var adjuntos = anotacion.AttachedFiles; // si hay archivos adjuntos
}
```
### Documentos dinámicos [#documentos-dinámicos]
Los Documentos Dinámicos permiten:
* Agrupar varias consultas en una sola operación para reducir latencia.
* Generar documentos de impresión (facturas, albaranes) delegando la composición en Dinaup.
Recomendación:
* Para consultar datos en general, usa Reports siempre que sea posible. Documentos Dinámicos son útiles para orquestar múltiples consultas y componer resultados.
- **Ejecutar un documento dinámico**
```csharp
var documentoSesionExecutor = new DynamicDocuments.APID.SesionC();
await documentoSesionExecutor.ExecuteAsync(dinaupClient);
```
### Secciones [#secciones]
Las secciones son el equivalente a tablas/entidades por empresa (Clientes, Facturas, Empleados, etc.). En MyDinaup existen utilidades tipadas para trabajar con ellas:
* Espacio de nombres: MyDinaup.SectionsD
* Incluye métodos para leer registros por Id o por criterios.
Advertencia de rendimiento:
* Las operaciones de lectura en SectionsD consultan todos los datos de la sección y los textos principales de los datos relacionados (p. ej., en una venta también recupera empleados, clientes, productos, impuestos, etc.). Esto tiene mayor coste computacional.
* Para rendimiento óptimo, usa Reports. Para escenarios “super optimizados”, usa PGSync.
* Usa SectionsD cuando el código se ejecute con poca frecuencia o para prototipos rápidos.
- **Recibir un dato por Id**
```csharp
Guid paisId = /* Id del país */;
var pais = await MyDinaup.SectionsD.PaisesD.GetRowByIdAsync(dinaupClient, paisId);
// Usa pais.Propiedad...
```
- **Recibir una lista**
```csharp
var filtros = new List
{
new FilterCondition(
MyDinaup.SectionsD.PaisesD.PaisesES.CodigoDePaisAlfabeticoDe2Caracteres,
"=",
"ES"
)
};
var parametros = new RowsRequestParameters(filtros.ToArray());
var paises = await MyDinaup.SectionsD.PaisesD.GetRowsAsync(dinaupClient, parametros);
// GetRowsAsync devuelve directamente una List
foreach (var p in paises)
{
// p.Propiedad...
}
```
- **Recibir cabecera y líneas en una llamada**
En secciones con lista (una factura y sus líneas), `GetRowsWithListAsync` devuelve cada registro como `MainRow` más su colección `ListRows`.
```csharp
var filas = await MyDinaup.SectionsD.FacturasD
.GetRowsWithListAsync(dinaupClient, new RowsRequestParameters(facturaId.STR()));
var factura = filas.FirstOrDefault();
// factura.MainRow.Propiedad...
foreach (var linea in factura.ListRows) { }
```
### Escritura [#escritura]
Las operaciones de escritura usan WriteOperation para altas y ediciones.
* El ID vacío ("") indica alta
* Un ID válido indica edición.
* Un ID que no existe provocará una excepción.
- **Alta simple (crear un registro)**
```csharp
Guid sectionId = /* sección destino */;
var data = new Dictionary
{
{
SeccionDePruebasAPIES.TextoPrincipal,
$"Prueba {Guid.NewGuid()}"
}
};
var wOp = new WriteOperation("", data); // "" => alta
// El sectionId es un Guid: usa _SectionIDGUID (no _SectionID, que es string)
await dinaupClient.RunWriteOperationAsync(SeccionDePruebasAPIES._SectionIDGUID, wOp, false);
// Lanza excepción si la operación falló o no se ejecutó
wOp.EnsureSuccess();
// Tras EnsureSuccess, WriteOperationResult está garantizado (no nulo)
Guid newId = wOp.WriteOperationResult.RowID;
```
- Edición (actualizar un registro existente)
```csharp
Guid rowId = /* Id del registro a editar */;
var data = new Dictionary
{
{
SeccionDePruebasAPIES.TextoPrincipal,
$"Prueba {Guid.NewGuid()}"
}
};
var wOp= new WriteOperation(rowId, data);
await dinaupClient.RunWriteOperationAsync(sectionId, wOp, false);
// Lanza excepción si la operación falló o no se ejecutó
wOp.EnsureSuccess();
Guid updatedId = wOp.WriteOperationResult.RowID;
```
- **Alta con líneas (cabecera + lista)**
En secciones con lista, añade cada línea como diccionario en `DataListRows`. Se guardan en la misma operación que la cabecera.
```csharp
var wOp = new WriteOperation("", data);
wOp.DataListRows.Add(new Dictionary
{
{ SeccionDePruebasAPIListaES.TextoPrincipal, "Línea 1" }
});
await dinaupClient.RunWriteOperationAsync(SeccionDePruebasAPIES._SectionIDGUID, wOp, false);
```
- **Editar, añadir o borrar líneas de un registro existente**
Las líneas se editan con el mismo `WriteOperation` de la cabecera. Cada línea de `DataListRows` lleva su `"id"`: el Guid de una línea existente la edita, vacío (o ausente) crea una nueva y `"eliminado"` a `"1"` la borra. Las líneas que no envías quedan como están.
```csharp
var wOp = new WriteOperation(rowId); // la cabecera, aunque no cambie ningún campo suyo
// Editar una línea: su id + los campos que cambian
wOp.DataListRows.Add(new Dictionary
{
{ "id", lineaId.ToString() },
{ SeccionDePruebasAPIListaES.TextoPrincipal, "Línea corregida" }
});
// Añadir una línea: id vacío
wOp.DataListRows.Add(new Dictionary
{
{ "id", "" },
{ SeccionDePruebasAPIListaES.TextoPrincipal, "Línea nueva" }
});
// Borrar una línea: su id + eliminado
wOp.DataListRows.Add(new Dictionary
{
{ "id", otraLineaId.ToString() },
{ "eliminado", "1" }
});
await dinaupClient.RunWriteOperationAsync(SeccionDePruebasAPIES._SectionIDGUID, wOp, false);
wOp.EnsureSuccess();
```
El SDK genera constantes también para la sección de lista (`SeccionDePruebasAPIListaES._SectionIDGUID`), pero escribir contra ella no está soportado: los scripts y cálculos viven en la sección principal. Las líneas viajan siempre en `DataListRows`. El detalle de este comportamiento, en [Escribir en secciones](/docs/desarrollo/dotnet/sdk/cliente/escritura-autorrellenado-y-scripts).
- **Editar un solo campo**
Para cambiar un valor sin montar el diccionario:
```csharp
await dinaupClient.RunInlineWriteOperationAsync(
SeccionDePruebasAPIES._SectionIDGUID, rowId,
SeccionDePruebasAPIES.TextoPrincipal, "Nuevo valor");
```
- **Relación por texto (selector dinámico)**
Si no tienes el Guid del registro relacionado, escribe `[Campo=Valor]` y el servidor lo resuelve buscando por ese campo.
```csharp
var data = new Dictionary
{
{ ProductosES.UnidadMedidaID, $"[{UnidadesMedidaES.TextoPrincipal}=Litros]" }
};
```
* **Alta 10 registros de golpe**
```csharp
var operaciones = new List();
for (int i = 0; i < 10; i++)
{
var fila = new Dictionary
{
{
SeccionDePruebasAPID.SeccionDePruebasAPIES.TextoPrincipal,
$"Lote {i}: {Guid.NewGuid()}"
}
};
operaciones.Add(new WriteOperation("", fila)); // alta
}
var batchAdd = await dinaupClient.RunWriteOperationAsync(sectionId, operaciones, false);
batchAdd.EnsureSuccess();
var ids = operaciones
.Where(o => o.WriteOperationResult != null)
.Select(o => o.WriteOperationResult.RowID)
.ToList();
```
* **Editar 10 registros**
```csharp
// Partiendo de la lista 'ids' creada en el ejemplo anterior
var operacionesEdicion = new List();
foreach (var id in ids)
{
var actualizado = new Dictionary
{
{
SeccionDePruebasAPID.SeccionDePruebasAPIES.TextoPrincipal,
$"Editado {DateTime.UtcNow.Ticks}"
}
};
operacionesEdicion.Add(new WriteOperation(id.ToString(), actualizado)); // edición
}
var batchEdit = await dinaupClient.RunWriteOperationAsync(sectionId, operacionesEdicion, false);
batchEdit.EnsureSuccess();
```
Cada llamada admite un máximo de 25 operaciones (`MaxItemsPerWriteOperation`). Si vas a procesar más, usa `.Chunk(25)` para dividir en bloques.
La escritura virtualizada permite que Dinaup ejecute la lógica de negocio definida en una sección. Al activarla, cualquier operación de escritura se comporta como si se hubiera realizado desde la interfaz web: con scripts, validaciones, eventos, y cálculos incluidos.
### ¿Qué hace la virtualización? [#qué-hace-la-virtualización]
Cuando se activa la virtualización en una operación de escritura (`RunWriteOperationAsync` con el tercer parámetro, ejecución de scripts, en `true`), Dinaup:
* Ejecuta scripts personalizados de la sección (`onBeforeSave`, `onAfterSave`, etc.)
* Recalcula campos automáticos (ej. totales, impuestos)
* Aplica reglas de validación y lógica de negocio
* Dispara eventos definidos en la sección
Cuando se desactiva (tercer parámetro en `false`), se guardan los valores tal como se reciben (creando histórico). **No se ejecuta ningún comportamiento adicional.**
La escritura virtualizada es más costosa en términos de rendimiento.\
Cada operación implica ejecutar scripts del backend y lógica personalizada, lo que puede afectar la velocidad si estás procesando muchos registros o usas esta opción innecesariamente.
### ¿Cuándo usar virtualización? [#cuándo-usar-virtualización]
Usa escritura virtualizada cuando la sección contiene lógica de negocio activa que debe ejecutarse. Esto incluye cálculos automáticos de totales en ventas, generación de fechas de vencimiento, o scripts que actualizan otras entidades relacionadas. Por ejemplo, al registrar una nueva venta, al cerrar un pedido o al generar una factura, la virtualización asegura que todo se procese correctamente.
### ¿Cuándo evitar virtualización? [#cuándo-evitar-virtualización]
Evita la virtualización cuando realizas modificaciones simples que no requieren ejecutar lógica adicional. Esto incluye acciones como cambiar el estado de una venta, asignar un técnico a un ticket de soporte, registrar una nota interna o marcar una tarea como completada. En estos casos, desactivarla mejora el rendimiento sin afectar el comportamiento esperado.
### Contexto de ejecución (atribuir operaciones a un usuario) [#contexto-de-ejecución-atribuir-operaciones-a-un-usuario]
Cuando la app conecta con credenciales de aplicación, las operaciones no tienen un usuario detrás. `DinaupContext.WithUser` establece uno para todo lo que ocurra dentro del bloque `using`: afecta al autor del alta, al histórico y a las anotaciones.
```csharp
// Solo userId
using (DinaupContext.WithUser(userId))
{
await dinaupClient.RunWriteOperationAsync(sectionId, wOp, false);
}
// Con IP y UserAgent del usuario final (quedan en el histórico)
using (DinaupContext.WithUser(userId, "192.168.1.1", "Mozilla/5.0..."))
{
await dinaupClient.RunWriteOperationAsync(sectionId, wOp, false);
}
```
El contexto es `AsyncLocal`: vale para el flujo async en curso y se restaura solo al salir del `using`.
### Fichajes (cronómetro) [#fichajes-cronómetro]
Los campos de tipo cronómetro registran tiempo sobre un registro: entrada, salida y latido de continuidad (fichajes de jornada, tiempo por tarea, etc.). Se operan con `Chronometer`, indicando el campo, el registro y la acción.
```csharp
Guid campoId = /* Id del campo cronómetro */;
Guid registroId = /* Id del registro (empleado, tarea…) */;
// Iniciar el fichaje
var inicio = dinaupClient.Chronometer(campoId, registroId, DinaupClientC.ChronometerActionE.actionStart);
// Latido periódico mientras el cronómetro corre
dinaupClient.Chronometer(campoId, registroId, DinaupClientC.ChronometerActionE.actionPing);
// Detener el fichaje
var fin = dinaupClient.Chronometer(campoId, registroId, DinaupClientC.ChronometerActionE.actionStop);
if (fin.Ok == false)
Console.WriteLine($"El fichaje no se registró: {fin.Description}");
```
Las tres acciones (`actionStart`, `actionPing`, `actionStop`) devuelven un `ChronometerResponse` con `Ok`, `Description`, `SuccessNotices` y `ErrorNotices`. `Chronometer` es síncrono.
# Funciones de agregación (/docs/desarrollo/flex/dinascript/funciones/agregacion)
Funciones del espacio `F.` que calculan sobre grupos de registros: totales, medias, primeros y últimos valores, rangos y recuentos de días. Todas las `Aggregate_*` ejecutan solo en [fórmulas de algoritmo](/docs/desarrollo/flex/algoritmos); las convenciones comunes (tipos, sufijos, contextos) están en el [índice de funciones](/docs/desarrollo/flex/dinascript/funciones).
## Contar, sumar y promediar [#contar-sumar-y-promediar]
Las variantes `Distinct` descartan los valores repetidos antes de calcular.
| Función | Parámetros | Devuelve | Qué hace |
| --------------------------- | ---------- | -------- | ------------------------------------------- |
| `Aggregate_Count` | (dato) | Entero | Número total de valores del grupo. |
| `Aggregate_CountDistinct` | (dato) | Entero | Número de valores distintos del grupo. |
| `Aggregate_Sum` | (dato) | Decimal | Suma todos los valores decimales del grupo. |
| `Aggregate_SumDistinct` | (dato) | Decimal | Suma los valores decimales distintos. |
| `Aggregate_Average` | (dato) | Decimal | Media de los valores decimales del grupo. |
| `Aggregate_AverageDistinct` | (dato) | Decimal | Media de los valores decimales distintos. |
## Concatenar texto [#concatenar-texto]
| Función | Parámetros | Devuelve | Qué hace |
| -------------------------- | ---------- | -------- | ------------------------------------------ |
| `Aggregate_Concat` | (dato) | Texto | Une todos los textos del grupo en uno. |
| `Aggregate_ConcatDistinct` | (dato) | Texto | Une los textos distintos del grupo en uno. |
## Máximo y mínimo del grupo [#máximo-y-mínimo-del-grupo]
Sin sufijo operan sobre decimales (`Aggregate_Max`); sufijos `Date`, `DateTime` y `Time` para fechas y horas (`Aggregate_MaxDate`…). Devuelven el tipo de su variante.
| Función | Parámetros | Devuelve | Qué hace |
| ---------------- | ---------- | -------------- | ------------------------- |
| `Aggregate_Max*` | (dato) | Según variante | Valor más alto del grupo. |
| `Aggregate_Min*` | (dato) | Según variante | Valor más bajo del grupo. |
## Primero, último y aleatorio [#primero-último-y-aleatorio]
Sin sufijo operan sobre texto (`Aggregate_First`); sufijos `Bool`, `Date`, `DateTime`, `Int`, `Numeric`, `Relation` y `Time` (`Aggregate_FirstDate`, `Aggregate_FirstNumeric`…). Cada variante devuelve su tipo; las `Bool` devuelven Entero (1/0).
| Función | Parámetros | Devuelve | Qué hace |
| ------------------- | ---------- | -------------- | --------------------------- |
| `Aggregate_First*` | (dato) | Según variante | Primer valor del grupo. |
| `Aggregate_Last*` | (dato) | Según variante | Último valor del grupo. |
| `Aggregate_Random*` | (dato) | Según variante | Un valor del grupo al azar. |
## Rango de valores [#rango-de-valores]
Sin sufijo opera sobre texto (`Aggregate_Range`); sufijos `Bool`, `Date`, `DateTime`, `Int`, `Numeric` y `Time`. No hay variante de relación. Todas devuelven un texto.
| Función | Parámetros | Devuelve | Qué hace |
| ------------------ | ---------- | -------- | -------------------------------------------- |
| `Aggregate_Range*` | (dato) | Texto | Rango del grupo, del valor mínimo al máximo. |
## Días dentro de un rango [#días-dentro-de-un-rango]
Reciben las dos fechas que delimitan el rango. Variantes `_DateTime` y `_Date` según el tipo del campo.
| Función | Parámetros | Devuelve | Qué hace |
| -------------------------------------- | -------------- | -------- | -------------------------------------------- |
| `Aggregate_CountDaysInRange_*` | (desde, hasta) | Entero | Días dentro del rango de fechas en el grupo. |
| `Aggregate_CountDistinctDaysInRange_*` | (desde, hasta) | Entero | Días distintos dentro del rango en el grupo. |
## Mínimo y máximo de dos valores [#mínimo-y-máximo-de-dos-valores]
No son agregados: comparan dos valores sueltos y devuelven uno. Variantes por tipo: `_Int`, `_Num`, `_Text`, `_Time`, `_Date` y `_DateTime`. Se pueden usar en cualquier contexto DinaScript, no solo en fórmulas de algoritmo.
`Aggregate_Max` devuelve el máximo de un grupo de registros; `Max_Num` devuelve el mayor de dos valores. No son intercambiables.
| Función | Parámetros | Devuelve | Qué hace |
| ------- | ------------- | -------------- | ---------------------------- |
| `Max_*` | (dato, dato2) | Según variante | El mayor de los dos valores. |
| `Min_*` | (dato, dato2) | Según variante | El menor de los dos valores. |
```javascript
@ Limita el descuento entre 0 y 100
num acotado = F.Max_Num(v.descuento, 0)
v.descuento = F.Min_Num(acotado, 100)
```
```javascript
@ El vencimiento nunca cae antes de la fecha de emisión
v.vencimiento = F.Max_Date(v.vencimiento, v.emision)
```
***
→ [Índice de funciones](/docs/desarrollo/flex/dinascript/funciones)
→ [Algoritmos](/docs/desarrollo/flex/algoritmos)
# Funciones de controles y listas (/docs/desarrollo/flex/dinascript/funciones/controles-y-listas)
Funciones del espacio `F.` para controlar los campos de un formulario (bloquear, obligar, avisar, sugerir valores) y para operar sobre su lista de registros. Todas ejecutan en scripts de formulario; no están disponibles en fórmulas de algoritmo. Las convenciones comunes (tipos de datos, valores sí/no) están en el [índice de funciones](/docs/desarrollo/flex/dinascript/funciones).
## Bloquear y limitar campos [#bloquear-y-limitar-campos]
Las funciones con parámetro `estado` activan la restricción con `true` y la retiran con `false`. El `motivo` se muestra al usuario cuando intenta saltarse el límite.
| Función | Parámetros | Devuelve | Qué hace |
| ------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- | ------------ | -------------------------------------------------------------- |
| `Field_SetLockedWithReason` | (campo, motivo, estado) | — | Bloquea o desbloquea el campo mostrando el motivo. |
| `Field_IsLocked` | (campo) | Entero (1/0) | El campo está bloqueado ahora mismo. |
| `Field_SetMinValueWithReason` / `Field_SetMaxValueWithReason` | (campo, motivo, valor, estado) | — | Impone un valor mínimo o máximo con su motivo. |
| `Field_ForcePositive` / `Field_ForceNegative` | (campo, activado) | — | El campo numérico solo acepta positivos o negativos. |
| `Field_IndirectQuantityLimit` | (campoRelación, campoCantidad, mínimo, máximo, campoLimitado, afectaPositivamente, motivo, activa) | — | Limita una cantidad según el rango de un registro relacionado. |
## Obligar, validar y avisar [#obligar-validar-y-avisar]
| Función | Parámetros | Devuelve | Qué hace |
| ----------------------------- | ----------------------- | ------------ | --------------------------------------------------------- |
| `Field_SetRequiredWithReason` | (campo, motivo, estado) | — | Marca el campo como obligatorio u opcional con su motivo. |
| `Field_IsRequired` | (campo) | Entero (1/0) | El campo es obligatorio ahora mismo. |
| `Field_SetWarningWithReason` | (campo, aviso, estado) | — | Pone o quita un aviso sobre el campo. |
| `Field_ListDropdownWarning` | (aviso, estado) | — | Pone o quita un aviso en la lista desplegable. |
| `CheckFillUnique` | (campo) | Entero (1/0) | El valor del campo no se repite en otros registros. |
```javascript
num esUnica = F.CheckFillUnique("REFERENCIA")
if esUnica = 0
F.Field_SetWarningWithReason("REFERENCIA", "Esta referencia ya existe", true)
F.Field_SetFocus("REFERENCIA", true)
end
```
## Leer y escribir valores [#leer-y-escribir-valores]
| Función | Parámetros | Devuelve | Qué hace |
| ------------------------------------------------------------ | -------------------------- | --------------- | -------------------------------------------------------------------- |
| `Field_Clear` | (campo) | — | Vacía el campo. |
| `Field_ResetToDefault` | (campo) | — | Devuelve el campo a su valor inicial. |
| `Field_SuggestValue` | (campo, sugerencia, clave) | — | Muestra un valor sugerido; la clave permite sustituirlo o retirarlo. |
| `Field_GetInitialTextValue` / `Field_GetInitialNumericValue` | (campo) | Texto / Decimal | Valor guardado del campo, antes de los cambios sin guardar. |
| `Field_GetUnsavedNumericDifference` | (campo) | Decimal | Diferencia entre el valor actual sin guardar y el guardado. |
| `Field_IsModified` | (campo) | Entero (1/0) | El campo ha cambiado desde que se cargó. |
| `Field_IsAffectedBetweenTicks` | (campo) | Entero (1/0) | El campo ha cambiado entre ticks de procesamiento. |
| `Field_RecalculateAlgorithm` | (campo) | — | Fuerza el recálculo del algoritmo asignado al campo. |
| `Field_UrlAssistantReadValue` | (campo, parámetro) | Texto | Lee un parámetro de un campo asistente de URL. |
```javascript
@ Avisa si el ajuste de stock se dispara respecto a lo guardado
num ajuste = F.Field_GetUnsavedNumericDifference("STOCK")
¿ajuste > 100 ? F.Field_SetWarningWithReason("STOCK", "Ajuste inusualmente grande", true)
```
## Etiquetas, foco y aspecto [#etiquetas-foco-y-aspecto]
| Función | Parámetros | Devuelve | Qué hace |
| ------------------------------ | --------------------------- | -------- | ----------------------------------------------------------------- |
| `Field_SetLabel` | (campo, etiqueta) | — | Cambia la etiqueta visible del campo. |
| `Field_SetExtraIdentifierText` | (campo, etiqueta) | — | Cambia el texto identificador extra del campo. |
| `Field_SetPlaceholder` | (campo, ejemplo) | — | Pone un texto de ejemplo en el campo vacío. |
| `Field_SetFocus` | (campo, seleccionar) | — | Lleva el cursor al campo, con opción de seleccionar su contenido. |
| `Field_CopyIconFromField` | (campoDestino, campoOrigen) | — | Copia el icono de un campo a otro. |
## Desplegables y autocompletado [#desplegables-y-autocompletado]
Las `Field_Dropdown*` sin parámetro de campo actúan sobre el desplegable que se está abriendo.
| Función | Parámetros | Devuelve | Qué hace |
| -------------------------------------------------- | -------------- | -------- | ------------------------------------------------------------ |
| `Field_DropdownApplyFilter` | (campo) | — | Filtra el desplegable según el valor de otro campo. |
| `Field_DropdownApplyAlternative` | () | — | Aplica una fuente de datos alternativa al desplegable. |
| `Field_DropdownApplySearchAlgorithm` | (algoritmo) | — | Aplica un algoritmo de búsqueda al desplegable. |
| `Field_DropdownAutoSelectFirst` | () | — | Selecciona automáticamente el primer elemento. |
| `Field_DropdownAutoSelectIfSingle` | () | — | Selecciona el elemento si el desplegable solo tiene uno. |
| `Field_DropdownCancel` | (motivo) | — | Cancela la apertura del desplegable y muestra el motivo. |
| `Field_DropdownClearFilters` | () | — | Quita todos los filtros aplicados al desplegable. |
| `Field_DropdownEnableFilterRemoval` | (títuloFiltro) | — | Ofrece al usuario quitar el filtro con ese título. |
| `Field_TextEnableCombo` / `Field_TextDisableCombo` | (campo) | — | Activa o desactiva el modo desplegable en un campo de texto. |
| `Field_TextAddAutoComplete` | (campo, valor) | — | Añade un valor memorizado al autocompletado del campo. |
| `Field_TextClearAutoComplete` | (campo) | — | Borra todos los valores memorizados del campo. |
## Relaciones [#relaciones]
| Función | Parámetros | Devuelve | Qué hace |
| ------------------------- | ----------------------- | -------- | ----------------------------------------------- |
| `AddRelation` | (campo, modoAutomático) | — | Añade una relación al campo indicado. |
| `Field_CopyOnAddRelation` | (campo, valor) | — | Copia un valor al campo al añadir una relación. |
`Field_CopyOnAddRelation` rellena campos, pero no los bloquea. Si la copia no debe modificarse, bloquea el campo de la sección de destino con `Field_SetLockedWithReason` en el script de esa sección.
## Precios, cronómetros y acciones [#precios-cronómetros-y-acciones]
| Función | Parámetros | Devuelve | Qué hace |
| ---------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- | -------- | -------------------------------------------------------------- |
| `RecalculatePrice4F` | (pvpSin, pvpCon, impuestosIncluidos, porcentajeImpuesto) | — | Recalcula PVP sin y con impuestos. |
| `RecalculatePrice5F` | (precio, pvpSin, pvpCon, impuestosIncluidos, porcentajeImpuesto) | — | Como la anterior, con campo de precio combinado. |
| `RecalculatePrice9F` | (precio, pvpSin, pvpCon, dtoFijo, dtoPorciento, subtotal, total, impuestosIncluidos, porcentajeImpuesto) | — | Versión completa: descuentos, subtotal y total. |
| `Field_StopwatchStart` / `Field_StopwatchStop` | (campo) | — | Arranca o para el cronómetro de un campo temporizador. |
| `Field_StopwatchState` | (campo) | Entero | Estado del cronómetro: en marcha o parado. |
| `TriggerClick` | (campo) | — | Dispara el clic de un campo botón. |
| `EnableReportCompatibilityAlgorithm` / `DisableReportCompatibilityAlgorithm` | () | — | Activa o desactiva el algoritmo de compatibilidad de informes. |
## Operar con la lista [#operar-con-la-lista]
Trabajan sobre la lista de registros del formulario: totales y recuentos por columna, y carga o vaciado de la lista completa.
| Función | Parámetros | Devuelve | Qué hace |
| ---------------------------- | ---------- | ------------ | ------------------------------------------------------------ |
| `Column_Sum` | (campo) | Decimal | Suma todos los valores de la columna. |
| `Column_CountFilled` | (campo) | Entero | Cuenta los valores no vacíos de la columna. |
| `Column_CountDistinct` | (campo) | Entero | Cuenta los valores distintos de la columna. |
| `Column_CountDistinctFilled` | (campo) | Entero | Cuenta los valores distintos no vacíos. |
| `Column_MaxValue_*` | (campo) | Según sufijo | Valor máximo de la columna. |
| `Column_MinValue_*` | (campo) | Según sufijo | Valor mínimo de la columna. |
| `CountItemList` | () | Entero | Número de elementos de la lista. |
| `List_Count` | () | Entero | Número de registros de la lista. |
| `List_Clear` | () | — | Vacía la lista: elimina todos los registros. |
| `LoadList` | () | Entero | Carga la lista (informe) y devuelve cuántos registros cargó. |
Los sufijos de `Column_MaxValue_*` y `Column_MinValue_*` (`_Numeric`, `_Int`, `_Text`, `_Time`, `_Date`, `_DateTime`) siguen la convención de familias tipadas del [índice de funciones](/docs/desarrollo/flex/dinascript/funciones).
```javascript
@ Un pedido sin importe necesita explicación
num total = F.Column_Sum("IMPORTE")
¿total = 0 ? F.Field_SetRequiredWithReason("MOTIVO", "Explica por qué el pedido va sin importe", true)
```
***
→ [Índice de funciones](/docs/desarrollo/flex/dinascript/funciones)
→ [Funciones de texto](/docs/desarrollo/flex/dinascript/funciones/texto)
# Funciones de datos y listados (/docs/desarrollo/flex/dinascript/funciones/datos-y-listados)
Funciones del espacio `F.` para trabajar con listados de datos: cargar un informe o una sección con filtros, orden y paginación, recorrer sus filas una a una y escribir los valores como celdas de tabla HTML. Las convenciones comunes (tipos de datos, valores sí/no, contextos) están en el [índice de funciones](/docs/desarrollo/flex/dinascript/funciones).
Todas las funciones de esta página ejecutan en formularios, en scripts independientes y vía API; no están disponibles en fórmulas de algoritmo. Salvo que se indique otra cosa, el primer parámetro es el GUID del informe o de la sección que alimenta el listado.
## Cargar un listado [#cargar-un-listado]
Carga datos desde un informe o una sección, con paginación, filtros y orden. Es la vía para recorrer registros existentes en lugar de construir una tabla a mano.
| Función | Parámetros | Devuelve | Qué hace |
| ---------------------------------- | -------------------------------------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
| `DataListLoad` | (listado, página, resultadosPorPágina) | Entero | Carga el listado: qué página y cuántos resultados por página. |
| `DataListLoadAddFilter` | (listado, campo, operador, valor) | — | Filtra por un campo del informe. Operadores: `=`, `<>`, `>`, `<`, `>=`, `<=`. Con `*` sobre un campo de fecha, el valor es un intervalo. |
| `DataListLoadAddFilterAlternative` | (listado) | — | Añade un criterio de filtrado alternativo al listado. |
| `DataListLoadSetOrder` | (listado, campo, descendente) | — | Ordena por un campo. El tercer parámetro activa el orden descendente. |
| `DataListLoadSelectedItems` | (listado) | Entero | Carga los elementos seleccionados del listado. |
| `DataListApplyDynamicAgruptaion` | (listado) | — | Aplica la agrupación dinámica al listado. |
El filtro se aplica sobre los campos del informe con los operadores de comparación. Para acumular o resumir lo que cargas (un total, una cuenta), recórrelo y combínalo con un [algoritmo](/docs/desarrollo/flex/algoritmos).
## Recorrer las filas [#recorrer-las-filas]
`ProcessDataList_Ini` abre el único bucle de datos de DinaScript: todo lo que escribas entre `ProcessDataList_Ini` y `ProcessDataList_End` se ejecuta una vez por cada fila del listado cargado. Dentro del bloque, las funciones de posición te dicen en qué fila estás.
| Función | Parámetros | Devuelve | Qué hace |
| ------------------------------------ | ---------- | ------------ | --------------------------------------------- |
| `ProcessDataList_Ini` | (keyword) | — | Inicia el recorrido del listado, fila a fila. |
| `ProcessDataList_End` | () | — | Cierra el recorrido. |
| `DataListCurrentRowPosition` | (listado) | Entero | Posición de la fila actual en el listado. |
| `DataListCurrentRowRelativePosition` | (listado) | Entero | Posición relativa de la fila actual. |
| `DataListIsFirstRow` | (listado) | Entero (1/0) | La fila actual es la primera. |
| `DataListIsLastRow` | (listado) | Entero (1/0) | La fila actual es la última. |
```javascript
@ Carga la primera página del informe de ventas: 200 filas por página
F.DataListLoad(v.informeVentas, 1, 200)
F.DataListLoadAddFilter(v.informeVentas, "estado", "=", "pendiente")
F.DataListLoadSetOrder(v.informeVentas, "fecha", true)
num filas = 0
F.ProcessDataList_Ini("ventas")
@ Este bloque se ejecuta una vez por cada fila del listado
v.filas = v.filas + 1
¿F.DataListIsLastRow(v.informeVentas) = 1 ? v.estado = "Recorrido completo"
F.ProcessDataList_End()
```
## Información del listado [#información-del-listado]
Tras cargar, consulta el tamaño y la posición del listado para paginar o decidir si sigues cargando páginas.
| Función | Parámetros | Devuelve | Qué hace |
| ------------------------ | ---------- | -------- | ----------------------------------- |
| `DataListCountResults` | (listado) | Entero | Total de resultados. |
| `DataListCountPages` | (listado) | Entero | Total de páginas. |
| `DataListCountFilled` | (listado) | Entero | Número de filas rellenadas. |
| `DataListCurrentPage` | (listado) | Entero | Página actual. |
| `DataListResultsPerPage` | (listado) | Entero | Resultados por página configurados. |
## Escribir celdas de tabla HTML [#escribir-celdas-de-tabla-html]
Vuelcan un valor como celda de una tabla HTML, cada una con su formato. `WriteTD` no escapa el HTML: úsala solo con contenido que controlas; para texto libre, `WriteTDText`.
| Función | Parámetros | Devuelve | Qué hace |
| ------------------- | -------------------- | -------- | ----------------------------------------------------------- |
| `WriteTD` | (texto) | — | Escribe el texto en la celda sin escapar HTML. |
| `WriteTDText` | (texto) | — | Texto plano: conserva saltos de línea y no interpreta HTML. |
| `WriteTDMoney` | (importe, decimales) | — | Importe con formato de moneda. |
| `WriteTDNum` | (valor, decimales) | — | Número con formato y los decimales indicados. |
| `WriteTDPercentage` | (valor, decimales) | — | Porcentaje formateado. |
## Localizar registros por ID [#localizar-registros-por-id]
Convierten un ID legible en el GUID interno del registro o del archivo, para usarlo después como relación.
| Función | Parámetros | Devuelve | Qué hace |
| ------------- | ------------- | --------------- | -------------------------------------------- |
| `GetRowById` | (sección, id) | Relación (GUID) | GUID del registro de esa sección con ese ID. |
| `GetFileById` | (id) | Relación (GUID) | GUID del archivo con ese ID. |
***
→ [Índice de funciones](/docs/desarrollo/flex/dinascript/funciones)
→ [Informes](/docs/desarrollo/flex/informes)
→ [Algoritmos](/docs/desarrollo/flex/algoritmos)
# Funciones de documentos y gráficos (/docs/desarrollo/flex/dinascript/funciones/documentos-y-graficos)
Funciones del espacio `F.` para componer la salida de un documento: tablas en memoria, escritura en el flujo de salida, URLs firmadas de archivos, gráficos y mapas. Se usan sobre todo en [documentos dinámicos](/docs/desarrollo/flex/documentos-dinamicos); ninguna vale en fórmulas de algoritmo, y las convenciones comunes están en el [índice de funciones](/docs/desarrollo/flex/dinascript/funciones).
## Tablas en memoria [#tablas-en-memoria]
Tablas que construyes a mano cuando el resultado no sale directo de una sección: creas la tabla, añades filas y rellenas celdas tipadas (el tipo condiciona cómo se formatea y exporta el valor). Funcionan en scripts independientes y en documentos dinámicos; para recorrer registros que ya existen usa [datos y listados](/docs/desarrollo/flex/dinascript/funciones/datos-y-listados).
| Función | Parámetros | Devuelve | Qué hace |
| ------------------------------ | ----------------------- | -------- | ------------------------------------------------------ |
| `DataTable_New` | () | Entero | Crea una tabla en memoria y devuelve su identificador. |
| `DataTable_AddRow` | (tabla) | Entero | Añade una fila y devuelve su índice. |
| `DataTable_SetValue` | (tabla, columna, valor) | — | Escribe un valor en una celda. |
| `DataTable_SetValueText` | (tabla, columna, valor) | — | Escribe texto escapando el HTML. |
| `DataTable_SetValueInt` | (tabla, columna, valor) | — | Escribe un entero. |
| `DataTable_SetValueNum` | (tabla, columna, valor) | — | Escribe un decimal. |
| `DataTable_SetValueMoney` | (tabla, columna, valor) | — | Escribe un importe monetario. |
| `DataTable_SetValuePercentage` | (tabla, columna, valor) | — | Escribe un porcentaje. |
| `DataTable_SetValueBool` | (tabla, columna, valor) | — | Escribe un valor sí/no. |
| `DataTable_SetValueDate` | (tabla, columna, valor) | — | Escribe una fecha y ajusta el formato de la columna. |
| `DataTable_SetValueDateTime` | (tabla, columna, valor) | — | Escribe una fecha y hora. |
| `DataTable_SetValueTime` | (tabla, columna, valor) | — | Escribe una hora. |
```javascript
num tabla = F.DataTable_New()
F.DataTable_AddRow(tabla)
F.DataTable_SetValueText(tabla, "Cliente", "Talleres Ruiz")
F.DataTable_SetValueMoney(tabla, "Importe", 1250.50)
txt html = F.DataTable_Build(tabla, "HTML")
```
## Columnas de la tabla [#columnas-de-la-tabla]
| Función | Parámetros | Devuelve | Qué hace |
| --------------------------------- | ------------------------- | -------- | ------------------------------------------------------------------------------ |
| `DataTable_ColumnSetFormat` | (tabla, columna, formato) | — | Asigna el formato de una columna. |
| `DataTable_ColumnSetRole` | (tabla, columna, rol) | — | Asigna el [rol de campo](/docs/desarrollo/flex/roles-de-campo) de una columna. |
| `DataTable_ColumnDelete` | (tabla, columna) | — | Elimina una columna. |
| `DataTable_ColumnDeleteIfIsEmpty` | (tabla, columna) | — | Elimina la columna solo si está vacía. |
## Volcar la tabla [#volcar-la-tabla]
| Función | Parámetros | Devuelve | Qué hace |
| ------------------ | ------------------- | -------- | ------------------------------------------------------------------------- |
| `DataTable_Build` | (tabla, formato) | Texto | Devuelve la tabla como texto: `JSONARRAY`, `JSON`, `HTML`, `CSV` o `XML`. |
| `DataTable_Export` | (tabla, formato) | — | Genera un archivo, preguntando al usuario formato y destino. |
| `DataTable_Import` | (tabla, silencioso) | — | Abre el importador de datos; detecta el informe por los ID de columna. |
`Build` funciona en scripts independientes y documentos dinámicos. `Export` e `Import` solo en el terminal, desde scripts de formulario o independientes.
## Escribir en el documento de salida [#escribir-en-el-documento-de-salida]
En documentos dinámicos y funciones API el resultado se construye escribiendo en un flujo de salida. Estas funciones solo ejecutan ahí.
| Función | Parámetros | Devuelve | Qué hace |
| ----------------- | -------------------------- | -------- | ------------------------------------------------------------------- |
| `Write` | (contenido) | — | Escribe contenido en bruto en la salida. |
| `WriteText` | (texto) | — | Escribe texto plano: conserva saltos de línea y no interpreta HTML. |
| `WriteBool` | (valor, textoSí, textoNo) | — | Escribe un sí/no con el texto que elijas para cada estado. |
| `WriteDate` | (fecha, formato) | — | Escribe una fecha con el formato indicado. |
| `WriteDateTime` | (valor, formato) | — | Escribe una fecha y hora con el formato indicado. |
| `WriteMoney` | (importe, máximoDecimales) | — | Escribe un importe como moneda con N decimales. |
| `WriteNum` | (valor, máximoDecimales) | — | Escribe un número con N decimales. |
| `WritePercentage` | (valor, máximoDecimales) | — | Escribe un porcentaje con N decimales. |
| `RemoveLastWrite` | () | — | Elimina el último elemento escrito en la salida. |
```javascript
F.Write("
Cualquiera con la URL accede al archivo sin autenticarse mientras dure la validez. Ajusta los segundos al mínimo que necesites.
## Gráficos [#gráficos]
Montas el gráfico por código y lo vuelcas a HTML para incrustarlo en el documento. Cada serie y valor lleva dos colores: uno para el tema claro y otro para el oscuro. Los gráficos y los mapas funcionan en scripts de formulario, scripts independientes y documentos dinámicos.
| Función | Parámetros | Devuelve | Qué hace |
| ---------------- | --------------------------------------------------- | -------- | ------------------------------------------------------------- |
| `Chart_New` | (título) | Entero | Crea un gráfico y devuelve su identificador. |
| `Chart_AddSerie` | (gráfico, etiqueta, colorClaro, colorOscuro) | — | Añade una serie de datos con sus colores. |
| `Chart_AddValue` | (gráfico, etiqueta, valor, colorClaro, colorOscuro) | — | Añade un valor etiquetado con sus colores. |
| `Chart_ToHTML` | (gráfico, tipo, ancho, alto) | Texto | Devuelve el gráfico como HTML con el tipo y tamaño indicados. |
```javascript
num grafico = F.Chart_New("Ventas del trimestre")
F.Chart_AddValue(grafico, "Enero", 1200, "#2e86c1", "#5dade2")
F.Chart_AddValue(grafico, "Febrero", 1550, "#28b463", "#58d68d")
txt html = F.Chart_ToHTML(grafico, 1, 800, 400)
F.Write(html)
```
## Mapas [#mapas]
| Función | Parámetros | Devuelve | Qué hace |
| ------------------------ | ------------------------------------------------------- | -------- | ----------------------------------------------------------------- |
| `Maps_New` | (título) | Entero | Crea un mapa y devuelve su identificador. |
| `Maps_AddPoint` | (mapa, título, icono, ubicación) | — | Añade un punto con etiqueta e icono en las coordenadas indicadas. |
| `Maps_AddClickablePoint` | (mapa, título, icono, ubicación, secciónId, registroId) | — | Punto que al pulsarlo abre un registro de una sección. |
| `Maps_ToHTML` | (mapa, coordenadasIniciales, zoomInicial) | — | Renderiza el mapa como HTML con el centro y zoom iniciales. |
***
→ [Índice de funciones](/docs/desarrollo/flex/dinascript/funciones)
→ [Documentos dinámicos](/docs/desarrollo/flex/documentos-dinamicos)
→ [Funciones de datos y listados](/docs/desarrollo/flex/dinascript/funciones/datos-y-listados)
# Funciones de fecha y hora (/docs/desarrollo/flex/dinascript/funciones/fecha-y-hora)
Funciones del espacio `F.` para trabajar con fechas, horas y periodos: montar y descomponer valores, desplazarlos en el tiempo, medir la distancia entre dos instantes y compararlos con el momento actual. Las convenciones comunes (tipos, sufijos, contextos) están en el [índice de funciones](/docs/desarrollo/flex/dinascript/funciones).
Las funciones de «Sumar y restar» y las `GoTo` no ejecutan en fórmulas de algoritmo; el resto de la página sí, salvo las excepciones que marca cada sección.
## Construir fechas y horas [#construir-fechas-y-horas]
| Función | Parámetros | Devuelve | Qué hace |
| ----------------------- | --------------------------------- | ------------ | -------------------------------------------------------- |
| `BuildDate` | (año, mes, día) | Fecha | Monta una fecha desde sus tres componentes. |
| `BuildDateTime` | (año, mes, día, hora, minutos) | Fecha y hora | Monta una fecha y hora desde sus componentes. |
| `BuildTime` | (hora, minutos, segundos) | Hora | Monta una hora desde sus componentes. |
| `AddTimeToDate` | (fecha, tiempo) | Fecha y hora | Combina una fecha con un valor de hora. |
| `AddDetailedTimeToDate` | (fecha, horas, minutos, segundos) | Fecha y hora | Combina una fecha con horas, minutos y segundos sueltos. |
```javascript
@ Fecha del formulario con hora fija
v.cita = F.AddTimeToDate(v.fechaVisita, F.BuildTime(9, 30, 0))
@ cita vale la fecha de la visita a las 9:30:00
```
## Extraer componentes [#extraer-componentes]
| Función | Parámetros | Devuelve | Qué hace |
| ------------------------- | ------------ | -------- | ------------------------------------ |
| `Date_FromDatetime` | (fechaYHora) | Fecha | Parte de fecha de un valor con hora. |
| `DalteLocal_FromDatetime` | (fechaYHora) | Fecha | Parte de fecha en hora local. |
| `Time` | (fechaYHora) | Hora | Parte de hora de un valor con fecha. |
| `Year` | (fecha) | Entero | Año de la fecha. |
| `Month` | (fecha) | Entero | Número de mes (1-12). |
| `Day` | (fecha) | Entero | Día del mes. |
| `Hour` | (hora) | Entero | Hora de un valor de tipo Hora. |
| `Minute` | (hora) | Entero | Minutos de un valor de tipo Hora. |
Todas valen en fórmulas de algoritmo salvo `DalteLocal_FromDatetime`.
## Sumar y restar [#sumar-y-restar]
Cada función devuelve el mismo tipo que recibe: `Date_` una Fecha, `DateTime_` una Fecha y hora, `Time_` una Hora.
| Función | Parámetros | Devuelve | Qué hace |
| --------------------------------------------------- | ---------------- | -------------------- | -------------------------------------------------- |
| `Date_AddDays` / `DateTime_AddDays` | (fecha, días) | Fecha · Fecha y hora | Suma días. |
| `Date_AddMonths` / `DateTime_AddMonths` | (fecha, meses) | Fecha · Fecha y hora | Suma meses. |
| `Date_AddYears` / `DateTime_AddYears` | (fecha, años) | Fecha · Fecha y hora | Suma años. |
| `DateTime_AddHours` / `Time_AddHours` | (valor, horas) | Fecha y hora · Hora | Suma horas; un valor decimal se redondea a entero. |
| `DateTime_AddMinutes` / `Time_AddMinutes` | (valor, minutos) | Fecha y hora · Hora | Suma minutos; admite decimales. |
| `Date_SubtractDays` / `DateTime_SubtractDays` | (fecha, días) | Fecha · Fecha y hora | Resta días. |
| `Date_SubtractMonths` / `DateTime_SubtractMonths` | (fecha, meses) | Fecha · Fecha y hora | Resta meses. |
| `Date_SubtractYears` / `DateTime_SubtractYears` | (fecha, años) | Fecha · Fecha y hora | Resta años. |
| `DateTime_SubtractHours` / `Time_SubtractHours` | (valor, horas) | Fecha y hora · Hora | Resta horas. |
| `DateTime_SubtractMinutes` / `Time_SubtractMinutes` | (valor, minutos) | Fecha y hora · Hora | Resta minutos. |
```javascript
@ Vencimiento a 30 días y aviso una semana antes
v.vencimiento = F.Date_AddDays(v.fechaFactura, 30)
v.aviso = F.Date_SubtractDays(v.vencimiento, 7)
```
## Funciones GoTo: cambiar componentes y saltar de periodo [#funciones-goto-cambiar-componentes-y-saltar-de-periodo]
Mueven una fecha a un punto concreto del calendario. Para cambiar un componente suelto:
| Función | Parámetros | Devuelve | Qué hace |
| ------------------------------------------- | ----------------------- | -------------------- | ---------------------------------------------------------- |
| `Date_GoToDay` / `DateTime_GoToDay` | (valor, nuevoDía) | Fecha · Fecha y hora | Cambia el día; si el mes no llega, salta al mes siguiente. |
| `Date_GoToMonth` / `DateTime_GoToMonth` | (valor, nuevoMes) | Fecha · Fecha y hora | Cambia el mes. |
| `Date_GoToYear` / `DateTime_GoToYear` | (valor, nuevoAño) | Fecha · Fecha y hora | Cambia el año. |
| `DateTime_GoToHour` / `Time_GoToHour` | (valor, nuevaHora) | Fecha y hora · Hora | Cambia la hora. |
| `DateTime_GoToMinutes` / `Time_GoToMinutes` | (valor, nuevosMinutos) | Fecha y hora · Hora | Cambia los minutos. |
| `DateTime_GoToSeconds` / `Time_GoToSeconds` | (valor, nuevosSegundos) | Fecha y hora · Hora | Cambia los segundos. |
| `DateTime_GoToDate` | (fechaYHora, fecha) | Fecha y hora | Sustituye la parte de fecha conservando la hora. |
| `DateTime_GoToTime` | (fechaYHora, hora) | Fecha y hora | Sustituye la parte de hora conservando la fecha. |
Para saltar al inicio o al final de un periodo. La tabla muestra la variante `Date_`, que recibe Fecha; cambia el prefijo a `DateTime_` para la que recibe Fecha y hora.
| Función | Parámetros | Devuelve | Qué hace |
| ------------------------------------------------------- | ---------- | ------------ | ------------------------------------------------ |
| `Date_GoToStartDay` / `Date_GoToEndDay` | (fecha) | Fecha y hora | Inicio o final del día. |
| `Date_GoToStartWeekMonday` / `Date_GotoEndSunday` | (fecha) | Fecha y hora | Lunes al inicio o domingo al final de la semana. |
| `Date_GoToStartOfFortnight` / `Date_GoToEndOfFortnight` | (fecha) | Fecha y hora | Inicio o final de la quincena. |
| `Date_GoToStartOfMonth` / `Date_GoToEndOfMonth` | (fecha) | Fecha y hora | Primer o último día del mes. |
| `Date_GoToStartOfQuarter` / `Date_GoToEndQuarter` | (fecha) | Fecha y hora | Inicio o final del trimestre. |
| `Date_GoToStartSemester` / `Date_GoToEndSemester` | (fecha) | Fecha y hora | Inicio o final del semestre. |
| `Date_GoToStartYear` / `Date_GoToEndYear` | (fecha) | Fecha y hora | 1 de enero o 31 de diciembre del año. |
Las variantes `Date_` de esta tabla también devuelven **Fecha y hora**, no Fecha: apuntan a un instante concreto, como las 23:59:59 del último día del periodo.
```javascript
@ Límites del mes de la fecha del pedido
v.desde = F.Date_GoToStartOfMonth(v.fechaPedido)
v.hasta = F.Date_GoToEndOfMonth(v.fechaPedido)
@ hasta apunta al último día del mes a las 23:59:59
```
## Diferencias entre fechas [#diferencias-entre-fechas]
| Función | Parámetros | Devuelve | Qué hace |
| --------------------------------------- | -------------------------------------- | -------- | --------------------------------------------------------------------------------- |
| `DaysDifferenceBetweenDates` | (primeraFecha, segundaFecha) | Entero | Días entre dos fechas; positivo si la segunda es posterior. |
| `MinutesDifferenceBetweenDates` | (primeraFecha, segundaFecha) | Entero | Minutos entre dos fechas. |
| `MinutesDifferenceBetweenDatesAndTimes` | (primeraFechaYHora, segundaFechaYHora) | Entero | Minutos entre dos valores de fecha y hora. |
| `MinutesDifferenceBetweenTimes` | (primeraHora, segundaHora) | Entero | Minutos entre dos horas. |
| `SecondsDifferenceBetweenDatesAndTimes` | (primeraFechaYHora, segundaFechaYHora) | Entero | Segundos entre dos valores de fecha y hora. |
| `SecondsDifferenceBetweenTimes` | (primeraHora, segundaHora) | Entero | Segundos entre dos horas. |
| `CalculateAge` | (primeraFecha, segundaFecha) | Entero | Edad en años entre dos fechas. |
| `CalculateAge_WithDateTime` | (primeraFechaYHora, segundaFechaYHora) | Entero | Edad en años entre dos valores de fecha y hora. |
| `CalculateSeniorityDate` | (fechaAntigüedad, modoAntigüedad) | Fecha | Fecha de referencia de antigüedad según el modo (inicio de mes, trimestre o año). |
Todas valen en fórmulas de algoritmo salvo `CalculateSeniorityDate`.
## Semana y calendario [#semana-y-calendario]
| Función | Parámetros | Devuelve | Qué hace |
| -------------------------- | ------------------------- | ------------ | -------------------------------------------------------------- |
| `DayOfWeek` | (fecha) | Entero | Día de la semana: 1=lunes … 7=domingo. |
| `NameDayOfWeek_FromDate` | (fecha) | Texto | Nombre del día de la semana. |
| `NameDayOfWeek_FromNumber` | (díaSemana) | Texto | Nombre del día desde su número (1=lunes … 7=domingo). |
| `MonthName_FromDate` | (fecha) | Texto | Nombre del mes de la fecha. |
| `MonthName_FromInt` | (mes) | Texto | Nombre del mes desde su número (1-12). |
| `WeekOfMonth` | (fecha) | Entero | Semana del mes (1-5). |
| `Fortnight` | (fecha) | Entero | Quincena (1 o 2); el corte es el día 15. |
| `Bimester` | (fecha) | Entero | Bimestre del año (1-6). |
| `Quarter` | (fecha) | Entero | Trimestre del año (1-4). |
| `Semester` | (fecha) | Entero | Semestre del año (1 o 2). |
| `DaysInMonth_FromDate` | (fecha) | Entero | Días que tiene el mes de la fecha. |
| `DaysInMonth_FromNumber` | (año, mes) | Entero | Días que tiene un mes dado por año y número. |
| `IsLeapYear_FromDate` | (fecha) | Entero (1/0) | El año de la fecha es bisiesto. |
| `IsLeapYear_FromNumber` | (año) | Entero (1/0) | El año es bisiesto. |
| `IsQuarter` | (fecha, trimestre) | Entero (1/0) | La fecha cae en el trimestre indicado. |
| `IsYear` | (fecha, año) | Entero (1/0) | La fecha cae en el año indicado. |
| `CountWeeklyDaysInRange` | (desde, hasta, díaSemana) | Entero | Cuenta cuántas veces cae un día de la semana entre dos fechas. |
Todas valen en fórmulas de algoritmo salvo `CountWeeklyDaysInRange`.
## Eventos respecto al momento actual [#eventos-respecto-al-momento-actual]
Comprueban dónde cae un evento respecto a ahora y devuelven Entero (`1`/`0`), listas para usar en condiciones. Cada familia existe en cinco unidades (cambia `Days` por `Hours`, `Minutes`, `Months` o `Years` en el nombre) y con sufijo de tipo: `_Date` y `_DateTime` para días, meses y años; `_Time` y `_DateTime` para horas y minutos. La leyenda de sufijos está en el [índice de funciones](/docs/desarrollo/flex/dinascript/funciones).
| Función | Parámetros | Devuelve | Qué hace |
| -------------------------------------------- | ------------------ | ------------ | -------------------------------------------------------- |
| `EventStartedLessThanXDaysAgo_*` | (valor, intervalo) | Entero (1/0) | El evento ocurrió hace menos de N días. |
| `EventStartedMoreThanXDaysAgo_*` | (valor, intervalo) | Entero (1/0) | El evento ocurrió hace más de N días. |
| `EventStartsInLessThanXDays_*` | (valor, intervalo) | Entero (1/0) | El evento llega dentro de los próximos N días. |
| `EventStartsInMoreThanXDays_*` | (valor, intervalo) | Entero (1/0) | El evento está a más de N días vista. |
| `EventStartedOrEventStartsInLessThanXDays_*` | (valor, intervalo) | Entero (1/0) | El evento ocurrió o llega dentro de un margen de N días. |
```javascript
@ Clasificar clientes por su última compra
¿F.EventStartedMoreThanXMonthsAgo_Date(v.ultimaCompra, 6) = 1 ? v.estado = "Inactivo"
¿F.EventStartedLessThanXDaysAgo_Date(v.ultimaCompra, 30) = 1 ? v.estado = "Activo"
```
## Rangos dinámicos e intervalos [#rangos-dinámicos-e-intervalos]
Comprueban valores contra rangos dinámicos e intervalos definidos en tu cuenta, y obtienen sus fechas límite.
| Función | Parámetros | Devuelve | Qué hace |
| --------------------------- | ------------------------ | ------------ | --------------------------------------------------------------------------------- |
| `InDynamicRange_*` | (valor, intervalo) | Entero (1/0) | El valor cae dentro del rango dinámico. Sufijos `_Date` y `_DateTime`. |
| `InRange_DateTime_DateOnly` | (fechaYHora, intervalo) | Fecha y hora | Comprueba si el valor cae en el intervalo, comparando solo la fecha. |
| `IntervalStartDate_*` | (intervalo) | Según sufijo | Fecha de inicio del intervalo, como Fecha (`_Date`) o Fecha y hora (`_DateTime`). |
| `IntervalEndDate_*` | (intervalo) | Según sufijo | Fecha de fin del intervalo. |
| `IsInInterval_*` | (valor, intervaloRápido) | Entero (1/0) | El valor cae dentro del intervalo rápido indicado. Sufijos `_Date` y `_DateTime`. |
Todas valen en fórmulas de algoritmo; `IsInInterval_*` no está disponible en funciones API.
***
→ [Índice de funciones](/docs/desarrollo/flex/dinascript/funciones)
→ [Algoritmos](/docs/desarrollo/flex/algoritmos)
→ [DinaScript](/docs/desarrollo/flex/dinascript)
# Funciones (espacio F.) (/docs/desarrollo/flex/dinascript/funciones)
El espacio **`F.`** reúne todas las funciones de DinaScript. Llamas a cualquiera anteponiendo `F.` al nombre y, si devuelve un valor, lo asignas a una variable.
```javascript
txt etiqueta = F.Concat2("Pedido ", "1024")
num total = F.Round(1250.505, 2)
```
## Categorías [#categorías]
| Página | Qué encuentras |
| ----------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ |
| [Texto](/docs/desarrollo/flex/dinascript/funciones/texto) | Combinar, buscar, trocear y formatear texto. Diccionarios en memoria, JSON y NIF. |
| [Fecha y hora](/docs/desarrollo/flex/dinascript/funciones/fecha-y-hora) | Construir fechas, sumar periodos, saltar a inicios de mes, diferencias e intervalos. |
| [Lógica y comparación](/docs/desarrollo/flex/dinascript/funciones/logica-y-comparacion) | Condiciones en línea: If, Case y comparaciones tipadas. |
| [Matemáticas y conversión](/docs/desarrollo/flex/dinascript/funciones/matematicas-y-conversion) | Redondeo, porcentajes, signo y conversión entre tipos. |
| [Agregación](/docs/desarrollo/flex/dinascript/funciones/agregacion) | Sumas, cuentas, medias y extremos sobre grupos de registros, para fórmulas de algoritmo. |
| [Datos y listados](/docs/desarrollo/flex/dinascript/funciones/datos-y-listados) | Cargar registros de un informe o sección y recorrerlos con filtros, orden y paginación. |
| [Interacción y formulario](/docs/desarrollo/flex/dinascript/funciones/interaccion-y-formulario) | Mensajes, preguntas al usuario, abrir recursos y actuar sobre el formulario abierto. |
| [Controles y listas](/docs/desarrollo/flex/dinascript/funciones/controles-y-listas) | Bloquear, ocultar, obligar y colorear campos; operar con el grid del formulario. |
| [Documentos y gráficos](/docs/desarrollo/flex/dinascript/funciones/documentos-y-graficos) | Tablas en memoria, escritura al documento de salida, URLs firmadas de archivos y gráficos. |
| [Sistema y seguridad](/docs/desarrollo/flex/dinascript/funciones/sistema-y-seguridad) | Crear y modificar registros por script, peticiones HTTP, hashes, QR, TOTP y contabilidad. |
## Tipos de datos [#tipos-de-datos]
Las firmas de cada función usan estos tipos:
| Tipo | Qué es |
| --------------------------- | -------------------------------------------- |
| Texto | Cadena de caracteres, entre comillas dobles. |
| Entero | Número sin decimales. |
| Decimal | Número con decimales. |
| Sí/No | Booleano: `true` o `false`. |
| Fecha · Hora · Fecha y hora | Valores temporales. |
| Relación (GUID) | Identificador de un registro. |
Muchas funciones de comprobación devuelven **Entero (1/0)**: `1` si se cumple, `0` si no. Se usan directo en condiciones.
## Familias tipadas [#familias-tipadas]
Cuando una operación existe para varios tipos, la función se repite con un sufijo por tipo y en la referencia aparece como `Nombre_*`:
| Sufijo | Tipo |
| ----------- | --------------- |
| `_Text` | Texto |
| `_Int` | Entero |
| `_Num` | Decimal |
| `_Bool` | Sí/No |
| `_Date` | Fecha |
| `_DateTime` | Fecha y hora |
| `_Time` | Hora |
| `_Relation` | Relación (GUID) |
Ejemplo: `Case2_*` existe como `Case2_Text`, `Case2_Int`, `Case2_Num`, `Case2_Date`, `Case2_DateTime` y `Case2_Time`. Elige la variante del tipo que devuelve.
## Dónde ejecuta cada función [#dónde-ejecuta-cada-función]
No todas las funciones valen en todos los contextos. Los cuatro hábitats:
* **Fórmulas de algoritmo**: cálculos sobre tus datos. Ver [algoritmos](/docs/desarrollo/flex/algoritmos).
* **Scripts de formulario**: reaccionan a eventos de la ventana en la aplicación. Ver [scripts](/docs/desarrollo/flex/scripts).
* **Scripts independientes**: se lanzan a demanda, sin formulario abierto.
* **Documentos dinámicos y funciones API**: generan salida HTML, JSON o archivos. Ver [documentos dinámicos](/docs/desarrollo/flex/documentos-dinamicos).
Cada página de categoría indica el contexto cuando importa: por ejemplo, las funciones de controles solo tienen sentido con un formulario abierto, y las de agregación solo dentro de un algoritmo.
***
→ [Índice de DinaScript](/docs/desarrollo/flex/dinascript)
→ [Espacio de nombres S. (Schema)](/docs/desarrollo/flex/dinascript/s.-espacio-de-nombre-schema)
# Funciones de interacción y formulario (/docs/desarrollo/flex/dinascript/funciones/interaccion-y-formulario)
Funciones del espacio `F.` para dialogar con el usuario (mensajes, preguntas, abrir informes y formularios) y para actuar sobre el formulario abierto: guardar, disparar scripts, dar altas. Ejecutan en scripts del Terminal (de formulario o independientes), no en fórmulas de algoritmo; las convenciones comunes están en el [índice de funciones](/docs/desarrollo/flex/dinascript/funciones).
## Mensajes y confirmaciones [#mensajes-y-confirmaciones]
El parámetro `acciónRest` indica la acción a aplicar cuando el script se ejecuta en emulación REST.
| Función | Parámetros | Devuelve | Qué hace |
| ------------------- | ------------------------------ | ------------ | ------------------------------------------------------ |
| `MsgBox` | (texto, acciónRest) | — | Muestra un mensaje al usuario. |
| `PromptYesNo` | (título, pregunta, acciónRest) | Entero (1/0) | Pregunta Sí/No: devuelve `1` Sí, `0` No. |
| `PromptYesNoCancel` | (título, pregunta, acciónRest) | Entero | Pregunta Sí/No/Cancelar: `1` Sí, `0` No, `2` Cancelar. |
```javascript
num confirmar = F.PromptYesNo("Facturación", "¿Generar la factura?", 0)
¿v.confirmar = 0 ? F.CancelEvent()
```
## Pedir datos al usuario [#pedir-datos-al-usuario]
| Función | Parámetros | Devuelve | Qué hace |
| ------------------------------ | ------------------------------------- | --------------- | ------------------------------------------------------------------------- |
| `PromptDecimalNumber` | (título, pregunta) | Decimal | Pide un número decimal y lo devuelve. |
| `PromptIntegerNumber` | (título, pregunta) | Entero | Pide un número entero y lo devuelve. |
| `PromptRecord` | (título, pregunta, sección) | Texto | Pide elegir un registro de la sección; devuelve su identificador. |
| `PromptRecordFromLoadedReport` | (título, pregunta, informeIdOSección) | Relación (GUID) | Pide elegir un registro de un informe cargado; devuelve su identificador. |
```javascript
num total = F.PromptDecimalNumber("Caja", "Importe contado al cierre")
F.MsgBox(F.Concat("Contado: ", F.FormatMoney(v.total)), 0)
```
## Abrir recursos [#abrir-recursos]
Abren un recurso de Dinaup identificándolo por su GUID.
| Función | Parámetros | Devuelve | Qué hace |
| --------------------- | ------------ | -------- | --------------------------------------------------------------- |
| `OpenForm` | (sección) | — | Abre el formulario para ver o editar un registro de la sección. |
| `OpenReport` | (informeId) | — | Abre un informe por su identificador. |
| `OpenDynamicDocument` | (funciónApi) | — | Abre el documento dinámico que genera una función de API. |
## Acciones sobre el formulario actual [#acciones-sobre-el-formulario-actual]
Actúan sobre el registro abierto. Solo en scripts de formulario.
| Función | Parámetros | Devuelve | Qué hace |
| -------------------------- | ---------- | ------------ | ------------------------------------------------------------- |
| `Save` | () | — | Guarda el registro actual del formulario. |
| `CancelEvent` | () | — | Cancela el evento en curso e impide que continúe. |
| `CalculatePurchase` | () | — | Ejecuta el cálculo de compra del registro actual. |
| `CalculateSale` | () | — | Ejecuta el cálculo de venta del registro actual. |
| `Form_EnableSequentialAdd` | (activado) | Entero | Activa o desactiva el modo de alta secuencial del formulario. |
| `IsNew` | () | Entero (1/0) | El registro actual es nuevo. |
| `IsNew_Sequential` | () | Entero (1/0) | El registro se creó en modo de alta secuencial. |
| `IsVirtualForm` | () | Entero (1/0) | El formulario actual es virtual. |
## Disparadores y cambios de campo [#disparadores-y-cambios-de-campo]
Declaran cuándo se dispara el script y leen el valor implicado en el cambio.
| Función | Parámetros | Devuelve | Qué hace |
| ----------------------- | ---------- | -------- | ------------------------------------------------------------ |
| `InitializeTrigger` | (evento) | — | Inicializa el disparador del script para el evento indicado. |
| `TriggerOnFieldChange` | (campoId) | — | Dispara el script cuando cambia el campo indicado. |
| `TriggerIfFieldsFilled` | (campoId) | — | Dispara el script solo si el campo indicado tiene valor. |
| `TriggerIfNewRecord` | () | Sí/No | Dispara el script solo si el registro es nuevo. |
| `GetNewFieldValue` | (campoId) | Texto | Devuelve el valor nuevo del campo. |
| `GetPreviousFieldValue` | (campoId) | Texto | Devuelve el valor anterior del campo. |
```javascript
@ Corre solo cuando cambia el campo Estado
F.TriggerOnFieldChange(S.Fields.Pedidos.Estado.ID)
txt anterior = F.GetPreviousFieldValue(S.Fields.Pedidos.Estado.ID)
txt nuevo = F.GetNewFieldValue(S.Fields.Pedidos.Estado.ID)
```
## Alta de registros desde el script [#alta-de-registros-desde-el-script]
Dan de alta un registro por pasos: abres el alta, asignas campos y la confirmas. Solo en scripts de formulario.
| Función | Parámetros | Devuelve | Qué hace |
| ---------------------------- | -------------- | -------- | ----------------------------------------------------------------------------------- |
| `AddElement_Begin` | (sección) | — | Inicia el alta de un registro en la sección indicada. |
| `AddElement_SetValue` | (campo, valor) | — | Asigna el valor de un campo del alta en curso. El tipo del valor depende del campo. |
| `AddElement_Commit` | () | — | Finaliza el alta sin aceptar automáticamente el registro. |
| `AddElement_CommitAndAccept` | () | — | Finaliza el alta y acepta (guarda) el registro. |
## Destinadores y catálogos [#destinadores-y-catálogos]
Leen cantidades de un destinador de destino y controlan qué se muestra en el formulario. Solo en scripts de formulario.
| Función | Parámetros | Devuelve | Qué hace |
| ----------------------------- | ---------------------- | -------- | ------------------------------------------------------- |
| `Allocator_SourceQuantity` | () | Decimal | Cantidad de origen del destinador. |
| `Allocator_CompletedQuantity` | () | Decimal | Cantidad ya completada del destinador. |
| `Allocator_PendingQuantity` | () | Decimal | Cantidad pendiente del destinador. |
| `Allocator_RenderGeneric` | () | — | Pinta la representación visual genérica del destinador. |
| `Allocator_SetHidden` | (destinadorId, estado) | Entero | Oculta o muestra un destinador por su ID. |
| `Catalog_SetDisabled` | (catálogo, estado) | Entero | Desactiva o activa un catálogo por su ID. |
## Email y sistema [#email-y-sistema]
| Función | Parámetros | Devuelve | Qué hace |
| ------------------------- | ------------------------------ | -------- | -------------------------------------------------------------------------- |
| `EmailSend` | (origen, destino) | — | Envía un email desde la cuenta de origen a la dirección de destino. |
| `EmailSendReply` | (origen, destino, respuestaA) | — | Envía una respuesta enlazada al email original. |
| `EmailSend_CurrentBuffer` | () | — | Envía el documento actual por email. |
| `CurrencyChange` | (isoOrigen, isoDestino, fecha) | Decimal | Tipo de cambio entre dos divisas ISO en la fecha dada. |
| `OSRunCMD` | (comando, esperar, timeoutMs) | — | Ejecuta un comando del sistema operativo, con espera y timeout opcionales. |
`EmailSend` y `EmailSendReply` ejecutan solo en scripts de formulario; el resto también vale en scripts independientes.
***
→ [Índice de funciones](/docs/desarrollo/flex/dinascript/funciones)
→ [Funciones de texto](/docs/desarrollo/flex/dinascript/funciones/texto)
# Funciones de lógica y comparación (/docs/desarrollo/flex/dinascript/funciones/logica-y-comparacion)
Funciones del espacio `F.` para comparar valores y decidir resultados: igualdad, mayor/menor, rangos, condicionales de dos salidas y cadenas de casos. Casi todas son familias tipadas: el sufijo (`_Int`, `_Num`, `_Text`, `_Time`, `_Date`, `_DateTime`) indica el tipo de dato de cada variante. La leyenda de sufijos y las convenciones comunes están en el [índice de funciones](/docs/desarrollo/flex/dinascript/funciones).
## Comparar dos valores [#comparar-dos-valores]
Cada comparación existe en dos formas con el mismo comportamiento: `Is…` devuelve Entero (`1`/`0`) y `Check…` devuelve Sí/No. Elige según el tipo que espere tu fórmula o campo.
| Función | Parámetros | Devuelve | Qué hace |
| ------------------------------------------------ | ---------------- | -------------------- | ------------------------------------------ |
| `IsEquals_*` / `CheckEquals_*` | (valor1, valor2) | Entero (1/0) · Sí/No | Los dos valores son iguales. |
| `IsDistinct_*` / `CheckDistinct_*` | (valor1, valor2) | Entero (1/0) · Sí/No | Los dos valores son distintos. |
| `IsGreater_*` / `CheckGreater_*` | (valor1, valor2) | Entero (1/0) · Sí/No | El primero es mayor que el segundo. |
| `IsGreaterOrEquals_*` / `CheckGreaterOrEquals_*` | (valor1, valor2) | Entero (1/0) · Sí/No | El primero es mayor o igual. |
| `IsSmaller_*` / `CheckSmaller_*` | (valor1, valor2) | Entero (1/0) · Sí/No | El primero es menor. |
| `IsSmallerOrEquals_*` / `CheckSmallerOrEquals_*` | (valor1, valor2) | Entero (1/0) · Sí/No | El primero es menor o igual. |
| `IsExact_*` | (valor1, valor2) | Entero (1/0) | Igualdad estricta, con comparación exacta. |
| `IsExactDirect_*` | (valor1, valor2) | Sí/No | Como `IsExact_*`, pero devuelve Sí/No. |
Sufijos disponibles: `_Int`, `_Num`, `_Text`, `_Time`, `_Date`, `_DateTime`.
```javascript
¿F.IsGreater_Num(v.total, 3000) = 1 ? v.descuento = 5
```
## Vacío o relleno [#vacío-o-relleno]
Solo existen para `_Text`, `_Time`, `_Date` y `_DateTime`. Misma pareja `Is…`/`Check…` que arriba.
| Función | Parámetros | Devuelve | Qué hace |
| ---------------------------------- | ---------- | -------------------- | --------------------------- |
| `IsEmpty_*` / `CheckEmpty_*` | (valor) | Entero (1/0) · Sí/No | El valor está vacío o nulo. |
| `IsNotEmpty_*` / `CheckNotEmpty_*` | (valor) | Entero (1/0) · Sí/No | El valor está relleno. |
## Rangos [#rangos]
Sufijos disponibles: `_Int`, `_Num`, `_Time`, `_Date`, `_DateTime` (sin variante de texto).
| Función | Parámetros | Devuelve | Qué hace |
| --------------------------- | ----------------------------------------------------- | ------------ | ----------------------------------------------------- |
| `Between_MinMax_*` | (valor, desde, hasta) | Entero (1/0) | El valor cae dentro del rango, extremos incluidos. |
| `Between_MinMax_Advanced_*` | (valor, desde, desdeInclusive, hasta, hastaInclusive) | Entero (1/0) | Como la anterior, pero eliges si cada extremo cuenta. |
| `Intersect_*` | (rango1Desde, rango1Hasta, rango2Desde, rango2Hasta) | Entero (1/0) | Los dos rangos se solapan. |
## Buscar en una lista [#buscar-en-una-lista]
| Función | Parámetros | Devuelve | Qué hace |
| ------------------- | -------------- | ------------ | --------------------------------------------- |
| `ExistIn_*` | (valor, lista) | Entero (1/0) | El valor está en la lista separada por comas. |
| `ExistIn_Reference` | (valor, lista) | Entero (1/0) | Igual, para relaciones (GUID). |
A diferencia del resto de la página, `ExistIn_*` y `ExistIn_Reference` solo ejecutan en fórmulas de algoritmo y vía API, no en formularios.
## Elegir entre dos valores [#elegir-entre-dos-valores]
El condicional básico: una condición Sí/No y dos posibles resultados.
| Función | Parámetros | Devuelve | Qué hace |
| ------------ | ------------------------------- | ------------ | ---------------------------------------------- |
| `If_*` | (condición, opciónSí, opciónNo) | Según sufijo | Devuelve una opción u otra según la condición. |
| `If_Numeric` | (condición, opciónSí, opciónNo) | Decimal | Versión decimal del condicional. |
`If_*` existe con sufijos `_Int`, `_Text`, `_Time`, `_Date` y `_DateTime`; para decimales usa `If_Numeric`.
## Comparar y elegir en una llamada [#comparar-y-elegir-en-una-llamada]
La familia `If___` combina comparación y condicional: compara dos valores del primer tipo y devuelve uno de dos resultados del segundo. Por ejemplo, `If_Num_IsGreater_Text` compara dos decimales y devuelve un texto.
| Comparación | Parámetros | Devuelve el valor Sí cuando… |
| ---------------------------- | --------------------------------------- | ------------------------------ |
| `If__IsEquals_*` | (valor1, valor2, valorSí, valorNo) | Los dos valores son iguales. |
| `If__IsDistinct_*` | (valor1, valor2, valorSí, valorNo) | Son distintos. |
| `If__IsGreater_*` | (valor1, valor2, valorSí, valorNo) | El primero es mayor. |
| `If__IsGreaterOrEquals_*` | (valor1, valor2, valorSí, valorNo) | El primero es mayor o igual. |
| `If__IsSmaller_*` | (valor1, valor2, valorSí, valorNo) | El primero es menor. |
| `If__IsSmallerOrEquals_*` | (valor1, valor2, valorSí, valorNo) | El primero es menor o igual. |
| `If__Between_*` | (valor, desde, hasta, valorSí, valorNo) | El valor cae dentro del rango. |
| `If__IsEmpty_*` | (valor, valorSí, valorNo) | El valor está vacío o nulo. |
| `If__IsNotEmpty_*` | (valor, valorSí, valorNo) | El valor está relleno. |
`` es el tipo comparado (`Int`, `Num`, `Text`, `Time`, `Date`, `DateTime`) y `*` el sufijo del tipo devuelto (`_Int`, `_Num`, `_Text`, `_Time`, `_Date`, `_DateTime`). Dos excepciones: `Between` no existe para `Text`, y `IsEmpty`/`IsNotEmpty` no existen para `Int` ni `Num`.
```javascript
txt aviso = F.If_Num_IsGreater_Text(v.total, 5000, "Revisar con dirección", "")
@ compara dos decimales y devuelve un texto
```
## Encadenar varios casos [#encadenar-varios-casos]
Las familias `Case2_*` a `Case10_*` encadenan de 2 a 10 pares evaluación-valor más un valor por defecto. Cada evaluación es un Entero (`1`/`0`), normalmente el resultado de una función `Is…`. Gana el primer par cuya evaluación se cumple; si ninguna se cumple, se devuelve `otro`.
| Función | Parámetros | Devuelve | Qué hace |
| ---------------------- | --------------------------------------------------- | ------------ | ------------------------------------------------ |
| `Case2_*` … `Case10_*` | (evaluación1, valor1, …, evaluaciónN, valorN, otro) | Según sufijo | El valor del primer par que se cumple, u `otro`. |
Sufijos disponibles: `_Int`, `_Num`, `_Text`, `_Time`, `_Date`, `_DateTime` (tipo de los valores devueltos).
```javascript
txt tramo = F.Case2_Text(F.IsSmaller_Num(v.total, 100), "Pequeño", F.IsSmaller_Num(v.total, 1000), "Medio", "Grande")
@ menor de 100: "Pequeño" · menor de 1000: "Medio" · resto: "Grande"
```
***
→ [Índice de funciones](/docs/desarrollo/flex/dinascript/funciones)
→ [Funciones de texto](/docs/desarrollo/flex/dinascript/funciones/texto)
# Funciones matemáticas y de conversión (/docs/desarrollo/flex/dinascript/funciones/matematicas-y-conversion)
Funciones del espacio `F.` para operar con números y cambiar valores de tipo: redondeo, porcentajes, signo y conversiones. Todas ejecutan en cualquier contexto (fórmulas de algoritmo, formularios, campos independientes y API) salvo las excepciones marcadas en la última sección. Las convenciones comunes están en el [índice de funciones](/docs/desarrollo/flex/dinascript/funciones).
¿Buscas el máximo o el mínimo de varios valores? Esas funciones (`Max_*`, `Min_*`) viven en [funciones de agregación](/docs/desarrollo/flex/dinascript/funciones/agregacion).
## Redondeo [#redondeo]
Cuatro criterios distintos para quitar decimales. Elige según hacia dónde quieres que caiga el resultado.
| Función | Parámetros | Devuelve | Qué hace |
| --------------- | ------------------ | -------- | --------------------------------------------------- |
| `Round` | (valor, decimales) | Decimal | Redondea al número de decimales indicado. |
| `Cast_NumToInt` | (valor) | Entero | Redondea al entero más cercano. |
| `Truncate` | (valor) | Entero | Parte entera: descarta los decimales sin redondear. |
| `Ceiling` | (valor) | Entero | Entero igual o superior más cercano. |
| `Floor` | (valor) | Entero | Entero igual o inferior más cercano. |
```javascript
num redondeado = F.Round(12.68, 1)
@ redondeado vale 12.7
num entero = F.Truncate(12.68)
@ entero vale 12; F.Ceiling(12.68) daría 13
```
## Porcentajes [#porcentajes]
Aplican o deshacen un porcentaje sin escribir la fórmula a mano.
| Función | Parámetros | Devuelve | Qué hace |
| --------------------------- | ----------------------------- | -------- | -------------------------------------------------------------- |
| `PercentageIncrease` | (valor, porcentaje) | Decimal | Incrementa el valor en el porcentaje dado. |
| `PercentageDecrease` | (valor, porcentaje) | Decimal | Reduce el valor en el porcentaje dado. |
| `PercentageReverse` | (valor, porcentaje) | Decimal | Deshace un porcentaje ya aplicado y devuelve la base original. |
| `CalculatePreDiscountValue` | (valorReferencia, porcentaje) | Decimal | Valor previo a un descuento del porcentaje indicado. |
| `PercentageDifference` | (dato, referencia) | Decimal | Diferencia porcentual entre un dato y su referencia. |
`PercentageReverse` no es lo mismo que `PercentageDecrease`: uno deshace, el otro resta.
```javascript
num conIva = F.PercentageIncrease(100, 21)
@ conIva vale 121
num base = F.PercentageReverse(conIva, 21)
@ base vale 100; F.PercentageDecrease(121, 21) daría 95.59
```
## Signo [#signo]
Fuerzan el signo de un número sin condicionales.
| Función | Parámetros | Devuelve | Qué hace |
| ---------------- | ---------- | -------- | ----------------------------------------------------- |
| `EnsurePositive` | (valor) | Decimal | Devuelve el valor en positivo, sea cual sea su signo. |
| `EnsureNegative` | (valor) | Decimal | Devuelve el valor en negativo, sea cual sea su signo. |
## Convertir entre tipos [#convertir-entre-tipos]
Pasan valores de un tipo a otro y comprueban si un texto es convertible.
| Función | Parámetros | Devuelve | Qué hace |
| --------------------- | -------------------- | ------------ | ------------------------------------------------------------ |
| `Cast_TextToNum` | (valor) | Decimal | Convierte un texto en número decimal. |
| `Cast_TextToInt` | (valor) | Entero | Convierte un texto en entero. |
| `Cast_NumToText` | (valor) | Texto | Convierte un número en su representación de texto. |
| `Cast_DateToText` | (fecha, formato) | Texto | Convierte una fecha en texto con el formato indicado. |
| `Cast_DateTimeToText` | (fechaHora, formato) | Texto | Convierte una fecha y hora en texto con el formato indicado. |
| `ExtractFirstNumber` | (texto) | Decimal | Extrae el primer número que aparece en un texto. |
| `IsNumeric` | (cadena) | Entero (1/0) | El texto representa un número válido. |
| `IsInteger` | (cadena) | Entero (1/0) | El texto representa un entero válido. |
`Cast_TextToNum`, `Cast_TextToInt` y `Cast_NumToText` solo ejecutan en fórmulas de algoritmo. `IsNumeric`, `IsInteger` y `ExtractFirstNumber` ejecutan en el resto de contextos, pero no en algoritmos: no puedes validar con `IsNumeric` antes de convertir con `Cast_TextToNum`.
***
→ [Índice de funciones](/docs/desarrollo/flex/dinascript/funciones)
→ [Funciones de agregación](/docs/desarrollo/flex/dinascript/funciones/agregacion)
→ [Funciones de texto](/docs/desarrollo/flex/dinascript/funciones/texto)
# Funciones de sistema y seguridad (/docs/desarrollo/flex/dinascript/funciones/sistema-y-seguridad)
Funciones del espacio `F.` para operar con el sistema: crear y modificar registros desde un script, lanzar peticiones HTTP, codificar texto, generar claves y códigos, y localizar cuentas contables. Las convenciones comunes (tipos de datos, sufijos, contextos) están en el [índice de funciones](/docs/desarrollo/flex/dinascript/funciones).
## Crear y modificar registros por script [#crear-y-modificar-registros-por-script]
Las funciones `API_` guardan registros desde el propio script. El flujo tiene tres pasos: abrir el registro con `API_BeginAddRecord` o `API_BeginModifyRecord`, asignar campos con `API_SetRecordFieldValue` y confirmar con `API_CommitSaveRecord`.
| Función | Parámetros | Devuelve | Qué hace |
| ------------------------- | ----------------------- | --------------- | -------------------------------------------------------------------------------------- |
| `API_BeginAddRecord` | (sección) | Relación (GUID) | Crea un registro nuevo en la sección y devuelve su GUID. |
| `API_BeginModifyRecord` | (sección) | — | Inicia la modificación de un registro existente de la sección. |
| `API_SetRecordFieldValue` | (sección, campo, valor) | — | Asigna el valor de un campo del registro abierto. El tipo del valor depende del campo. |
| `API_CommitSaveRecord` | () | Entero | Confirma y guarda en base de datos los cambios pendientes. |
| `API_DeleteRecord` | (sección) | — | Elimina definitivamente un registro de la sección. |
| `API_RestoreRecord` | (sección) | — | Restaura un registro eliminado de la sección. |
Sin `API_CommitSaveRecord` no se guarda nada: los cambios quedan pendientes hasta que lo llamas.
Tras el guardado, las `SaveInfo_` te dicen qué ha pasado:
| Función | Parámetros | Devuelve | Qué hace |
| ------------------------ | ---------- | --------------- | --------------------------------------------------------- |
| `SaveInfo_AffectedCount` | (sección) | Entero | Registros afectados por el último guardado en la sección. |
| `SaveInfo_AffectedID` | (sección) | Relación (GUID) | GUID del registro afectado por el último guardado. |
| `SaveInfo_DurationMs` | (sección) | Entero | Duración del último guardado, en milisegundos. |
## Ejecutar scripts y servicios externos [#ejecutar-scripts-y-servicios-externos]
Todas ejecutan en scripts independientes.
| Función | Parámetros | Devuelve | Qué hace |
| ------------------------------------ | ------------------------------- | -------- | ------------------------------------------------------------ |
| `ExecuteScript` | (script) | — | Ejecuta otro script por su identificador. |
| `WebClient_Request` | (endpoint, método, diccionario) | Texto | Lanza una petición HTTP al endpoint y devuelve la respuesta. |
| `IndexText` | (texto) | Entero | Añade un texto al índice en memoria y devuelve su posición. |
| `BuildArrayJSON` | () | Texto | Monta un array JSON con los valores indexados. |
| `Maps_KilometersBetween2Coordinates` | (desde, hasta) | Decimal | Kilómetros entre dos coordenadas geográficas. |
| `Maps_MinutesBetween2Coordinates` | (desde, hasta) | Entero | Minutos de viaje entre dos coordenadas geográficas. |
Los parámetros de la petición HTTP viajan en un diccionario de [funciones de texto](/docs/desarrollo/flex/dinascript/funciones/texto):
```javascript
num parametros = F.DicT_New()
F.DicT_Add(parametros, "email", v.email)
txt respuesta = F.WebClient_Request("https://api.ejemplo.com/altas", "POST", parametros)
```
## Equipo local: solo en el Terminal [#equipo-local-solo-en-el-terminal]
Operan sobre la máquina donde corre la aplicación: portapapeles, archivos y procesos. Solo ejecutan en el Terminal, en scripts independientes.
| Función | Parámetros | Devuelve | Qué hace |
| ------------------- | -------------------------------------------------- | ------------ | ---------------------------------------------------------------- |
| `ClipboardGet` | () | Texto | Lee el texto del portapapeles. |
| `ClipboardSet` | (texto) | — | Copia el texto al portapapeles. |
| `IOFileExists` | (ruta) | Entero (1/0) | El archivo existe en la ruta indicada. |
| `IODirectoryExists` | (ruta) | Entero (1/0) | La carpeta existe en la ruta indicada. |
| `OSProcessStart` | (directorio, archivo, comando, esperar, timeoutMs) | — | Arranca un proceso del sistema, con espera y timeout opcionales. |
| `RunCMD` | (comando) | Texto | Ejecuta un comando de sistema predefinido y devuelve su salida. |
## Codificar y descodificar [#codificar-y-descodificar]
Escapan texto para incrustarlo en HTML, URLs o JSON sin romper la sintaxis. Ejecutan en documentos dinámicos y funciones API; `URLEncode` también vale en scripts de formulario e independientes.
| Función | Parámetros | Devuelve | Qué hace |
| ------------ | ---------------- | -------- | ---------------------------------------------------------- |
| `HtmlEncode` | (texto) | Texto | Escapa los caracteres especiales de HTML. |
| `HtmlDecode` | (texto) | Texto | Deshace la codificación HTML y recupera el texto original. |
| `URLEncode` | (texto) | Texto | Escapa un texto para usarlo en una URL. |
| `URLDecode` | (texto) | Texto | Deshace la codificación URL y recupera el texto original. |
| `JSONEncode` | (texto) | Texto | Escapa un texto para usarlo como valor JSON. |
| `GetBase64` | (imagen, tamaño) | Texto | Devuelve una imagen en Base64, al tamaño indicado. |
## Códigos QR [#códigos-qr]
Ambas ejecutan en documentos dinámicos y funciones API.
| Función | Parámetros | Devuelve | Qué hace |
| ------------------- | ------------------------------- | -------- | ------------------------------------------------------------- |
| `BuildQR` | (url) | Texto | Genera un código QR a partir de una URL. |
| `BuildQR_Verifactu` | (nif, numSerie, fecha, importe) | Texto | Genera el QR Verifactu de una factura con sus datos fiscales. |
## Hashes, claves y códigos [#hashes-claves-y-códigos]
Todas valen en scripts independientes salvo `ToSHA1`, que solo ejecuta en documentos dinámicos y funciones API. `NewGuid` vale en cualquier contexto.
| Función | Parámetros | Devuelve | Qué hace |
| --------------------- | ---------------------- | -------- | ----------------------------------------------------------------- |
| `NewGuid` | () | Texto | Genera un GUID aleatorio nuevo. |
| `NewPassword` | (longitud, especiales) | Texto | Genera una contraseña aleatoria, con o sin caracteres especiales. |
| `ToSHA1` | (texto) | Texto | Hash SHA-1 del texto. |
| `CreateSecretKeyTotp` | (longitud) | Texto | Genera una clave secreta para códigos TOTP. |
| `ComputeCodeTotp` | (claveSecreta) | Texto | Calcula el código TOTP vigente para una clave secreta. |
El secreto TOTP se genera una vez; el código se recalcula a partir de él cada vez que lo necesitas:
```javascript
txt secreto = F.CreateSecretKeyTotp(32)
txt codigo = F.ComputeCodeTotp(secreto)
```
## Contabilidad [#contabilidad]
Localizan grupos, cuentas y subcuentas del plan contable por su código. Las `Detect*` ejecutan en scripts de formulario; `IsAccountOrSubAccount` también en algoritmos y scripts independientes.
| Función | Parámetros | Devuelve | Qué hace |
| ----------------------- | -------------------- | --------------- | ------------------------------------------------------------------------------- |
| `DetectAccount` | (código) | Relación (GUID) | GUID de la cuenta a partir del código de cuenta o subcuenta. |
| `DetectAccountByType` | (código, tipo) | Relación (GUID) | GUID del grupo, cuenta o subcuenta, según el tipo a extraer. |
| `DetectAccountGroup` | (código) | Relación (GUID) | GUID del grupo contable a partir del código. |
| `DetectSubAccount` | (código) | Relación (GUID) | GUID de la subcuenta a partir de su código. |
| `IsAccountOrSubAccount` | (cuenta, subcuentas) | — | Comprueba si la cuenta coincide con los códigos indicados, separados por comas. |
***
→ [Índice de funciones](/docs/desarrollo/flex/dinascript/funciones)
→ [Scripts](/docs/desarrollo/flex/scripts)
→ [Documentos dinámicos](/docs/desarrollo/flex/documentos-dinamicos)
# Funciones de texto (/docs/desarrollo/flex/dinascript/funciones/texto)
Funciones del espacio `F.` para trabajar con texto: combinar valores, buscar dentro de una cadena, trocearla por un separador, formatear números como texto y montar estructuras JSON. Las convenciones comunes (tipos de datos, valores sí/no, contextos) están en el [índice de funciones](/docs/desarrollo/flex/dinascript/funciones).
## Combinar y transformar [#combinar-y-transformar]
| Función | Parámetros | Devuelve | Qué hace |
| --------------------------- | ---------------------------------- | -------- | --------------------------------------------------------------------------------------------------------------------- |
| `Concat` … `Concat6` | (texto1, …, textoN) | Texto | Une de 1 a 6 valores de texto en uno. |
| `Replace` | (cadena, búsqueda, nuevoValor) | Texto | Sustituye todas las apariciones de un texto por otro. |
| `ToUppers` | (texto) | Texto | Pasa a mayúsculas. |
| `ToLower` | (texto) | Texto | Pasa a minúsculas. |
| `Length` | (texto) | Entero | Número de caracteres. |
| `Substring` | (texto, inicio, longitud) | Texto | Extrae un trozo desde una posición. |
| `RemoveStart` / `RemoveEnd` | (cadena, cantidad) | Texto | Quita N caracteres del inicio o del final. |
| `PadLeft` / `PadRight` | (texto, cantidad, relleno, cortar) | Texto | Rellena hasta una longitud fija por la izquierda o la derecha. El último parámetro corta el texto si ya es más largo. |
```javascript
txt codigo = F.PadLeft("7", 5, "0", false)
@ codigo vale "00007"
txt etiqueta = F.Concat3("Pedido ", codigo, " confirmado")
```
## Buscar dentro de un texto [#buscar-dentro-de-un-texto]
Las tres devuelven un entero: `1` si se cumple, `0` si no. La comparación ignora mayúsculas y acentos.
| Función | Parámetros | Devuelve | Qué hace |
| ------------ | ------------------ | ------------ | --------------------------------------- |
| `Contains` | (cadena, búsqueda) | Entero (1/0) | La cadena contiene el texto buscado. |
| `StartsWith` | (cadena, búsqueda) | Entero (1/0) | La cadena empieza por el texto buscado. |
| `EndsWith` | (cadena, búsqueda) | Entero (1/0) | La cadena termina en el texto buscado. |
```javascript
¿F.Contains(v.email, "@") = 0 ? v.error = "El email no es válido"
```
## Trocear por separador [#trocear-por-separador]
Parten la cadena por un separador y devuelven o eliminan segmentos. `A ignorar` salta los primeros N trozos; `A recibir` limita cuántos coges.
| Función | Parámetros | Devuelve | Qué hace |
| ----------------- | -------------------------------------- | -------- | -------------------------------------------------- |
| `GetFirstPart` | (valor, separador, aIgnorar, aRecibir) | Texto | Coge los primeros segmentos tras partir la cadena. |
| `GetLastPart` | (valor, separador, aIgnorar, aRecibir) | Texto | Coge los últimos segmentos. |
| `RemoveFirstPart` | (valor, separador, aEliminar) | Texto | Quita los primeros N segmentos. |
| `RemoveLastPart` | (valor, separador, aEliminar) | Texto | Quita los últimos N segmentos. |
```javascript
txt dominio = F.GetLastPart("ana@dinaup.com", "@", 0, 1)
@ dominio vale "dinaup.com"
```
## Formatear números como texto [#formatear-números-como-texto]
Aplican el formato de presentación de tu cuenta: separadores de miles, símbolo de moneda, signo de porcentaje.
| Función | Parámetros | Devuelve | Qué hace |
| --------------------- | ------------ | -------- | -------------------------------------------------------------------------------------------- |
| `FormatMoney` | (importe) | Texto | Importe monetario: `1.234,56 €`. |
| `FormatNumeric` | (importe) | Texto | Número con separadores: `1.234,56`. |
| `FormatPercentage` | (importe) | Texto | Porcentaje: `25%`. |
| `FormatNumericByRole` | (valor, rol) | Texto | Formatea según el formato del [rol de campo](/docs/desarrollo/flex/roles-de-campo) indicado. |
| `FormatTime` | (minutos) | Texto | Minutos como hora: `90` → `1:30`. |
| `WriteTime` | (minutos) | Texto | Minutos como texto legible por personas. |
## Diccionarios en memoria [#diccionarios-en-memoria]
Pares clave-valor para acumular resultados antes de exportarlos. Dos sabores: texto (`DicT_`) y numérico (`DicN_`). `_New` devuelve la referencia del diccionario, que pasas al resto de funciones.
| Función | Parámetros | Devuelve | Qué hace |
| --------------------------------------- | --------------------- | --------------- | ----------------------------------------------------------- |
| `DicT_New` / `DicN_New` | () | Referencia | Crea el diccionario. |
| `DicT_Add` / `DicN_Add` | (dic, clave, valor) | — | Añade o actualiza una clave. |
| `DicT_Get` / `DicN_Get` | (dic, clave, defecto) | Texto / Decimal | Lee una clave; si no existe, devuelve el valor por defecto. |
| `DicT_ContainsKey` / `DicN_ContainsKey` | (dic, clave) | Entero (1/0) | La clave existe. |
| `DicT_Count` / `DicN_Count` | (dic) | Entero | Número de entradas. |
| `DicT_RemoveItem` / `DicN_RemoveItem` | (dic, clave) | — | Elimina una clave. |
| `DicT_Clear` / `DicN_Clear` | (dic) | — | Vacía el diccionario. |
| `DicT_ToJson` / `DicN_ToJson` | (dic) | Texto | Vuelca el diccionario a JSON. |
```javascript
num dic = F.DicN_New()
F.DicN_Add(dic, "enero", 1200)
F.DicN_Add(dic, "febrero", 1550)
txt json = F.DicN_ToJson(dic)
```
## Construir JSON [#construir-json]
Para montar un JSON a mano con objetos anidados, sin pelearte con comillas. Abres un documento, vas asignando claves tipadas y lo lees al final.
| Función | Parámetros | Devuelve | Qué hace |
| ------------------- | -------------- | -------- | ----------------------------------------------------------- |
| `Json_DocIni` | (keyword) | — | Abre un documento JSON identificado por keyword. |
| `Json_ObjectIni` | (clave) | — | Abre un objeto anidado. Con clave vacía, es el objeto raíz. |
| `Json_SetValueText` | (clave, valor) | — | Asigna un valor de texto. |
| `Json_SetValueN` | (clave, valor) | — | Asigna un valor numérico. |
| `Json_SetValueB` | (clave, valor) | — | Asigna un valor sí/no. |
| `Json_SetValueJson` | (clave, json) | — | Anida un JSON ya construido como valor. |
| `Json_ObjectEnd` | () | — | Cierra el objeto actual. |
| `Json_DocEnd` | () | — | Cierra el documento. |
| `Json_ReadDoc` | (keyword) | Texto | Devuelve el JSON generado. |
```javascript
F.Json_DocIni("respuesta")
F.Json_ObjectIni("")
F.Json_SetValueText("estado", "ok")
F.Json_SetValueN("total", 1250.50)
F.Json_ObjectEnd()
F.Json_DocEnd()
txt json = F.Json_ReadDoc("respuesta")
```
## NIF españoles [#nif-españoles]
| Función | Parámetros | Devuelve | Qué hace |
| ------------------- | ---------- | ------------ | ---------------------------------- |
| `ValidateNIF` | (nif) | Entero (1/0) | El NIF tiene un formato válido. |
| `NIFIsPersonal` | (nif) | Entero (1/0) | El NIF es de persona física. |
| `DetectTypeNIF` | (nif) | Texto | Nombre del tipo de NIF. |
| `IdentifyIDTypeNIF` | (nif) | Entero | Código del tipo de identificación. |
## Utilidades web [#utilidades-web]
| Función | Parámetros | Devuelve | Qué hace |
| --------------- | ---------- | -------- | --------------------------------------------------------------------------- |
| `ToFriendlyUrl` | (valor) | Texto | Convierte un texto en slug para URL, sin espacios ni caracteres especiales. |
| `JSEncode` | (texto) | Texto | Escapa un texto para incrustarlo en JavaScript. |
***
→ [Índice de funciones](/docs/desarrollo/flex/dinascript/funciones)
→ [Espacio de nombres S. (Schema)](/docs/desarrollo/flex/dinascript/s.-espacio-de-nombre-schema)
# Impresión de factura emitida (/docs/desarrollo/flex/documentos-dinamicos/ejemplos/impresion-factura-emitida)
## Contexto [#contexto]
Este documento genera un PDF de factura.
## Variables [#variables]
Define las variables:
* Factura (Relacionado con ventas)
## DinaScript [#dinascript]
```
 :-->)
* A fecha dispone de de saldo promocional que puede aplicar como descuentos en compras futuras.
```
# Ejemplos (/docs/desarrollo/flex/documentos-dinamicos/ejemplos)
Estos ejemplos son **plantillas reales** de documentos dinámicos, con su DinaScript completo. Copia el que más se parezca a lo que necesitas y adáptalo a tu caso.
Cada ejemplo muestra el patrón de principio a fin: qué **variables** define, cómo recorre los datos con DinaScript y cómo construye la salida final.
¿Es tu primer documento dinámico? Empieza por **[Crear documento dinámico](/docs/desarrollo/flex/documentos-dinamicos/crear-documento-dinamico)** para entender el flujo básico (código + variables) y vuelve aquí cuando quieras un ejemplo completo.
***
## Plantillas disponibles [#plantillas-disponibles]
Listado HTML de compras/gastos filtrado por rango de fechas y tipo de operación, con desglose de bases, IVA, RE y retenciones más una tabla de totales.
Factura de venta lista para imprimir o enviar por email: conceptos, bases imponibles, totales, condiciones de pago y notas, a partir de una factura concreta.
***
## Cuál te conviene [#cuál-te-conviene]
Los dos ejemplos resuelven necesidades distintas. Elige según el resultado que buscas:
| | Libro registro (HTML) | Impresión de factura (PDF) |
| ------------------ | ------------------------------------------- | ------------------------------------------- |
| Qué genera | Un **listado** con muchos registros | Un **documento** de un único registro |
| Entrada | Variables de filtro: rango de fechas y tipo | Una variable: la factura a imprimir |
| Cómo recorre datos | Carga y procesa una lista de compras/gastos | Carga las líneas de la factura seleccionada |
| Uso típico | Consulta fiscal, exportación, revisión | Entregar o enviar la factura al cliente |
Ambos comparten el mismo esqueleto: definir variables, recorrer los datos con DinaScript y volcar el HTML resultante.
***
## Cómo adaptar un ejemplo [#cómo-adaptar-un-ejemplo]
### Crea el documento [#crea-el-documento]
Sigue los pasos de **[Crear documento dinámico](/docs/desarrollo/flex/documentos-dinamicos/crear-documento-dinamico)** para dar de alta una plantilla nueva y abrir su editor de código.
### Pega el ejemplo [#pega-el-ejemplo]
Copia el DinaScript de la plantilla que hayas elegido y pégalo en el editor, sustituyendo el contenido inicial.
### Declara sus variables [#declara-sus-variables]
Cada ejemplo indica en su apartado **Variables** las que necesita (por ejemplo, las fechas del libro registro o la factura a imprimir). Créalas con el mismo nombre desde la pestaña de variables.
### Ajústalo a tu caso [#ajústalo-a-tu-caso]
Cambia las secciones, campos, columnas y textos para que reflejen tus datos. Guarda y prueba el resultado.
***
→ [Crear documento dinámico](/docs/desarrollo/flex/documentos-dinamicos/crear-documento-dinamico)
→ [Documentos dinámicos](/docs/desarrollo/flex/documentos-dinamicos)
→ [Dinaup Flex](/docs/desarrollo/flex)
# Libro registro de facturas recibidas (HTML) (/docs/desarrollo/flex/documentos-dinamicos/ejemplos/libro-registro-de-facturas-recibidas-html)
## Contexto [#contexto]
Este documento dinámico muestra las facturas recibidas filtradas por variables globales:
* Rango de fecha
* Tipo de compra / gasto
## Variables [#variables]
Define las variables:
* Fecha\_Desde
* Fecha\_Hasta
* Tipo
## DinaScript [#dinascript]
```
```
# Crear y configurar informes (/docs/desarrollo/recursos/dinaup-terminal/ventanas/crear-informes)
Un informe nace siempre de una sección de datos. Se afina desde dos ventanas del Terminal: **Configuración de informe** (el informe entero) y **Editar Columna** (cada columna). Esta página lista qué controla cada opción. Para el concepto de informe, roles, visibilidad y filtrado, ver [informes en Flex](/docs/desarrollo/flex/informes).
## Crear informe [#crear-informe]
Se abre desde una sección de datos: el informe parte siempre de esa sección origen. El panel lateral **Secciones relacionadas** lista la sección base y sus plantillas derivadas. Solo aparecen las que tu permiso de creación te deja usar. Eliges sobre cuál crear.
| Campo | Qué es |
| -------------------------- | -------------------------------------------------- |
| Sección de origen de datos | La sección de la que salen los datos. Obligatorio. |
| Nombre informe | Nombre visible del informe. Obligatorio. |
| Categoría | Dónde se agrupa el informe. Obligatorio. |
| Subcategoría | Agrupación de segundo nivel. Opcional. |
Al aceptar, Dinaup crea el informe y lo abre. Valida que haya sección origen, nombre y categoría.
### Asistente de nombre [#asistente-de-nombre]
Desde **Asistente nombre** (en Configuración de informe) construyes el nombre uniendo hasta cinco partes con espacios.
| Parte | Contenido |
| ----------------------------- | ------------------------------------------------------------------------------------------------ |
| Prefijo | Sugiere `Top` (rankings), `Listado` (listados), `Resumen` (con gráficas) o `Board` (modo board). |
| Sujeto, Condición, Agrupación | Texto libre. |
| Pregunta | Si la rellenas, se añade al final precedida de `\| `. |
## Configurar informe [#configurar-informe]
La ventana **Configuración de informe** reúne todos los ajustes del informe en paneles. Los botones de pie son **Aceptar**, **Cancelar**, **Ver Informe**, **Exportar** (guardar en archivo), **Agregar columna** y **Asistente nombre**.
En informes principales o de sistema (combos, destinadores, alertas) muchos campos aparecen bloqueados con su motivo. El sistema autogestiona su tipo. Un informe que creas a mano casi siempre es de tipo Ordinario.
### Datos e identificación [#datos-e-identificación]
| Panel / campo | Qué controla |
| ----------------------------------------- | ------------------------------------------------------------ |
| Nombre informe, Descripción | Nombre y una descripción opcional para reconocer su función. |
| Sección de datos, Categoría, Subcategoría | Origen y clasificación del informe. |
| Tipo | Destino del informe. Casi siempre Ordinario. |
| Tipo de clasificación | Clasificación general (Funcionalidad, etc.). |
| Resultados por página | Numérico. Máximo 1.000; hasta 10.000 si aceptas con Shift. |
### Orden y agrupación [#orden-y-agrupación]
| Panel | Qué controla |
| ------------------- | --------------------------------------------------------------------------------------------------------------------- |
| Orden | Hasta 5 campos de orden, cada uno con casilla de descendente. Si el campo es fecha u hora, se marca descendente solo. |
| Agrupación de datos | Hasta 5 agrupaciones, cada una con su Modo (el criterio de agrupado). |
Algunos tipos de informe no permiten agrupar: en ese caso los selectores se bloquean con el motivo. Si rellenas una agrupación, debes elegir un modo válido antes de aceptar.
### Filtrado [#filtrado]
| Panel | Qué controla |
| ----------------- | ---------------------------------------------------------------------------------------------------- |
| Filtrado rápido | Condiciones directas sobre campos, más un Algoritmo de filtrado para condiciones que son un cálculo. |
| Filtrado avanzado | Editor de condiciones con las variables del informe (las preguntas dinámicas). |
Las variables de un informe ya publicado o en uso no pueden cambiarse, para no romper la compatibilidad con quien ya lo usa.
Ver [filtrado por algoritmo](/docs/desarrollo/flex/algoritmos), [preguntas dinámicas](/docs/desarrollo/flex/informes) y el how-to de [filtrar por rango de fechas](/docs/desarrollo/flex/informes/filtrar-informe-por-rango-de-fechas).
### Renderizado y representación [#renderizado-y-representación]
| Campo | Opciones |
| ---------------- | ------------------------------------------------------------------------- |
| Modo renderizado | Lista, Barras, Tarta, Polar, Board. |
| Modo multilinea | Automático, Activado, Desactivado, Siempre Activado, Siempre Desactivado. |
| Alto fila | Altura de cada fila. |
La representación avanzada añade columnas propias de cada modo:
| Modo | Columnas que añade |
| ----------------- | -------------------------------- |
| Board | Columnas de agrupación. |
| Calendario, Gantt | Columnas de inicio, fin y texto. |
| Gráfica | Columna de agrupación. |
### Aviso, permisos, complemento y destinador [#aviso-permisos-complemento-y-destinador]
| Panel | Qué controla |
| ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Aviso | Texto de aviso más su Tipo de aviso. Si escribes texto pero el tipo es Ninguno, se avisa de que no se mostrará. |
| Permisos | Casilla para ocultar el informe en principal (solo en informes reales). |
| Complemento en principal | Acceso rápido: Título, Etiqueta Singular y Etiqueta Plural (obligatorios si lo expandes), hasta 4 pares Campo/Valor de autorrellenado y una opción de incrustar. |
| Destinador Informe | Campo y sección destino; valida que el campo pertenezca a la sección elegida. |
Otros campos del panel: Informe relacionado y su etiqueta, Impresión por defecto, Objeto relacionado, Widget CFG y Categorías secundarias (hasta 8 categoría/subcategoría extra).
## Editar columna [#editar-columna]
La ventana **Editar Columna** define una columna. Los paneles que ves dependen del tipo de dato que produce la columna (texto, numérico, fecha, bool, imagen). Botones: **Aceptar**, **Cancelar**, **Ver informe**, **Personalizar** e **Ir a combo en sección** (si la columna sale de un combo).
### Dato e identificación [#dato-e-identificación]
| Campo | Qué es |
| -------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
| Dato | Campo o cadena mágica que representa la columna. Obligatorio. Admite campos directos, de sesión, de empresa, constantes y algoritmos. |
| Título columna, Abreviatura, Subtitulo | Textos de cabecera de la columna. |
| Prefijo, Sufijo, Color | Adornan el valor mostrado. |
| Información | Texto que aparece al pasar el cursor sobre la columna. |
### Comportamiento [#comportamiento]
| Campo | Opciones |
| ----------- | ---------------------------------------------------------------------------------------------------- |
| Rol | Automático por defecto, más los [roles de columna](/docs/desarrollo/flex/informes). |
| Visibilidad | Siempre visible por defecto, más el resto de [modos de visibilidad](/docs/desarrollo/flex/informes). |
| Relevancia | Normal, Alta, Secundaria. |
| Orden | Normal, Ascendente, Descendente. |
**Resúmenes de pie** (según el tipo de dato): Resumen Total, Resumen Filtrado y Resumen Seleccionado, con opciones Ninguno, Con dato, Vacías, Resultados y, según tipo, Media y Sumar (numérico), Contar distintos (texto) o Sí/No (bool).
**Agrupación (Dinámica)**: criterio de agrupado que depende del tipo de dato: Iguales, Vacíos, Parte entera, Parte decimal, Par/Impar, Horas, Días, Día de la semana, Meses, Trimestre, Bimensual, Año, Letra o Palabra inicial/final. Se acompaña de Orden (Dinámico) y Representación agrupada.
Al guardar, si el tipo de dato no admite monitorización, Dinaup avisa de que el informe la perderá.
### Opciones por tipo de dato [#opciones-por-tipo-de-dato]
| Tipo | Opciones propias |
| -------------------- | ------------------------------------------------------------ |
| Numérico | Decimales Visibles, Modo límite, Máximo valor, Mínimo valor. |
| Fecha / Fecha y hora | Modo de representación de la fecha. |
| Bool | Texto Sí, Texto No, Representación Sí, Representación No. |
| Texto | Representación del texto. |
| Imagen | Representación Imagen (Automático más el resto). |
## Enlaces relacionados [#enlaces-relacionados]
* → [Informes en Flex: concepto, roles y visibilidad](/docs/desarrollo/flex/informes)
* → [Filtrar un informe por rango de fechas](/docs/desarrollo/flex/informes/filtrar-informe-por-rango-de-fechas)
* → [Consumir un informe por API](/docs/desarrollo/flex/informes/informes-api)
* → [Diseñar secciones y campos](/docs/desarrollo/recursos/dinaup-terminal/ventanas/disenar-secciones-y-campos)
* → [Terminal de Dinaup](/docs/desarrollo/recursos/dinaup-terminal)
# Diseñar secciones y campos (/docs/desarrollo/recursos/dinaup-terminal/ventanas/disenar-secciones-y-campos)
Al modelar datos en Terminal trabajas con dos ventanas: el Asistente de Secciones y el Editor de Campos. Esta página es la referencia de sus opciones.
Para el concepto de sección o campo, ve a [Secciones](/docs/desarrollo/flex/secciones) y [Campos](/docs/desarrollo/flex/campos). Aquí tienes qué significa cada opción de la pantalla. Para el orden en que se usan, mira el [flujo de desarrollo](/docs/desarrollo/recursos/dinaup-terminal/flujo-de-desarrollo).
Editar la estructura de una sección afecta a todos los usuarios del tenant. Antes de tocarla, repasa las cautelas del [flujo de desarrollo](/docs/desarrollo/recursos/dinaup-terminal/flujo-de-desarrollo).
## Asistente de Secciones [#asistente-de-secciones]
Crea o edita una sección, es decir, una tabla de datos.
| Opción | Qué hace |
| ----------------------------------------- | ----------------------------------------------------------------------- |
| Título | Nombre identificativo de la sección. |
| Etiqueta singular / plural | Cómo se nombra un registro y muchos (Cliente / Clientes). |
| Es femenino | Ajusta el género de las etiquetas automáticas. |
| Icono / Color | Imagen y color con que se identifica la sección. |
| Campo Legible | Campo que representa cada registro como texto al referenciarlo. |
| Imagen de vista previa | Campo con la imagen que se muestra como previa del registro. |
| Se pueden crear derivadas / Derivable | Permite que otras secciones hereden de esta como base. |
| Datos exportables | Incluye los datos de la sección al empaquetar un módulo. |
| Control por fecha / por empleado | Campos con los que se filtran los datos por fecha o responsable. |
| Impedir agregar / mensajes de restricción | Bloquea crear, editar o eliminar y define el mensaje que ve el usuario. |
## Editor de Campos [#editor-de-campos]
Configura un campo al completo. Está organizado en pestañas.
### Identificación [#identificación]
| Opción | Qué hace |
| ----------------------------- | --------------------------------------------- |
| Etiqueta / Etiqueta abreviada | Nombre del campo y su versión corta. |
| Valor de ejemplo | Texto de ejemplo que orienta a quien rellena. |
| Ayuda | Instrucciones que se muestran junto al campo. |
### Tipo y rol [#tipo-y-rol]
| Opción | Qué hace |
| -------------------- | --------------------------------------------------------------------------------------------- |
| Formato | Tipo base: Texto, Número decimal, Número entero, Sí/No, Fecha, Fecha y hora, Hora o Relación. |
| Rol especial | Afina el tipo base (Email, Teléfono, NIF, Moneda, Porcentaje…). |
| Renderizado especial | Cómo se muestra en pantalla (genérico, selector Sí/No, selector múltiple…). |
El Formato define el [tipo de campo](/docs/desarrollo/flex/campos); el Rol especial lo afina, con más detalle en [roles de campo](/docs/desarrollo/flex/roles-de-campo).
### Comportamiento [#comportamiento]
| Opción | Qué hace |
| ----------------------------------- | ------------------------------------------------------------ |
| Visible / Visible a la derecha | Si se muestra el campo y dónde. |
| Obligatorio / Rellenado obligatorio | Si hace falta para guardar y si hay que rellenarlo al crear. |
| Bloqueado | Solo lectura: lo pone el sistema o un cálculo. |
| Indexar | Acelera las búsquedas por ese campo. |
| Sin valores repetidos | Exige que el valor sea único. |
| Valor por defecto | Valor inicial al crear un registro. |
### Auto-calculado [#auto-calculado]
Marca **Auto-calculado** y el valor lo produce un [algoritmo](/docs/desarrollo/flex/algoritmos) en vez de escribirse a mano. La lógica se escribe con [DinaScript](/docs/desarrollo/flex/dinascript/funciones).
### Campos numéricos [#campos-numéricos]
Aparecen cuando el Formato es un número.
| Opción | Qué hace |
| ------------------------------------- | --------------------------------------------------- |
| Decimales visibles / en base de datos | Cuántos decimales se muestran y cuántos se guardan. |
| Parte entera | Dígitos de la parte entera. |
### Campos de relación [#campos-de-relación]
Aparecen cuando el Formato es Relación.
| Opción | Qué hace |
| ------------------------------------- | -------------------------------------------------- |
| Sección relacionada / preferente | A qué otra sección apunta el campo. |
| Copiar valor principal al pulsar \[+] | Autorrellena datos al crear la relación. |
| Campo de texto de relación | Qué campo de la otra sección se muestra al buscar. |
## Agregar Campo Rápido [#agregar-campo-rápido]
Atajo para crear un campo con lo mínimo (Etiqueta, Formato, Rol, decimales) sin abrir el editor completo.
* **Aceptar** crea el campo.
* **Aceptar Avanzado** abre el Editor de Campos para afinar el resto de opciones.
## Duplicar Tabla [#duplicar-tabla]
Copia una sección a otra: eliges origen y destino, y se copian los campos con su configuración y las columnas del informe principal. Útil para partir de algo parecido en vez de empezar de cero.
## Relacionado [#relacionado]
→ [Secciones](/docs/desarrollo/flex/secciones)
→ [Campos](/docs/desarrollo/flex/campos)
→ [Roles de campo](/docs/desarrollo/flex/roles-de-campo)
→ [Flujo de desarrollo en Terminal](/docs/desarrollo/recursos/dinaup-terminal/flujo-de-desarrollo)
# Documentos dinámicos y API (/docs/desarrollo/recursos/dinaup-terminal/ventanas/documentos-dinamicos-y-api)
El Terminal trae un editor para crear y editar documentos dinámicos y funciones API. Esta página es la referencia de esas ventanas: el diálogo de alta rápida, el editor del documento y el asistente que escribe el código de un endpoint por ti. Para saber qué es un documento dinámico y sus tipos, ve a [documentos dinámicos](/docs/desarrollo/flex/documentos-dinamicos). Para el lenguaje, ve a [DinaScript](/docs/desarrollo/flex/dinascript).
## Elegir tipo de plantilla [#elegir-tipo-de-plantilla]
Al dar de alta un documento se abre el diálogo **Agregar Documentos dinámicos**. Ofrece cuatro atajos que crean directamente un documento de lectura libre y le cargan un ejemplo listo para editar:
| Botón | Extensión de salida |
| ------------ | ------------------- |
| Plantilla A4 | `.pdf` |
| Reporte HTML | `.html` |
| Archivo CSV | `.csv` |
| Archivo JSON | `.json` |
Los cuatro crean el tipo *Documento de lectura libre*; solo cambia la extensión y el ejemplo inicial. Cada botón descarga su plantilla y abre el editor con ese código puesto. **Cancelar** cierra sin crear. Para crear otros tipos (API de escritura, diseño de informe) fijas el campo **Clase** dentro del editor.
Si no hay conexión y la descarga del ejemplo falla, el editor se abre igual, pero vacío.
## El editor del documento [#el-editor-del-documento]
La ventana se titula **Agregar documento dinámico** al crear y **Editor documento dinámico** al editar. Es grande y redimensionable, y en ella defines todo el documento.
### Identificación [#identificación]
| Campo | Qué es |
| ------------------------ | ------------------------------------------ |
| Título | Nombre del documento en el listado. |
| Categoría · Subcategoría | Agrupan el documento en el listado. |
| Descripción | Texto libre que explica para qué sirve. |
| Ruta Keyword · ID | Identificadores para invocar el documento. |
Las categorías predefinidas son *Páginas / Informes*, *Exportación*, *Librerías*, *API*, *Ejemplos / Plantillas*, *Otros*, *Tareas programadas* y *Webhook*. Puedes añadir las tuyas.
### Tipo y salida [#tipo-y-salida]
| Campo | Qué controla |
| ---------- | ------------------------------------------------------------------------------------------------------------------------------- |
| Clase | El tipo de documento. Fija el título, el icono y el ejemplo de código inicial. |
| Extensión | Extensión del archivo generado (`.html`, `.pdf`, `.csv`, `.txt`, `.xml`, `.json`, `.css`, `.js`, `.svg`, `.md`, `.yaml` y más). |
| Encoding | Codificación del documento generado. |
| Protección | Nivel de acceso al documento (por ejemplo, *Cualquier empleado*). |
Los tipos disponibles en **Clase** y qué hace cada uno están en la [tabla de tipos de documento dinámico](/docs/desarrollo/flex/documentos-dinamicos).
### Pestañas de trabajo [#pestañas-de-trabajo]
| Pestaña | Para qué |
| --------- | ------------------------------------------------------------------------------------ |
| Inicio | Configuración general del documento. |
| Código | Editor DinaScript: colorea la sintaxis, detecta errores en vivo y lleva un contador. |
| Variables | Variables del documento con su formato, valor por defecto y etiqueta. |
| Previa | Vista previa del HTML renderizado. |
## La barra de variables [#la-barra-de-variables]
Bajo el editor de código, una barra muestra cada variable definida (`V.NombreVariable`) con su número de usos. Si una variable no se usa en ningún sitio, aparece en rojo.
* **Bloque Script:** inserta un bloque de script vacío donde está el cursor.
* **Menú `+`:** *Formatear* el código, *Convertir a Nativo*, *Convertir a Keyword*, *Reiniciar Código HTML* y *Reiniciar Código VUE* (regenera el ejemplo desde cero).
* **Presets:** al pulsar sobre las zonas de la barra insertas código de lectura (*Registro* o *Informe*: eliges una sección o un informe y vuelca sus campos) o abres el asistente de escritura (*Edición*).
* **ERRORES:** al hacer clic en el contador se despliega la lista de errores del script sobre el editor.
## Disponibilidad [#disponibilidad]
Este bloque marca dónde puede usarse el documento. Las casillas **Ticket**, **Impresión** y la de informe solo aparecen cuando la Clase es *Documento de lectura libre*; para otros tipos están ocultas.
* **Email:** marca el documento como válido para envío por email.
* **Obsoleto:** retira el documento sin borrarlo.
## Asistente de escritura API [#asistente-de-escritura-api]
El asistente **Asistente Agregar registro** / **Asistente modificador** genera automáticamente el código de un endpoint que crea o modifica un registro, para que no lo escribas a mano. Se abre desde el editor con el preset *Edición*: primero eliges Agregar o Modificar, y luego la sección de destino con el selector de secciones.
El asistente lista los campos de la sección como casillas, agrupados por pestaña y con un icono por tipo. Puedes filtrar qué campos ves:
| Filtro | Muestra los campos de tipo |
| ----------- | -------------------------- |
| Textos | Texto. |
| Sí/No | Casilla verdadero/falso. |
| Relaciones | Enlace a otra sección. |
| Numéricos | Número o moneda. |
| Hora | Hora. |
| Fecha | Fecha. |
| Fech y Hora | Fecha con hora. |
También hay un buscador por nombre. Los campos obligatorios y el texto principal salen marcados y bloqueados. Los campos que no se pueden modificar desde REST salen deshabilitados, con el motivo.
Dos botones de salida:
* **Aceptar:** inserta solo el código (las funciones `API_BeginAddRecord` / `API_BeginModifyRecord`, un `API_SetRecordFieldValue` por campo, `API_CommitSaveRecord` y el bloque de respuesta JSON).
* **Aceptar y Crear variables:** además da de alta las variables `V.*` correspondientes a cada campo.
El detalle de esas funciones está en la [referencia de funciones](/docs/desarrollo/flex/dinascript/funciones).
## Botones de la ventana [#botones-de-la-ventana]
| Botón | Qué hace |
| -------- | ------------------------------------------------------------- |
| Aceptar | Guarda el documento y cierra. |
| Aplicar | Guarda sin cerrar (solo al editar un documento existente). |
| Duplicar | Crea una copia con toda su configuración, código y variables. |
| Exportar | Exporta el documento. |
| Cancelar | Cierra sin guardar. |
Al aceptar, el código keyword se convierte a nativo y se validan las variables. Si la configuración de variables ocupa demasiado, el editor avisa y no guarda.
## Enlaces relacionados [#enlaces-relacionados]
* → [Documentos dinámicos: concepto y tipos](/docs/desarrollo/flex/documentos-dinamicos)
* → [Crear un documento dinámico: código y variables](/docs/desarrollo/flex/documentos-dinamicos/crear-documento-dinamico)
* → [Ejemplos completos](/docs/desarrollo/flex/documentos-dinamicos/ejemplos)
* → [Referencia de funciones (F.Write, API\_BeginAddRecord…)](/docs/desarrollo/flex/dinascript/funciones)
* → [Editor de scripts y algoritmos](/docs/desarrollo/recursos/dinaup-terminal/ventanas/editor-de-scripts-y-algoritmos)
# Editor de scripts y algoritmos (/docs/desarrollo/recursos/dinaup-terminal/ventanas/editor-de-scripts-y-algoritmos)
El Terminal trae un editor para escribir la lógica de tu solución. Con él creas scripts, que reaccionan a lo que pasa en un formulario, y algoritmos, que calculan valores. Esta página es la referencia de esa herramienta. Para el lenguaje en sí, ve a [DinaScript](/docs/desarrollo/flex/dinascript).
## El editor de scripts [#el-editor-de-scripts]
El área de escritura colorea la sintaxis y detecta errores mientras escribes. Debajo tienes el panel de errores: lista cada fallo con su número de línea, y al hacer clic saltas directo a esa línea.
El autocompletado te acompaña a medida que tecleas. Cuando escribes un prefijo y un punto (`S.`, `F.`, `V.`, `C.`…), te sugiere lo disponible en ese contexto. Y mientras escribes una función, te muestra sus parámetros. El catálogo completo está en la [referencia de funciones](/docs/desarrollo/flex/dinascript/funciones).
El panel de variables administra las variables locales del script. Con los atajos de teclado del editor revalidas el código y lo ejecutas sin salir de la pantalla.
## Cuándo se ejecuta un script [#cuándo-se-ejecuta-un-script]
El selector de evento decide cuándo corre el script. Según el evento que elijas, asocias uno o varios campos, o un informe. Estas son las familias de evento y cuándo disparan:
| Familia | Cuándo dispara |
| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
| Independiente | A demanda, sin ningún formulario abierto. |
| De formulario | Al crear un registro, antes de guardar, antes de cancelar, al cargar, en el recálculo periódico, al autoguardar o con un atajo de teclado. |
| De campo | Cuando un campo cambia, gana o pierde el foco, al abrir o cerrar una relación, o al filtrar un desplegable. |
| De informe | Sobre el informe entero o sobre las filas que el usuario ha seleccionado. |
Para el detalle conceptual de cada disparador, ve a [scripts](/docs/desarrollo/flex/scripts).
Algunas funciones solo tienen sentido en ciertos eventos, y el editor te lo avisa. Por ejemplo, filtrar un desplegable solo vale en el evento que filtra ese desplegable.
## Definir parámetros del script [#definir-parámetros-del-script]
Puedes declarar los parámetros que el script recibe. Mientras los usas dentro del código, el editor te muestra su información.
## El editor de algoritmos [#el-editor-de-algoritmos]
Un algoritmo se define en dos partes. La cabecera fija su identidad; el diseñador de fórmula, su cálculo.
En la cabecera indicas el nombre, la categoría y subcategoría, el rol (el tipo de dato que devuelve: texto, moneda, porcentaje…) y una descripción. El diseñador de fórmula es el editor DinaScript donde escribes el cálculo.
Al crear el algoritmo eliges su tipo. De él depende qué paneles aparecen:
| Tipo | Para qué sirve |
| ----------------- | ------------------------------------------------ |
| Lineal | Cálculo directo sobre una sección. |
| De dato | Devuelve un valor de un registro. |
| Compuesto | Cruza una sección principal con una relacionada. |
| De cálculo | Opera sobre resultados agregados. |
| De compatibilidad | Mantiene algoritmos de versiones anteriores. |
Según el tipo verás paneles de filtrado previo, criterios de relación (en los compuestos, entre la sección principal y la relacionada), orden y límites. Los conceptos de cada tipo están en [algoritmos](/docs/desarrollo/flex/algoritmos).
Además puedes configurar:
* **Referencia de fecha:** eliges un campo de fecha y el algoritmo filtra automáticamente por periodo.
* **Preguntas del algoritmo:** defines variables que el usuario responde justo al ejecutarlo.
## Probar y depurar [#probar-y-depurar]
* **Probar algoritmo:** lo ejecutas con datos reales y ves el resultado antes de guardarlo. Si tiene preguntas o referencia de fecha, el editor te las pide primero.
* **Ver el SQL:** muestra, ya formateada, la consulta que Dinaup genera a partir de tu algoritmo. Útil para entender o depurar qué hace por dentro.
Para probar el algoritmo o ver su SQL cuando tiene preguntas, primero tienes que guardarlo.
Cada variable que definas debe usarse en alguna fórmula. Si sobra una, el editor no te deja guardar.
## Enlaces relacionados [#enlaces-relacionados]
* → [DinaScript, el lenguaje](/docs/desarrollo/flex/dinascript)
* → [Referencia de funciones](/docs/desarrollo/flex/dinascript/funciones)
* → [Scripts: los disparadores](/docs/desarrollo/flex/scripts)
* → [Algoritmos: los tipos](/docs/desarrollo/flex/algoritmos)
# Gestión de archivos (/docs/desarrollo/recursos/dinaup-terminal/ventanas/gestion-de-archivos)
Cada campo de rol Archivo o Imagen guarda su contenido como un archivo del sistema. El Terminal lo maneja con cuatro ventanas encadenadas: Administrador de archivos, Subir archivo, Detalles de archivo y Vista previa.
Estas ventanas son la interfaz del operador. Para servir un archivo a alguien sin sesión (web pública, email, documento), no se usan aquí sino la función `SignFileURL`.
## Administrador de archivos [#administrador-de-archivos]
Lista todos los archivos e imágenes de una sección. Al pulsar un archivo se abre su ventana de Detalles.
| Elemento | Qué hace |
| --------------------- | ------------------------------------------------------------------------------------------------------- |
| Casilla **Ver todos** | Por defecto solo muestra la última versión de cada archivo. Activada muestra el histórico de versiones. |
| Arrastrar y soltar | Acepta soltar archivos sobre la lista para subirlos directamente. |
| Botón **Cerrar** | Cierra la ventana. |
## Subir archivo [#subir-archivo]
Ventana modal que sube el archivo al almacenamiento en segundo plano. Muestra el progreso de cada subida y no tiene más opción que el botón **Cancelar**, que aborta la subida en curso.
* **Deduplicación.** Antes de subir calcula la huella del archivo. Si el servidor ya lo tiene, lo reutiliza sin volver a subirlo.
* **Imágenes.** Genera y sube varios tamaños a la vez. Si no es imagen, sube el archivo tal cual.
* **Tamaño máximo.** Rechaza los archivos muy grandes con el aviso *La imagen es demasiado grande.*
## Detalles de archivo [#detalles-de-archivo]
Muestra la miniatura del archivo y una ficha de metadatos:
| Dato | Contenido |
| ----------------------------------------- | ---------------------------------------------- |
| Nombre / Nombre Original | Nombre en el sistema y el original al subirlo. |
| Ruta Original | Ruta de origen del archivo. |
| Tamaño | Tamaño formateado. |
| Extensión / Formato | Extensión y formato detectado. |
| Fecha de creación / modificación / subida | Fechas del archivo (subida en hora local). |
| Resolución / EsFlat | Solo imágenes: ancho por alto y si es plana. |
Si consta el usuario, muestra el empleado que subió el archivo con su avatar y nombre.
### Acciones [#acciones]
| Botón | Qué hace |
| ---------------- | ------------------------------------------------------------------------------ |
| **Descargar** | Descarga el archivo. Se habilita según el permiso del servidor. |
| **Vista previa** | Abre la ventana de Vista previa. Solo si el archivo la soporta en el Terminal. |
| **Copiar ID** | Copia el identificador del archivo al portapapeles. |
Si no tienes permiso de descarga, el Terminal responde *No tiene permisos para descargar este archivo.* El servidor revalida el permiso al servir el archivo, no solo al abrir la ventana.
* **Otras versiones.** Lista el histórico de versiones del mismo archivo. Al elegir otra versión, recarga la ficha para esa versión.
* **Comentarios internos.** Panel de comentarios sobre el archivo, sujeto a permisos para verlos y comentar.
* **Exportar en módulos** (solo desarrolladores). Marca si el archivo se incluye al empaquetar un módulo.
## Vista previa [#vista-previa]
Visor incrustado que muestra imágenes y PDFs a pantalla completa. Para imágenes pide al servidor el tamaño Original.
| Atajo | Acción |
| --------------- | ------------------------------------------------------ |
| Escape | Cierra la ventana. |
| F2 (**Fijar**) | Ancla la ventana arriba a la derecha, siempre visible. |
| F3 (**Venta**) | Crea un registro de venta a partir del archivo. |
| F4 (**Compra**) | Crea un registro de compra a partir del archivo. |
Los atajos **Venta** y **Compra** solo aparecen si tienes permiso para agregar en esas secciones. Con Shift al abrir, la ventana arranca ya en modo fijado.
## Formatos y tamaños [#formatos-y-tamaños]
Al subir una imagen, el sistema genera y almacena varios tamaños. Al descargar o previsualizar se pide el que corresponda: miniatura para la lista, Original para la vista previa.
Los tamaños disponibles (alto en píxeles) son **Original**, **32**, **100**, **300**, **720** y **1080**. Son los mismos valores que acepta el parámetro `tamaño` de `SignFileURL`.
Estas ventanas son para el operador del Terminal. Para acceder a un archivo por código sin sesión de usuario, usa la función DinaScript `SignFileURL`.
## Relacionado [#relacionado]
→ [Roles de campo: Archivo](/docs/desarrollo/flex/roles-de-campo)
→ [SignFileURL: servir archivos por código](/docs/desarrollo/flex/dinascript/funciones/documentos-y-graficos)
→ [Dinaup Terminal](/docs/desarrollo/recursos/dinaup-terminal)
→ [Diseñar secciones y campos](/docs/desarrollo/recursos/dinaup-terminal/ventanas/disenar-secciones-y-campos)
# Instalar y gestionar módulos (/docs/desarrollo/recursos/dinaup-terminal/ventanas/instalar-y-gestionar-modulos)
El Terminal tiene tres ventanas para instalar y mantener módulos. La galería elige qué instalar, la ventana de instalación ejecuta el plan, y la de Integridad repara objetos rotos. Es el reverso de [publicar un módulo](/docs/desarrollo/recursos/dinaup-terminal/ventanas/publicar-un-modulo), que cubre el lado productor. El concepto está en [módulos y canales](/docs/desarrollo/recursos/dinaup-terminal/modulos-y-canales).
## Dónde se abre cada ventana [#dónde-se-abre-cada-ventana]
| Ventana | Cómo llegas |
| ---------------------------------------- | ------------------------------------------------------------------------------- |
| Galería (**Dinaup Módulos**) | Configuración global → **Módulos**, o desde la ventana de Módulos en desarrollo |
| Instalación (**Instalación de módulos**) | Se abre sola al instalar desde la galería |
| Integridad (**Integridad Sistema**) | Panel principal, acción Errores del panel de widgets |
## La galería de módulos disponibles [#la-galería-de-módulos-disponibles]
La ventana **Dinaup Módulos** (subtítulo *Panel de gestión de Módulos Dinaup*) lista todo lo que puedes instalar. Mientras carga muestra *Cargando galería...*.
La lista se agrupa por módulo y muestra la versión más reciente disponible en tu canal. Columnas:
| Columna | Qué muestra |
| --------- | -------------------------------- |
| Estado | Badge azul **Disponible** |
| Módulo | Nombre del módulo |
| Versión | Versión más reciente en tu canal |
| Autor | Quién lo publicó |
| Publicado | Fecha de publicación |
| Canal | Canal de distribución del módulo |
El canal queda fijado por tu licencia: la galería solo muestra los módulos de ese canal. Para entender qué implica cada canal, consulta [módulos y canales](/docs/desarrollo/recursos/dinaup-terminal/modulos-y-canales).
Botones del pie:
* **Instalar Selección**: instala la fila marcada.
* **Visitar galeria de módulos**: abre la galería web en [www.dinaup.com/modulos](http://www.dinaup.com/modulos).
* **Cerrar**: cierra la ventana.
Para instalar haz doble clic sobre una fila, o márcala y pulsa **Instalar Selección**. Si no hay nada seleccionado, avisa: *Debe seleccionar al menos un elemento del listado*.
Al cerrar la galería, si has instalado algún módulo, el Terminal se reinicia solo para aplicar los cambios. Guarda tu trabajo antes.
## La ventana de instalación [#la-ventana-de-instalación]
Al lanzar la instalación se abre **Instalación de módulos**. Primero muestra *Cargando información necesaria...* mientras el servidor calcula el plan.
La cabecera resume el módulo: su icono, el nombre grande, la etiqueta **Desarrollado por:** con el autor y la versión (formato `vN`, por ejemplo `v2`).
Debajo va el plan de instalación, con una fila por cada pieza que hace falta:
| Columna | Qué muestra |
| ------- | ----------------------------------------- |
| Módulo | Pieza a instalar |
| Versión | Versión que se instalará |
| Estado | **Pendiente de instalar** (badge naranja) |
| Acción | Qué se hará con esa pieza |
Pulsa **Instalar módulos necesarios** para ejecutar el plan. El servidor resuelve las dependencias, descarga e instala, y al terminar bien la ventana se cierra sola. Mientras trabaja, el botón cambia a **Instalando** y la lista se bloquea para que no lances la instalación dos veces.
No puedes instalar dos módulos a la vez. Si ya hay uno en proceso, verás *Ya existe otro módulo en proceso de instalación*. En modo seguro tampoco se instala: cierra y reabre la ventana.
### Progreso cuando toca la base de datos [#progreso-cuando-toca-la-base-de-datos]
Si la instalación modifica la base de datos, aparece una ventana de progreso con avance por fases. Muestra tres fases que se marcan al completarse, una barra de porcentaje global y un contador de sub-acción del tipo *tantos de tantos*. Puede pedirte la contraseña de administrador para instalar o actualizar la base de datos.
## Reparar la integridad de objetos [#reparar-la-integridad-de-objetos]
La ventana **Integridad Sistema** localiza y arregla objetos rotos o con avisos: campos, algoritmos, secciones, destinaciones, scripts, informes y columnas. Su título es dinámico y resume la salud del sistema (errores, avisos e ignorados). Mientras calcula muestra *Comprobando integridad...*.
Columnas de la lista:
| Columna | Qué muestra |
| -------- | ----------------------------- |
| Nombre | Nombre del objeto |
| Tipo | Clase de objeto, con su icono |
| Seccion | Sección a la que pertenece |
| Tipo Adv | Tipo de aviso |
| Error ID | Identificador del error |
| Error | Descripción del problema |
Sobre el objeto seleccionado tienes tres acciones:
* **Autorreparar**: solo aparece si el error tiene una reparación automática conocida. Cubre casos como el nombre de una columna, la relación con la base, las etiquetas singular y plural invertidas, o quitar el icono de un campo.
* **Eliminar**: solo se ofrece cuando es seguro (ver aviso).
* **Aceptar**: cierra la ventana.
Atajos de teclado:
| Tecla | Acción |
| ----- | -------------------------------------------- |
| F4 | Desactiva el aviso seleccionado |
| F5 | Recalcula la integridad de todos los objetos |
| Supr | Elimina el objeto seleccionado, si es seguro |
No puedes eliminar un objeto publicado en un módulo, ni uno con referencias externas. Al borrar una sección se marcan también como eliminados sus campos, informes, algoritmos, scripts, destinadores y catálogos, previa confirmación.
Cada vez que reparas o eliminas, la lista se recarga y los contadores del título reflejan la nueva situación.
## Para seguir [#para-seguir]
* → [Módulos y canales](/docs/desarrollo/recursos/dinaup-terminal/modulos-y-canales)
* → [Publicar un módulo](/docs/desarrollo/recursos/dinaup-terminal/ventanas/publicar-un-modulo)
* → [Flujo de desarrollo](/docs/desarrollo/recursos/dinaup-terminal/flujo-de-desarrollo)
# Permisos y roles (/docs/desarrollo/recursos/dinaup-terminal/ventanas/permisos-y-roles)
Esta pantalla del Terminal (Configuración > Roles) administra un rol y define, sección por sección, qué puede hacer quien lo tenga asignado. Aquí tienes la referencia de todas sus opciones.
No es el concepto de usuarios y niveles ni el cómo asignar roles. Para eso:
* El recorrido completo de niveles, permisos y roles → [Usuarios, roles y permisos](/docs/guias/usuarios-roles-y-permisos)
* Los pasos generales y cómo asignar un rol a un usuario → [Permisos y roles](/docs/cuenta/permisos-y-roles)
Editar un rol afecta a todos los usuarios que lo tienen asignado. Un cambio aquí se aplica a todos ellos a la vez.
## Cabecera y controles del rol [#cabecera-y-controles-del-rol]
| Control | Qué hace |
| ------------------ | ----------------------------------------------------------------------- |
| Rol a gestionar | Nombre del rol que estás editando. |
| Todos los Permisos | Concede acceso total. Al activarlo se oculta el resto de configuración. |
| Ver auto-generados | Muestra también las secciones generadas de forma automática. |
| ¿Qué configurar? | Cambia entre dos modos: Secciones y Avanzado. |
| Opciones... | Menú con Administrar Secciones y Acceso Total. |
El pie tiene tres acciones: **Aplicar** (guarda sin cerrar), **Guardar** (guarda y cierra) y **Cancelar** o **Cerrar** según haya cambios pendientes.
## Modo Secciones [#modo-secciones]
En el panel izquierdo aparecen solo las secciones activadas en el rol, con sus columnas ID, Nombre y Módulo. Si está vacío, el rol no tiene ninguna sección. Las secciones se añaden y quitan desde Administrar Secciones. Un icono junto a cada fila abre el registro de esa sección.
### Permisos por sección [#permisos-por-sección]
Al seleccionar una sección aparece su matriz de permisos. Cada permiso se activa o desactiva por separado.
| Permiso | Qué habilita |
| ------------------------------ | ------------------------------------------------------ |
| Agregar | Crear registros nuevos en la sección. |
| Acceso | Entrar en la sección y ver sus registros. |
| Modificar | Editar registros existentes. |
| Ver eliminados | Ver los registros que están eliminados. |
| Eliminar | Eliminar registros. |
| Restaurar | Recuperar registros eliminados. |
| Ver histórico | Consultar el histórico de cambios del registro. |
| Compartir por chat | Enviar registros por el chat interno. |
| Imprimir | Imprimir el listado de la sección. |
| Exportar | Exportar el listado de la sección. |
| Ver comentarios | Leer los comentarios de los registros. |
| Comentar | Escribir comentarios en los registros. |
| Imprimir registro | Imprimir un registro concreto. |
| Opciones de control de lectura | Marcar registros como leídos y ver quién los ha leído. |
Dos botones aplican combinaciones de golpe:
| Botón | Qué activa |
| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Todo | Todos los permisos de la sección. |
| Solo lectura | Solo los de consulta (Acceso, Ver histórico, Ver comentarios, Comentar, Imprimir y Exportar listado, Imprimir registro, Opciones de control de lectura). Desactiva los de escritura. |
Si una sección queda sin Acceso ni Agregar, su fila se muestra bloqueada y rayada: el rol no puede hacer nada en ella.
### Informes y diseño por sección [#informes-y-diseño-por-sección]
Cada sección tiene ajustes propios de presentación:
| Ajuste | Qué controla |
| ---------------------------- | ------------------------------------------------------------------------------------------- |
| Informe Principal | Informe que ve el rol al abrir un registro. |
| Informe Búsqueda | Informe usado en la búsqueda de la sección. |
| Informe Principal Lista | Informe de lista, solo si la sección contiene lista. |
| Configuración predeterminada | Dos selectores: el diseño que ve el rol al crear (Agregar) y al editar (Editar). |
| Condición | Filtra a qué registros accede el rol dentro de la sección: por registro, grupo o condición. |
El diseño que fija Configuración predeterminada se crea aparte → [Crear un diseño de sección](/docs/cuenta/permisos-y-roles/crear-diseno-de-seccion).
## Administrar Secciones [#administrar-secciones]
Se abre desde **Opciones... > Administrar Secciones** (no está disponible con Todos los Permisos activado). Lista todas las secciones configurables, agrupadas por tipo y por módulo.
Cada sección tiene un conmutador con dos estados: **Accesible** y **Sin Acceso**. Al guardar, las secciones marcadas Accesible se añaden al rol y las demás se quitan.
## Modo Avanzado [#modo-avanzado]
El modo Avanzado reúne casillas que afectan a todo el rol, no a una sección concreta.
Los textos exactos de estas casillas pueden variar en pantalla. Ábrela en el Terminal para contrastarlos.
* **Sesión**: Administrar sesiones (ver favoritos e histórico de otros usuarios y finalizar sus sesiones y turnos), Importador de datos.
* **Ocultar accesos**: Ocultar acceso a informes, a históricos y a configuración; Ocultar registros y comentarios internos.
* **Bloqueos del alta**: Bloquear campos de autor del alta, campos de fecha de alta y el campo de ubicación principal; Bloquear históricos.
* **Disposiciones**: Administrar disposiciones públicas, Administrar disposiciones personales.
* **Datos relacionados**: Bloquear datos relacionados de informes, relaciones o datos. Marcar Bloquear todo fuerza y deshabilita las opciones individuales.
## Presets de rol [#presets-de-rol]
Al pulsar el botón de presets se abre una ventana que aplica un conjunto de permisos de golpe a todo el rol.
| Preset | Estado |
| ---------------------------- | ----------------------------------------- |
| Ninguno | Operativo. Deja el rol sin acceso a nada. |
| Máximo | Operativo. Concede acceso total. |
| Privada, Compañeros, Pública | No disponibles todavía en esta versión. |
Además, **Opciones... > Acceso Total** aplica el preset Máximo a las secciones seleccionadas o a todas.
## Empieza por el mínimo [#empieza-por-el-mínimo]
La ventana está pensada para conceder lo justo. Una sección nueva entra Sin Acceso por defecto, tienes el botón Solo lectura para dar solo consulta, y los presets van de Ninguno a Máximo.
Recomendación: activa solo las secciones y permisos que el rol necesite, y usa Solo lectura salvo que haga falta escritura. Es el mismo principio de empezar por el nivel más bajo que se explica en la [guía de usuarios, roles y permisos](/docs/guias/usuarios-roles-y-permisos).
La Condición de acceso permite además agrupar registros de forma dinámica para condicionar a cuáles llega el rol; es un ajuste de acceso, no una tabla de permisos.
## Relacionado [#relacionado]
* → [Permisos y roles: pasos y asignación](/docs/cuenta/permisos-y-roles)
* → [Usuarios, roles y permisos](/docs/guias/usuarios-roles-y-permisos)
* → [Crear un diseño de sección](/docs/cuenta/permisos-y-roles/crear-diseno-de-seccion)
* → [Cómo crear y asignar roles de usuario](/docs/cuenta/permisos-y-roles/como-crear-y-asignar-roles-de-usuario-en-dinaup)
* → [Diseñar secciones y campos](/docs/desarrollo/recursos/dinaup-terminal/ventanas/disenar-secciones-y-campos)
# Publicar un módulo (/docs/desarrollo/recursos/dinaup-terminal/ventanas/publicar-un-modulo)
Cuando tu trabajo en Flex está listo, lo empaquetas como módulo y lo publicas por un canal. Esta página es la referencia de la ventana de publicación: qué pide, cómo decide la versión y por qué a veces no puedes publicar. Para el concepto de módulos y canales, ve a [Módulos y canales](/docs/desarrollo/recursos/dinaup-terminal/modulos-y-canales); para el ciclo completo, a [Flujo de desarrollo](/docs/desarrollo/recursos/dinaup-terminal/flujo-de-desarrollo).
## La ventana de publicación [#la-ventana-de-publicación]
Accedes desde el **Estado módulo**, con el botón **Publicar módulo**. La ventana pide cuatro cosas y tiene dos botones: **Publicar módulo** y **Cancelar**.
Mientras se envía, los controles se bloquean. Así no publicas dos veces por error.
## Los cuatro campos [#los-cuatro-campos]
| Campo | Qué es | ¿Lo editas? |
| --------------------------------------- | -------------------------------------------------------------------- | ----------------------------- |
| Nombre del módulo | El del módulo en desarrollo. Solo hay un módulo activo por licencia. | No. Lo determina tu proyecto. |
| Versión | El número que tendrá esta publicación. | No. Se calcula sola. |
| Canal de publicación | Quién recibe el módulo: Desarrollo (dev), Beta o Estable (release). | Sí. Por defecto, Desarrollo. |
| Descripción de funcionalidad del módulo | Resume qué trae el módulo para quien lo instale. | Sí. Es obligatoria. |
El nombre del módulo no puede ser numérico.
**Cómo se calcula la versión.** Terminal toma la más alta que ya exista del módulo, mirando todos los canales a la vez, y le suma uno. Si en desarrollo hay una v2 y en producción una v3, la siguiente es v4.
**Qué hace el canal.** El canal decide quién recibe el módulo. La versión es la misma se publique donde se publique. Elige el destino en [Módulos y canales](/docs/desarrollo/recursos/dinaup-terminal/modulos-y-canales).
**La descripción.** Escribe qué trae esta versión, para quien la instale o para tu yo del futuro. Admite textos largos.
## Antes de publicar: dependencias [#antes-de-publicar-dependencias]
Antes de dejarte publicar, Terminal comprueba que el módulo esté completo. Un módulo depende de piezas: secciones, campos, algoritmos, informes. Si alguna de ellas apunta a algo que no incluyes o que quedó huérfano, la publicación se bloquea hasta que lo resuelvas.
Esto evita el problema clásico: instalar un módulo que "casi" funciona porque le faltaba algo de origen.
Desde el **Estado módulo** puedes:
* Revisar la lista de lo que se va a exportar: secciones, campos, algoritmos e informes.
* En una actualización, ver qué ha cambiado respecto a la versión anterior.
* Revisar que las columnas de tus informes no dependan de otros módulos.
## Por qué a veces no puedes publicar [#por-qué-a-veces-no-puedes-publicar]
* Falta la descripción, que es obligatoria.
* Hay objetos rotos o dependencias sin resolver: arréglalos y vuelve.
* El nombre del módulo es numérico, y eso no se permite.
* Tu licencia no tiene el desarrollo de módulos activo.
## Qué pasa al publicar [#qué-pasa-al-publicar]
Al pulsar **Publicar módulo**, Terminal valida y envía el módulo; el empaquetado final lo hace el servidor. Si va bien, la ventana te lo confirma y el botón pasa a **Aceptar**. Si algo falla, te muestra el motivo y puedes reintentar.
En una actualización, la versión sube sola y es la misma para todos los canales. El canal solo decide el destino, no el número de versión.
## Siguiente paso [#siguiente-paso]
→ [Módulos y canales](/docs/desarrollo/recursos/dinaup-terminal/modulos-y-canales)
→ [Flujo de desarrollo](/docs/desarrollo/recursos/dinaup-terminal/flujo-de-desarrollo)
→ [Instalar Terminal y publicar un módulo](/docs/guias/instalar-terminal-y-publicar-modulo)
# Categorías de Compra (/docs/rtg/pymes/facturacion/compras/categorias-de-compra)
Una **categoría de compra** es una etiqueta que clasifica tus compras y gastos según su tipo o finalidad: suministros, servicios profesionales, alquiler, combustible, material de oficina, etc. Sirve para dos cosas a la vez: **analizar en qué gastas** y que cada gasto **se contabilice solo**, porque cada categoría puede ligarse a una cuenta contable.
Es el hermano de las [categorías de venta](/docs/rtg/pymes/facturacion/ventas/categorias-de-venta): funcionan igual, pero unas clasifican lo que entra y otras lo que sale.
***
## Para qué sirven [#para-qué-sirven]
* **Analizar tus gastos por tipo.** Saber cuánto se va en alquiler, en suministros o en servicios profesionales, en lugar de ver solo un total de compras.
* **Contabilizar automáticamente.** Si ligas una categoría a una cuenta contable, cada gasto que asignes a esa categoría se asienta en la cuenta correcta sin decidirlo factura a factura.
* **Detectar gastos sin clasificar.** Un gasto sin categoría no encaja en ningún informe. Tenerlos todos categorizados deja los libros listos para el asesor.
Cuando subes una factura de gasto en PDF, Dinaup propone una **categoría sugerida** junto al resto de datos. Tú revisas y confirmas.
***
## Categoría y cuenta contable [#categoría-y-cuenta-contable]
Una categoría de compra y una cuenta contable son cosas distintas que trabajan juntas:
| | Categoría de compra | Cuenta contable |
| ---------- | ------------------------------------------------ | --------------------------------------------- |
| Qué es | Una etiqueta de negocio para clasificar el gasto | La cuenta del plan contable donde se registra |
| Para quién | Para ti: análisis y control interno | Para la contabilidad y tu asesor |
| Relación | Se **liga** a una cuenta contable | Recibe los apuntes de las categorías ligadas |
Al asociar la categoría a una cuenta, el sistema sabe a qué cuenta del [plan contable](/docs/rtg/pymes/contabilidad) llevar cada gasto que clasifiques con ella. Así la categorización que haces pensando en tu negocio se traduce sola en un asiento correcto.
***
## Crear una categoría de compra [#crear-una-categoría-de-compra]
### Abre las categorías de compra [#abre-las-categorías-de-compra]
Ve a **Pymes → Compras y gastos** y entra en la configuración de **categorías de compra**.
### Añade una categoría nueva [#añade-una-categoría-nueva]
Crea la categoría y dale un nombre claro que identifique el tipo de gasto (por ejemplo, *Suministros*, *Alquiler* o *Servicios profesionales*). El nombre es lo que verás al clasificar cada compra, así que cuanto más reconocible, mejor.
### Lígala a una cuenta contable [#lígala-a-una-cuenta-contable]
Asocia la categoría a la **cuenta contable** que le corresponda. Es el paso que activa la contabilización automática: a partir de ahí, todo gasto que asignes a esta categoría se asienta en esa cuenta.
### Úsala al registrar gastos [#úsala-al-registrar-gastos]
Con la categoría creada, ya aparece como opción al registrar una compra o un gasto. Asígnala y el gasto queda clasificado para análisis y listo para contabilizar.
Crea pocas categorías y claras antes que muchas y solapadas. Un puñado de categorías bien definidas es más útil que una lista interminable donde nunca sabes cuál elegir.
***
## Cómo se usan en el día a día [#cómo-se-usan-en-el-día-a-día]
Cada vez que registras una compra o un gasto, le asignas su categoría. A partir de ese momento:
* El gasto **suma en su categoría** y aparece agrupado en los informes por tipo de gasto.
* Si la categoría está ligada a una cuenta, el gasto **se contabiliza solo** en la cuenta correcta.
* Al revisar el periodo, puedes detectar los **gastos sin categoría** y clasificarlos antes de cerrar.
***
## Preguntas frecuentes [#preguntas-frecuentes]
La categoría es una etiqueta de negocio que usas tú para clasificar el gasto por tipo. La cuenta contable es la cuenta del plan contable donde se registra. Ligas una categoría a una cuenta para que la clasificación se contabilice sola.
No. Puedes usar las categorías solo para analizar tus gastos por tipo. Ligarlas a una cuenta es lo que añade la contabilización automática, así que es muy recomendable si llevas la contabilidad en Dinaup.
Funcionan igual, pero clasifican cosas distintas: las de compra etiquetan tus gastos y las de venta etiquetan tus ingresos. Las dos sirven para analizar y para que la contabilización salga sola.
Las que necesites. Lo recomendable es mantener una lista corta y clara, con una categoría por cada tipo de gasto relevante de tu negocio.
***
→ [Gestión de compras y gastos](/docs/rtg/pymes/facturacion/compras/gestion-de-compras-y-gastos)
→ [Categorías de venta](/docs/rtg/pymes/facturacion/ventas/categorias-de-venta)
→ [Contabilidad](/docs/rtg/pymes/contabilidad)
# Gestión de Compras y Gastos (/docs/rtg/pymes/facturacion/compras/gestion-de-compras-y-gastos)
### Inicia sesión en Play.Dinaup.com [#inicia-sesión-en-playdinaupcom]
[Play.dinaup.com](https://play.dinaup.com/)
### Accede a la App de Pymes [#accede-a-la-app-de-pymes]
### Entra al apartado de "Gastos" [#entra-al-apartado-de-gastos]
# Compras (/docs/rtg/pymes/facturacion/compras)
Registro y gestión de facturas recibidas y gastos:
* [Categorías de Compra](/docs/rtg/pymes/facturacion/compras/categorias-de-compra): clasificación analítica.
* [Gestión de Compras y Gastos](/docs/rtg/pymes/facturacion/compras/gestion-de-compras-y-gastos): alta y trabajo diario.
# Categorías de Venta (/docs/rtg/pymes/facturacion/ventas/categorias-de-venta)
Una **categoría de venta** clasifica tus ventas e ingresos por línea de negocio o por tipo de producto o servicio. Es una etiqueta analítica: agrupa lo que facturas para que veas, por ejemplo, cuánto ingresas por "Servicios", cuánto por "Productos" y cuánto por "Cursos". También sirve para que la contabilización automática sepa a qué cuenta llevar cada venta.
No tiene nada que ver con el régimen fiscal de la factura: de eso se encarga el [tipo de venta](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos). La categoría dice **a qué línea de negocio pertenece** la venta; el tipo de venta dice **cómo se comporta fiscalmente**.
***
## Categoría de venta frente a tipo de venta [#categoría-de-venta-frente-a-tipo-de-venta]
Son dos clasificaciones distintas y complementarias. En una misma factura conviven las dos: el tipo de venta decide el IVA, las validaciones y la numeración; la categoría decide en qué grupo de negocio cuenta ese ingreso.
| | Categoría de venta | [Tipo de venta](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos) |
| -------------- | ------------------------------------------------- | ------------------------------------------------------------------------------ |
| Para qué sirve | Agrupar ventas por línea de negocio o producto | Definir el régimen fiscal y el comportamiento de la factura |
| Qué responde | "¿De qué es esta venta?" | "¿Cómo se factura esta venta?" |
| Ejemplos | Servicios, Productos, Cursos, Mantenimientos | Nacional, Simplificada, Intracomunitaria, OSS, Exportación |
| Dónde se usa | Informes de ingresos y contabilización automática | IVA, retenciones, validaciones de NIF, numeración |
Si nunca has separado tus ventas por línea de negocio, no pasa nada: puedes empezar con unas pocas categorías generales (por ejemplo "Productos" y "Servicios") y afinarlas más adelante.
***
## Para qué sirven [#para-qué-sirven]
Una categoría bien puesta trabaja para ti en dos sitios:
* **Análisis de ingresos**: los informes agrupan tus ventas por categoría, así que sabes qué línea de negocio te aporta más. En el informe de **Pérdidas y Ganancias** ves los ingresos repartidos por categoría, igual que los gastos.
* **Contabilización automática**: la categoría sirve de criterio para llevar cada venta a su cuenta contable. Cuando generas los asientos de forma masiva, Dinaup usa la categoría para asignar la cuenta de ingresos correcta sin que tengas que decidirlo factura a factura.
→ [Contabilidad y contabilización automática](/docs/rtg/pymes/contabilidad)
***
## Crear una categoría de venta [#crear-una-categoría-de-venta]
### Abre la configuración de ventas [#abre-la-configuración-de-ventas]
Ve a **Pymes → Configuras → Ventas**. Ahí gestionas los elementos que clasifican tu facturación, entre ellos las categorías de venta.
### Crea una categoría nueva [#crea-una-categoría-nueva]
Añade una categoría y dale un nombre claro que identifique la línea de negocio (por ejemplo, "Servicios profesionales" o "Venta de material"). El nombre es lo que verás luego en los informes, así que cuanto más reconocible, mejor.
### Asígnala a tus productos y servicios [#asígnala-a-tus-productos-y-servicios]
En la ficha de cada producto o servicio elige su categoría de venta. A partir de ahí, cada vez que vendas ese producto, la línea de la factura hereda la categoría: no tienes que indicarla a mano.
La categoría parte del producto, pero un **tipo de venta** puede sobrescribirla. Si configuras una categoría en la ficha de un tipo de venta, esa categoría sustituye a la del producto para todas las facturas de ese tipo. Útil cuando un mismo producto debe contar en líneas distintas según el escenario de venta.
***
## Cómo se asigna la categoría a una venta [#cómo-se-asigna-la-categoría-a-una-venta]
La categoría llega a la factura por sí sola, siguiendo este orden:
1. **Desde el producto o servicio**: cada línea hereda la categoría definida en la ficha del producto que vendes.
2. **Desde el tipo de venta** (si lo sobrescribe): si el tipo de venta tiene una categoría configurada, manda sobre la del producto.
3. **Ingresos sin factura**: un ingreso que no es una venta (una subvención, una devolución de impuestos) también puede clasificarse con su categoría para que cuente en el sitio correcto del análisis y la contabilidad.
Al analizar o contabilizar, cada venta ya está clasificada en su línea de negocio.
***
## Preguntas frecuentes [#preguntas-frecuentes]
La categoría clasifica la venta por línea de negocio o tipo de producto (para análisis y contabilización). El tipo de venta define el comportamiento fiscal de la factura: IVA, retenciones, validaciones de NIF y numeración. Son cosas distintas y conviven en la misma factura.
No. La categoría se hereda del producto o servicio que vendes, o del tipo de venta si lo sobrescribe. Solo defines la categoría una vez, en la ficha del producto.
Sirve de criterio en la contabilización automática: Dinaup usa la categoría para llevar cada venta a su cuenta de ingresos al generar los asientos de forma masiva.
Sí. Las compras y gastos se clasifican con [categorías de compra](/docs/rtg/pymes/facturacion/compras/categorias-de-compra), que funcionan igual pero para el lado de los gastos.
***
→ [Tipos de ventas e ingresos](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos)
→ [Categorías de compra](/docs/rtg/pymes/facturacion/compras/categorias-de-compra)
→ [Contabilidad](/docs/rtg/pymes/contabilidad)
# Devoluciones y Abonos (/docs/rtg/pymes/facturacion/ventas/devoluciones-y-abonos)
Cuando un cliente te devuelve mercancía o le reintegras un importe, no borras ni editas la venta original: creas una **devolución** ligada a ella. Esa devolución mueve el stock y el dinero en sentido contrario. A efectos fiscales, genera una **factura rectificativa** (el abono) que corrige la venta inicial.
Hay dos conceptos que conviene no mezclar:
* **Devolución**: el hecho real. La mercancía vuelve a tu almacén y/o le devuelves dinero al cliente.
* **Rectificativa**: el documento fiscal que respalda esa devolución. Es una factura con su propia numeración que rectifica la original.
Una devolución en Dinaup genera siempre su rectificativa: así el almacén, la tesorería y los libros oficiales cuadran a la vez.
***
## Devolución total o parcial [#devolución-total-o-parcial]
No tienes que devolver la venta entera. Al iniciar la devolución, eliges **cuántas unidades de cada línea** se devuelven:
* **Total**: devuelves todas las unidades de la venta. La rectificativa anula el importe completo.
* **Parcial**: devuelves solo parte (algunas unidades de una o varias líneas). La rectificativa corrige únicamente lo devuelto, y el resto de la venta sigue en pie.
Dinaup sabe en todo momento cuánto queda por devolver de cada producto: si ya rectificaste parte, solo te deja devolver lo que aún no habías devuelto. Así no puedes abonar de más por error.
***
## Cómo hacer una devolución [#cómo-hacer-una-devolución]
Una devolución se crea **desde la propia venta**, no como un documento suelto. Eso es lo que mantiene atada la trazabilidad: la rectificativa nace vinculada a la factura que corrige.
### Abre la venta a devolver [#abre-la-venta-a-devolver]
Localiza la factura de venta original y ábrela. Dentro verás su detalle, con el cobro, las salidas de mercancía y el bloque de **Devolución**.
### Inicia la devolución [#inicia-la-devolución]
Pulsa **Iniciar devolución**. Dinaup prepara una rectificativa **vinculada a esa venta**, que hereda el cliente, sus datos fiscales, los impuestos y el resto de condiciones de la factura original.
### Indica qué se devuelve [#indica-qué-se-devuelve]
Ajusta las unidades de cada línea que el cliente devuelve. Déjalas todas para una devolución total, o reduce las cantidades para una devolución parcial.
### Confirma la rectificativa [#confirma-la-rectificativa]
Al grabar, queda creada la factura rectificativa de abono. La mercancía devuelta vuelve a entrar en tu almacén y el importe queda registrado a favor del cliente.
La rectificativa se marca de forma bien visible con la etiqueta **Rectificativa** para que nadie la confunda con una venta normal.
***
## Qué cambia en stock y tesorería [#qué-cambia-en-stock-y-tesorería]
Una devolución es el reflejo en espejo de la venta:
| | En la venta | En la devolución |
| ------------- | ------------------------- | --------------------------------- |
| **Mercancía** | Sale del almacén (salida) | Vuelve al almacén (entrada) |
| **Dinero** | Lo cobras del cliente | Lo abonas / reintegras al cliente |
| **Documento** | Factura de venta | Factura rectificativa (abono) |
Al confirmar la devolución, el producto vuelve a estar disponible para vender y el saldo del cliente refleja el importe que le corresponde.
***
## La rectificativa: el documento fiscal [#la-rectificativa-el-documento-fiscal]
La **rectificativa** es el documento que hace válida la devolución de cara a Hacienda. Es una factura con serie y numeración propias que **corrige** la original.
Cuando inicias la devolución, eliges (o Dinaup propone) la forma de rectificar:
* **Por diferencias**: la rectificativa recoge solo lo que cambia respecto a la factura original (el importe devuelto). Es lo habitual en una devolución de mercancía.
* **Por sustitución**: la rectificativa reemplaza por completo la factura original por una nueva. Útil cuando la primera era inválida y hay que rehacerla entera.
**No puedes rectificar una rectificativa.** Si necesitas corregir de nuevo, crea una nueva rectificativa vinculada a la **factura original**, no a la de abono.
El tipo concreto de rectificativa (las claves R1, R2… y los criterios "por sustitución" / "por diferencias") es una cuestión fiscal que Dinaup gestiona por ti según el caso. El detalle de cada tipo está en la página de Verifactu.
→ [Verifactu y tipos de factura rectificativa](/docs/rtg/pymes/facturacion/ventas/verifactu)
***
## Trazabilidad: la venta y su abono, conectados [#trazabilidad-la-venta-y-su-abono-conectados]
Devolver desde la venta deja las dos **enlazadas**:
* Desde la **venta original** ves el historial de sus devoluciones: cada rectificativa con su estado, su número, su fecha, las unidades y el importe devuelto.
* Cada **rectificativa** apunta a la factura que corrige.
Así, ante cualquier revisión, sabes qué se devolvió, cuándo y contra qué venta. Nada queda huérfano: una venta parcialmente devuelta muestra tanto lo que se vendió como lo que volvió.
Puedes hacer **varias devoluciones parciales** sobre la misma venta a lo largo del tiempo. Todas se acumulan en el historial de esa factura, y Dinaup controla que entre todas no devuelvas más de lo vendido.
***
## Devoluciones en el TPV (cobro rápido) [#devoluciones-en-el-tpv-cobro-rápido]
En el TPV puedes resolver una devolución sin salir de la pantalla de cobro. Cuando una operación es una devolución, su total es **negativo**, y el cobro rápido cambia de modo: en lugar de "cobrar", **devuelve dinero**.
La pantalla se adapta para que el operario no tenga que hacer cuentas raras:
* En vez de **A cobrar**, ves **A devolver al cliente**.
* En vez de **Pago recibido**, tecleas el **dinero entregado al cliente** (siempre en positivo, sin signos).
* Dinaup calcula **lo que el cliente debe reintegrarte** si le entregas de más, igual que calcularía el cambio en una venta normal.
Esto registra el efectivo real que sale del cajón, de modo que el **arqueo de caja sigue cuadrando**: la devolución resta de la caja exactamente lo que entregaste.
Como el efectivo de una devolución **sale** de la caja, cuéntalo en el cierre igual que cuentas las entradas. El cierre lo tiene en cuenta para que el recuento físico cuadre con lo esperado.
→ [Cobrar en el TPV](/docs/rtg/tpv/procesos/cobro)
***
## Preguntas frecuentes [#preguntas-frecuentes]
La devolución es el hecho real: la mercancía vuelve y/o reintegras dinero. La rectificativa es el documento fiscal (una factura de abono con su propia numeración) que respalda esa devolución corrigiendo la venta original. En Dinaup, hacer una devolución genera su rectificativa.
Sí. Al iniciar la devolución eliges cuántas unidades de cada línea se devuelven. Puedes hacer varias devoluciones parciales sobre la misma factura; Dinaup controla que entre todas no superes lo vendido.
No. Abres la venta original, pulsas Iniciar devolución y Dinaup prepara la rectificativa ya vinculada, con el cliente, los impuestos y las condiciones heredados de la factura inicial.
No se puede rectificar una rectificativa. Crea una nueva rectificativa vinculada a la factura de venta original, no a la de abono.
Cuando la operación es una devolución, su total es negativo y la pantalla de cobro pasa a modo devolución: indica el dinero que entregas al cliente y Dinaup ajusta la caja. El efectivo sale del cajón, así que el cierre seguirá cuadrando.
La mercancía devuelta vuelve a entrar en tu almacén y queda otra vez disponible para vender. Es el movimiento inverso de la salida que provocó la venta.
***
→ [Ventana de Factura](/docs/rtg/pymes/facturacion/ventas/ventana-de-factura)
→ [Verifactu y rectificativas](/docs/rtg/pymes/facturacion/ventas/verifactu)
→ [Tipos de Ventas e Ingresos](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos)
→ [Cobrar en el TPV](/docs/rtg/tpv/procesos/cobro)
# Fechas en facturas (/docs/rtg/pymes/facturacion/ventas/fechas-en-facturas)
En Dinaup, cada factura (ya sea de **ventas** o de **compras**) utiliza tres fechas distintas, cada una con un propósito propio.
### 1. Fecha Principal [#1-fecha-principal]
Corresponde a la **fecha de expedición** de la factura, es decir, la que figura en el propio documento.
* Al crear una factura, Dinaup rellena este campo con la **fecha actual**.
* Si la factura incluye otra fecha, como “15 de enero”, esa es la que deberías indicar.
### 2. Fecha Contable [#2-fecha-contable]
Define el periodo en el que la factura se refleja en el **Libro Registro de Facturas** (tanto emitidas como recibidas).
* Si no indicas una fecha, Dinaup asigna la **fecha actual** al guardar.
* Si estás registrando una factura de un trimestre pasado pero necesitas declararla en el trimestre actual, asegúrate de que la **Fecha Contable** sea la del trimestre en curso.
### 3. Fecha de Operación [#3-fecha-de-operación]
Es la fecha en la que se realizó la operación (entrega del bien o prestación del servicio).
* Si no indicas ninguna, Dinaup utiliza la **Fecha Principal**.
* Solo necesitas modificarla cuando la fecha de expedición y la fecha de la operación no coinciden.
# Gestión Archivos (/docs/rtg/pymes/facturacion/ventas/gestion-archivos)
Los empleados cargan archivos en el sistema y quedan disponibles en una cola de revisión. Al pulsar el botón **“+”**, se abre el formulario con los campos ya completados por la IA.
El flujo es: se sube el archivo, la IA interpreta los datos clave y el responsable valida o descarta.
# Ventas (/docs/rtg/pymes/facturacion/ventas)
Emisión y gestión de facturas a clientes:
* [Tipos de Ventas e Ingresos](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos): nacional, intracomunitaria, exportación, OSS, etc.
* [Categorías de Venta](/docs/rtg/pymes/facturacion/ventas/categorias-de-venta): clasificación analítica.
* [Fechas en facturas](/docs/rtg/pymes/facturacion/ventas/fechas-en-facturas): fecha de expedición vs. fecha registro.
* [Libros Registro y Tipos de Venta](/docs/rtg/pymes/facturacion/ventas/libros-registro-y-tipos-de-venta): relación entre tipos y libros oficiales.
* [Verifactu](/docs/rtg/pymes/facturacion/ventas/verifactu): cumplimiento del Real Decreto 1007/2023.
* [Gestión Archivos](/docs/rtg/pymes/facturacion/ventas/gestion-archivos): buzón de documentos con IA.
* [Ventana de Factura](/docs/rtg/pymes/facturacion/ventas/ventana-de-factura): referencia de campos del formulario.
# Libros Registro y Tipos de Venta (/docs/rtg/pymes/facturacion/ventas/libros-registro-y-tipos-de-venta)
Tres conceptos que verás al facturar en Dinaup: **libros registro, tipos de venta y ventas**.
## Libros [#libros]
Un **libro registro** es el listado de todas tus facturas agrupadas por su naturaleza fiscal. Es la forma tradicional de clasificar la facturación para tenerla siempre lista ante Hacienda o tu asesoría. [Puedes exportar estos libros a Excel](/docs/rtg/pymes/procesos/exportacion).
| Ejemplo de libro registro | ¿Qué agrupa? |
| ---------------------------------- | ------------------------------------------- |
| **Ventas nacionales** | Facturas emitidas dentro de España. |
| **Ventas simplificadas (tickets)** | Facturas simplificadas o tickets. |
| **Ventas intracomunitarias** | Facturas a clientes de la UE con NIF-IVA. |
| **Exportaciones fuera de la UE** | Operaciones con clientes extracomunitarios. |
Desde `Pymes` > `Configuras` > `Ventas` > `Libros de venta` puedes crear libros nuevos y editar los existentes.
## Tipos [#tipos]
Un **tipo de venta** no es un libro registro, sino la *configuración* que determina cómo se comporta cada factura dentro de Dinaup.
| Ejemplo de tipo | ¿Qué hace diferente? |
| ---------------------------- | ------------------------------------------------- |
| **Factura simplificada** | Usa una serie numérica específica. |
| **Venta online** | Aplica una plantilla de impresión distinta. |
| **Factura intracomunitaria** | Activa *inversión del sujeto pasivo* por defecto. |
Puedes crear tantos tipos de venta como necesites, uno por cada escenario fiscal o flujo habitual. Cada vez que factures, eliges el tipo y Dinaup rellena el resto.
# Presupuestos (/docs/rtg/pymes/facturacion/ventas/presupuestos)
Un **presupuesto** es la oferta que mandas a un cliente antes de vender: los conceptos, sus precios y el total, sin efecto fiscal. Es el primer paso de la pre-venta. Cuando el cliente lo acepta, el presupuesto se convierte en [pedido](/docs/rtg/pymes/inventario-y-precios/gestion-de-pedidos) o directamente en [venta](/docs/rtg/pymes/facturacion/ventas).
Llegas desde **Pymes → Pre Venta → Presupuestos**.
***
## Qué ves en la pantalla [#qué-ves-en-la-pantalla]
La pantalla organiza los presupuestos en pestañas:
| Pestaña | Qué muestra |
| ---------------- | -------------------------------------------------------------- |
| **Presupuestos** | El listado de presupuestos con sus importes, estados y fechas. |
| **Notas** | Anotaciones y ayuda de la sección. |
Desde el listado filtras y buscas para localizar un presupuesto concreto, y lo abres para editarlo o cambiarle el estado.
***
## Qué acciones tienes [#qué-acciones-tienes]
En la barra de herramientas aparece **un botón por cada tipo de venta** que tengas habilitado. Cada botón abre la ventana de presupuesto con ese tipo ya aplicado (numeración, serie e impuestos). Si un tipo está marcado como táctil, su botón usa el modo TPV.
Los botones que ves dependen de tus [tipos de ventas e ingresos](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos). Si no aparece ninguno, crea o habilita un tipo de venta primero.
***
## Del presupuesto a la venta [#del-presupuesto-a-la-venta]
El presupuesto no factura: es una propuesta. Su recorrido habitual es:
1. **Creas el presupuesto** con el botón de su tipo y se lo envías al cliente.
2. **El cliente lo acepta.**
3. **Lo conviertes** en un [pedido](/docs/rtg/pymes/inventario-y-precios/gestion-de-pedidos) (si hay que preparar o servir algo) o directamente en una [factura de venta](/docs/rtg/pymes/facturacion/ventas).
***
## Preguntas frecuentes [#preguntas-frecuentes]
No. Es una oferta sin efecto fiscal ni de inventario. El stock se mueve y la factura se emite cuando el presupuesto se convierte en venta.
Porque no tienes ningún tipo de venta habilitado. Los botones de la barra salen de tus tipos de ventas e ingresos: crea o activa uno y aparecerá.
***
→ [Gestión de pedidos](/docs/rtg/pymes/inventario-y-precios/gestion-de-pedidos)
→ [Facturación de ventas](/docs/rtg/pymes/facturacion/ventas)
→ [Tipos de ventas e ingresos](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos)
# Ventana de Factura (/docs/rtg/pymes/facturacion/ventas/ventana-de-factura)
## Fechas [#fechas]
1. **Fecha de Expedición**
1. Si se deja vacía se asigna la fecha actual en el momento de guardar
2. **Fecha Registro**
1. Si se deja vacía se asigna la fecha de expedición.
# Verifactu (/docs/rtg/pymes/facturacion/ventas/verifactu)
Con el cumplimiento en Verifactu, la ventana de factura cambia: algunos campos pasan a ser obligatorios, otros se bloquean y, al aceptar, Dinaup comprueba que el registro sea válido antes de firmarlo y enviarlo a la AEAT. Esta página es la referencia de ese comportamiento y de las claves de tipo de factura. Para activar Verifactu y seguir el estado de los envíos, ver la [guía de facturación y Verifactu](/docs/guias/verifactu).
***
## Qué cambia en la ventana de factura [#qué-cambia-en-la-ventana-de-factura]
Dinaup ajusta la ventana en cuanto la empresa factura bajo Verifactu. No son errores: es el formulario guiándote hacia un registro válido.
| Comportamiento | Cuándo ocurre |
| ------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------- |
| **Serie**, **Número**, **Número completo** y **ES - Tipo de Factura** pasan a obligatorios | Cuando escribes la numeración a mano en vez de elegir una serie de numeración automática. |
| **Serie** y **Número** se bloquean como "Automático" | Cuando la factura tiene una serie de numeración asignada: los rellena la serie, no tú. |
| **NIF** y **Nombre del emisor** (tercero) se vacían y bloquean | Mientras **Expedida por tercero** no esté marcada. Al marcarla, ambos pasan a ser exigidos. |
| Los **datos fiscales del receptor** se vacían y bloquean | Cuando el tipo es **F2** o **R5** (simplificadas): una factura simplificada no identifica al destinatario. |
## Comprobaciones al aceptar [#comprobaciones-al-aceptar]
Al aceptar la factura, Dinaup valida el registro. Si algo no cuadra, muestra el motivo y no guarda; el mismo control aplica a las escrituras por API.
| Comprobación | Qué exige |
| --------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Numeración completa** | Si rellenas alguno de **Número**, **Serie** o **Número completo**, deben estar los tres. |
| **Expedida por tercero** | Con la casilla marcada, **NIF del emisor** y **Nombre del emisor** son obligatorios. |
| **Coherencia del tipo** | Una factura **rectificativa** debe llevar clave **R1–R5**; una no rectificativa, **F1–F3**. |
| **Impuestos preparados para Verifactu** | Cada impuesto usado en la venta debe tener valor en **ES - Tipo**, **ES - Clasificación de la Operación**, **ES - Clave de Régimen** y **ES - Causa de Sujeción**. Se corrige en la ficha del [impuesto](/docs/rtg/pymes/configuracion/impuestos), no en la factura. |
## Una vez enviada a la AEAT [#una-vez-enviada-a-la-aeat]
Un registro remitido a la AEAT deja de ser editable: los campos que alteran importes (descuentos, retención, inclusión de impuestos, recargo de equivalencia) se bloquean con el motivo a la vista. Si necesitas corregir la operación, el camino es una **factura rectificativa**, no editar la original. La única excepción es una factura cuyo envío quedó **Rechazada**: esa sí se corrige y se reenvía, como cuenta la [guía de Verifactu](/docs/guias/verifactu).
***
## Tipos de factura: claves de la AEAT [#tipos-de-factura-claves-de-la-aeat]
El campo **ES - Tipo de Factura** clasifica el registro ante la AEAT. Claves para facturas normales:
| Clave | Cuándo se usa |
| ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **F1** | Factura completa (arts. 6, 7.2 y 7.3 del RD 1619/2012), con destinatario identificado. Incluye las simplificadas *cualificadas* que sí identifican al destinatario. |
| **F2** | Factura simplificada o sin identificación del destinatario (art. 6.1.d del RD 1619/2012). |
| **F3** | Factura emitida en sustitución de facturas simplificadas ya facturadas y declaradas. |
Y para rectificativas:
| Clave | Cuándo se usa |
| ------ | ------------------------------------------------------------------------------------------------------------------------------------ |
| **R1** | Error fundado en derecho o causas del art. 80 Uno, Dos y Seis LIVA: devoluciones, descuentos posteriores, resolución de operaciones. |
| **R2** | Modificación de la base imponible por concurso de acreedores (art. 80.Tres LIVA). |
| **R3** | Modificación de la base imponible por crédito incobrable (art. 80.Cuatro LIVA). |
| **R4** | El resto: modificaciones fuera del art. 80 sin error fundado en derecho, o error en datos no monetarios. |
| **R5** | Rectificación de una factura simplificada, sea cual sea el motivo. |
### Notas sobre rectificativas [#notas-sobre-rectificativas]
* Las rectificativas llevan **serie específica** y se identifican como rectificación **"S" por sustitución** o **"I" por diferencias**.
* Como **fecha de operación** se indica la de la entrega o prestación original; si una rectificativa corrige varias facturas, la más reciente.
* La devolución de mercancías o envases con ocasión de un suministro posterior al mismo destinatario y tipo no exige rectificativa: se resta del importe de esa operación posterior.
* Identificar las facturas rectificadas es opcional; si se identifican, se informa su número y fecha de expedición.
***
→ [Guía: activar Verifactu y resolver rechazos](/docs/guias/verifactu)
→ [Emisión de facturas](/docs/rtg/pymes/procesos/emision-de-facturas)
→ [Impuestos](/docs/rtg/pymes/configuracion/impuestos)
→ [QR Verifactu en documentos dinámicos](/docs/desarrollo/flex/documentos-dinamicos/qr-verifactu)
# Emitir Factura con Suplidos (/docs/rtg/pymes/procesos/emision-de-facturas/emitir-factura-con-suplidos)
Las **ventas con gastos suplidos** son aquellas en las que facturas al cliente un importe que no es un ingreso propio de la empresa. Es dinero pagado en nombre del cliente: tasas, registros o servicios de terceros. El importe se traslada al cliente **sin aplicar margen comercial ni impuestos**, ya que la empresa actúa como intermediaria. Para que Dinaup gestione bien este tipo de ventas, configura la categoría y el impuesto correspondientes.
## Registrar una venta con gastos suplidos [#registrar-una-venta-con-gastos-suplidos]
Agrega el gasto suplido como concepto en la factura y selecciona el impuesto `Suplido` y la categoría `Suplido`.
## Gasto suplido en análisis [#gasto-suplido-en-análisis]
El importe del suplido **no se suma a las ventas ni al beneficio**, pero sí aparece en “**Suplidos Ventas**” para dejar constancia de lo que el cliente debe reembolsar.
***
*⚠️ Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
# Emitir Factura Exportación (/docs/rtg/pymes/procesos/emision-de-facturas/emitir-factura-exportacion)
En Dinaup, las **exportaciones** son operaciones de venta realizadas **a clientes fuera de la Unión Europea**. Estas operaciones están **exentas de IVA**, según el **artículo 21 de la Ley del IVA**, siempre que puedas acreditar que los bienes han salido efectivamente del territorio aduanero de la UE.
## Requisitos [#requisitos]
1. Un **libro registro de facturas** exportaciones: [Libro de Ventas Exportaciones](/docs/rtg/pymes/libros-registros-de-venta/libro-de-ventas-exportaciones)
2. Un [**impuesto**](/docs/rtg/pymes/configuracion/impuestos) específico.
3. Un **tipo de Venta**: [Tipo de Venta: Exportación](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-exportacion)
***
*⚠️ Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
# Emitir Factura Intracomunitarias (/docs/rtg/pymes/procesos/emision-de-facturas/emitir-factura-intracomunitarias)
En Dinaup, las **ventas intracomunitarias** son, por defecto, **entregas o servicios realizados a clientes de la UE que están dados de alta en el VIES**.
No deben confundirse con:
* Las [**ventas OSS**](/docs/rtg/pymes/procesos/emision-de-facturas/emitir-factura-oss), que aunque se hagan a países de la UE, **siguen un régimen distinto** y se declaran aparte.
* Las **ventas a particulares (B2C)** en la UE, cuando el cliente **no tiene NIF-IVA intracomunitario**. En estos casos, la operación se **registra como nacional**, aplicando el **IVA español**.
## Requisitos [#requisitos]
1. Un **Libro registro de facturas** intracomunitarias: [Libro de Ventas Intracomunitarias](/docs/rtg/pymes/libros-registros-de-venta/libro-de-ventas-intracomunitarias)
2. Un [**Impuesto** ](/docs/rtg/pymes/configuracion/impuestos)específico, recomendado: [Impuesto: VIES](/docs/rtg/pymes/configuracion/impuestos/impuesto-vies)
3. Un **Tipo de Venta**: [Tipo de Venta: Intracomunitaria (VIES)](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-intracomunitaria-vies)
***
*⚠️ Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
# Emitir Factura Nacional (/docs/rtg/pymes/procesos/emision-de-facturas/emitir-factura-nacional)
En Dinaup, las **ventas nacionales** son, por defecto, aquellas realizadas a clientes establecidos en España, ya sea a empresas, profesionales o particulares. Estas operaciones **llevan IVA español**, salvo que estén exentas por algún motivo legal.
## Requisitos [#requisitos]
1. Un **libro registro de facturas** Nacionales: [Libro de Ventas Nacionales](/docs/rtg/pymes/libros-registros-de-venta/libro-de-ventas-nacionales)
2. Un [**impuesto** ](/docs/rtg/pymes/configuracion/impuestos)específico, recomendado.
3. Un **tipo de Venta**: [Tipo de Venta: Nacional](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-nacional)
***
*⚠️ Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
# Emitir Factura OSS (/docs/rtg/pymes/procesos/emision-de-facturas/emitir-factura-oss)
De manera predeterminada, **Dinaup no incluye un libro registro específico para operaciones OSS**. Si tu empresa vende a consumidores finales en la UE bajo el régimen de ventanilla única (One Stop Shop), es necesario **crear manualmente la estructura** para registrar correctamente este tipo de ventas.
### **Crear el libro registro OSS** [#crear-el-libro-registro-oss]
Desde la aplicación de Pymes, accede a:\
**Configuración > Ventas / Ingresos > Libros**\
Añade un nuevo libro llamado `OSS` o `Ventas OSS`, que agrupará exclusivamente estas operaciones.
### **Crear un tipo de venta OSS** [#crear-un-tipo-de-venta-oss]
**Configuración > Ventas / Ingresos > Tipos**\
Crea un tipo de venta específico y asígnalo al libro que acabas de crear. Esto permitirá que cada factura OSS se clasifique automáticamente.
### **Crear los impuestos OSS por país** [#crear-los-impuestos-oss-por-país]
Crea un impuesto por cada país de destino, con el porcentaje de IVA correspondiente y aplicando:
Puedes nombrarlos, por ejemplo, `IVA Francia OSS (20%)`, `IVA Alemania OSS (19%)`, etc.
***
*⚠️ Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
# Emitir Factura Simplificada / Ticket (/docs/rtg/pymes/procesos/emision-de-facturas/emitir-factura-simplificada-ticket)
En Dinaup, las **facturas simplificadas** son aquellas operaciones documentadas sin identificar al cliente, normalmente para **ventas al por menor**, **tickets de TPV** o **servicios sin necesidad de facturación nominativa**. Estas operaciones están **sujetas al IVA correspondiente**, igual que una factura completa.
## Requisitos [#requisitos]
1. Un **libro registro de facturas** Simplificadas: [Libro de Ventas Simplificadas / Tickets](/docs/rtg/pymes/libros-registros-de-venta/libro-de-ventas-simplificadas-tickets)
2. Un [**impuesto** ](/docs/rtg/pymes/configuracion/impuestos)específico, recomendado.
3. Un **tipo de Venta**: [Tipo de Venta: Simplificada](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-simplificada)
***
*⚠️ Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
# Emisión de Facturas (/docs/rtg/pymes/procesos/emision-de-facturas)
En Dinaup, la emisión de facturas se adapta a distintos tipos de operación: nacionales, intracomunitarias, exportaciones, simplificadas, OSS, entre otras. Cada factura se clasifica sola según el [tipo de venta](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos) seleccionado. Así queda asignada a su [Libro registro](/docs/rtg/pymes/libros-registros-de-venta) **correspondiente** y recibe el **tratamiento fiscal adecuado**.
Elige el escenario que se ajusta a tu operación:
# Otros supuestos: España (/docs/rtg/pymes/procesos/emision-de-facturas/otros-supuestos-espana)
*⚠️ Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
## Factura normal régimen general [#factura-normal-régimen-general-]
Las facturas ordinarias nacionales usan la clave `F1` e identifican al receptor. El sistema tiene preconfigurado el [Tipo de Venta: Nacional](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-nacional) y aplica el [Impuesto: IVA 21% Régimen general](/docs/rtg/pymes/configuracion/impuestos/impuesto-iva-21-regimen-general) (`IVA`, `S1`, `01`, `Sin Exención`).
```csharp
var invoice = new Invoice("FCO-5", new DateTime(2024, 11, 15), "B72877814")
{
InvoiceType = TipoFactura.F1,
SellerName = "WEFINZ GANDIA SL",
BuyerID = "B44531218",
BuyerName = "WEFINZ SOLUTIONS SL",
Text = "PRESTACION SERVICIOS DESARROLLO SOFTWARE",
TaxItems = new List() {
new TaxItem()
{
TaxRate = 4,
TaxBase = 10,
TaxAmount = 0.4m
},
new TaxItem()
{
TaxRate = 21,
TaxBase = 100,
TaxAmount = 21
}
}
};
```
***
## Factura simplificada [#factura-simplificada-]
Las facturas simplificadas usan la clave `F2` y no identifican al receptor. El sistema tiene preconfigurado el [Tipo de Venta: Simplificada](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-simplificada) y aplica el [Impuesto: IVA 21% Régimen general](/docs/rtg/pymes/configuracion/impuestos/impuesto-iva-21-regimen-general) (`IVA`, `S1`, `01`, `Sin Exención`).
```csharp
var invoice = new Invoice("FSO-24", new DateTime(2024, 12, 4), "B72877814")
{
InvoiceType = TipoFactura.F2,
SellerName = "WEFINZ GANDIA SL",
Text = "PRESTACION SERVICIOS DESARROLLO SOFTWARE",
TaxItems = new List() {
new TaxItem()
{
TaxRate = 4,
TaxBase = 10,
TaxAmount = 0.4m
},
new TaxItem()
{
TaxRate = 21,
TaxBase = 100,
TaxAmount = 21
}
}
};
```
***
## Factura recargo de equivalencia [#factura-recargo-de-equivalencia-]
Las facturas con recargo de equivalencia usan la clave `F1` e identifican al receptor. El sistema tiene preconfigurado el [Tipo de Venta: Nacional](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-nacional), aplicando [Impuesto: IVA 21% Régimen general](/docs/rtg/pymes/configuracion/impuestos/impuesto-iva-21-regimen-general) (`IVA`, `S1`, `01`, `Sin Exención`).
Aunque existe la clave de régimen `18: L8A: Recargo de equivalencia...`, no es necesario seleccionarla: Dinaup trata igual la clave `01` y la `18`. En ventas existe un campo llamado `Aplica recargo de equivalencia`, y en función de ese campo Dinaup informa correctamente a la AEAT.
Para activar el recargo de equivalencia en una venta se debe marcar el checkbox `Recargo de equivalencia` en la pestaña de `Parámetros`
Se puede marcar `Vender con recargo de equivalencia`, en la ficha del cliente para que se marque automáticamente en las ventas.
```csharp
var invoice = new Invoice("FCO-6", new DateTime(2024, 10, 14), "B72877814")
{
InvoiceType = TipoFactura.F1,
SellerName = "WEFINZ GANDIA SL",
BuyerID = "B44531218",
BuyerName = "WEFINZ SOLUTIONS SL",
Text = "VENTA A COMERCIO MINORISTA",
TaxItems = new List() {
new TaxItem()
{
TaxScheme = ClaveRegimen.RecEquivPeqEmp,
TaxType = CalificacionOperacion.S1,
TaxRate = 21,
TaxBase = 1000,
TaxAmount = 210m,
TaxRateSurcharge = 5.2m, // Tipo recargo equivalencia
TaxAmountSurcharge = 52m // Cuota recargo equivalencia
}
}
};
```
***
## Factura rectificativa [#factura-rectificativa-]
```csharp
// Creamos una instacia de la clase factura para la factura rectificativa
var invoiceRectif = new Invoice("GIT-AB-0076", new DateTime(2024, 12, 10), "B72877814")
{
InvoiceType = TipoFactura.R1,
SellerName = "WEFINZ GANDIA SL",
BuyerID = "B44531218",
BuyerName = "WEFINZ SOLUTIONS SL",
Text = "ABONO ERROR PRECIO FACTURA GIT-EJ-0065",
TaxItems = new List()
{
new TaxItem()
{
TaxRate = 21,
TaxBase = -100,
TaxAmount = -21
}
},
RectificationItems = new List()
{
new RectificationItem()
{
InvoiceID = "GIT-EJ-0076",
InvoiceDate = new DateTime(2024, 12, 4)
}
}
};
```
***
## Factura rectificativa sustitutiva [#factura-rectificativa-sustitutiva-]
```csharp
// Creamos una instacia de la clase factura para la factura rectificativa
var invoiceRectif = new Invoice("GIT-AB-0085", new DateTime(2025, 3, 12), "B72877814")
{
InvoiceType = TipoFactura.R1,
SellerName = "WEFINZ GANDIA SL",
BuyerID = "B44531218",
BuyerName = "WEFINZ SOLUTIONS SL",
Text = "ABONO ERROR PRECIO FACTURA GIT-EJ-00651",
TaxItems = new List()
{
new TaxItem()
{
TaxRate = 21,
TaxBase = 100,
TaxAmount = 21
}
},
RectificationItems = new List()
{
new RectificationItem()
{
InvoiceID = "GIT-EJ-00651",
InvoiceDate = new DateTime(2025, 3, 12)
}
}
};
```
***
## Factura a la Administración con IVA diferido [#factura-a-la-administración-con-iva-diferido-]
Las facturas a Administración Pública con IVA diferido usan la clave `F1`, identifican al receptor y requieren clave de régimen `14`. Se aplica el [Impuesto: IVA para la Administración pública con IVA diferido](/docs/rtg/pymes/configuracion/impuestos/impuesto-iva-para-la-administracion-publica-con-iva-diferido) (`IVA`, `S1`, `14`, `Sin Exención`).
```csharp
var invoice = new Invoice("FCO-7", new DateTime(2024, 10, 10), "B72877814")
{
InvoiceType = TipoFactura.F1,
SellerName = "WEFINZ GANDIA SL",
BuyerID = "P1203200I",
BuyerName = "AYUNTAMIENTO DE BURRIANA",
Text = "CONSTRUCCION NUEVAS OFICINAS",
OperationDate = new DateTime(2024, 12, 10), // Fecha operación obligatoria
TaxItems = new List() {
new TaxItem()
{
TaxScheme = ClaveRegimen.ObraPteDevengoAdmonPublica,
TaxType = CalificacionOperacion.S1,
TaxRate = 21,
TaxBase = 1000,
TaxAmount = 210m,
}
}
};
```
***
## Factura operación No Sujeta artículo 7, 14, otros [#factura-operación-no-sujeta-artículo-7-14-otros-]
Se aplican los **impuestos correspondientes** (`Otro`, `N1`, `01`, `Sin Exención`)
```csharp
// Creamos una instacia de la clase factura
var invoice = new Invoice("FCO-8", new DateTime(2024, 10, 14), "B72877814")
{
InvoiceType = TipoFactura.F1,
SellerName = "WEFINZ GANDIA SL",
BuyerID = "123456789",
BuyerName = "CLIENTE EXTRANJERO SERVICIOS INFORMATICOS",
BuyerIDType = IDType.PASAPORTE,
BuyerCountryID = "US",
Text = "SERVICIOS INFORMATICOS",
TaxItems = new List() {
new TaxItem()
{
Tax = Impuesto.OTROS,
TaxType = CalificacionOperacion.N1,
TaxBase = 1000,
}
}
};
```
***
## Factura operación No Sujeta por Reglas de localización [#factura-operación-no-sujeta-por-reglas-de-localización-]
Las facturas no sujetas por reglas de localización usan la clave `F1` con calificación `N2`. El sistema tiene preconfigurado el [Tipo de Venta: Exportación](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-exportacion) y se aplica el [Impuesto: No Sujeto por reglas de Localización](/docs/rtg/pymes/configuracion/impuestos/impuesto-no-sujeto-por-reglas-de-localizacion) (`Otro`, `N2`).
```csharp
// Creamos una instacia de la clase factura
var invoice = new Invoice("FEO-1", new DateTime(2024, 10, 14), "B72877814")
{
InvoiceType = TipoFactura.F1,
SellerName = "WEFINZ GANDIA SL",
BuyerID = "123456789",
BuyerName = "CLIENTE EXTRANJERO SERVICIOS INFORMATICOS",
BuyerIDType = IDType.PASAPORTE,
BuyerCountryID = "US",
Text = "CLIENTE EXTRANJERO SERVICIOS INFORMATICOS",
TaxItems = new List() {
new TaxItem()
{
Tax = Impuesto.OTROS,
TaxType = CalificacionOperacion.N2,
TaxBase = 1000,
}
}
};
```
***
## Factura con Suplidos [#factura-con-suplidos-]
() {
new TaxItem()
{
TaxException = CausaExencion.E1,
TaxBase = 200,
}
}
};
```
***
## Factura exenta articulo 25 LIVA (Entrega intracomunitaria) [#factura-exenta-articulo-25-liva-entrega-intracomunitaria-]
[Impuesto: VIES](/docs/rtg/pymes/configuracion/impuestos/impuesto-vies)
```csharp
var invoice = new Invoice("FIO-2", new DateTime(2025, 2, 7), "B12959755")
{
InvoiceType = TipoFactura.F1,
SellerName = "IRENE SOLUTIONS SL",
BuyerID = "IE3668997OH",
BuyerName = "GOOGLE CLOUD EMEA LIMITED",
BuyerCountryID = "IE",
BuyerIDType = IDType.NIF_IVA,
Text = "ENTREGA INTRACOMUNITARIA: COMPONENTES HARDWARE",
TaxItems = new List() {
new TaxItem()
{
TaxException = CausaExencion.E5,
TaxBase = 200,
}
}
};
```
***
## Factura a cliente con VAT number de la UE [#factura-a-cliente-con-vat-number-de-la-ue-]
```csharp
// Creamos una instacia de la clase factura
var invoice = new Invoice("FCO-10", new DateTime(2025, 1, 9), "B72877814")
{
InvoiceType = TipoFactura.F1,
SellerName = "WEFINZ GANDIA SL",
BuyerID = "IE3668997OH",
BuyerName = "GOOGLE CLOUD EMEA LIMITED",
BuyerIDType = IDType.NIF_IVA,
BuyerCountryID = "IE",
Text = "SERVICIOS INFORMATICOS",
TaxItems = new List() {
new TaxItem()
{
TaxRate = 21,
TaxBase = 100,
TaxAmount = 21
}
}
};
```
***
## Factura a cliente con pasaporte como identificador [#factura-a-cliente-con-pasaporte-como-identificador-]
```csharp
var invoice = new Invoice("FCO-11", new DateTime(2025, 1, 9), "B72877814")
{
InvoiceType = TipoFactura.F1,
SellerName = "WEFINZ GANDIA SL",
BuyerID = "P4366918",
BuyerName = "ESTIVE SOTANO MENGANO",
BuyerIDType = IDType.PASAPORTE,
BuyerCountryID = "US",
Text = "SERVICIOS INFORMATICOS",
TaxItems = new List() {
new TaxItem()
{
TaxRate = 21,
TaxBase = 100,
TaxAmount = 21
}
}
};
```
***
## Factura IGIC Canarias [#factura-igic-canarias-]
**Impuesto IGIC**
```csharp
var invoice = new Invoice("FCO-12", new DateTime(2024, 12, 4), "B72877814")
{
InvoiceType = TipoFactura.F1,
SellerName = "WEFINZ GANDIA SL",
BuyerID = "B44531218",
BuyerName = "WEFINZ SOLUTIONS SL",
Text = "PRESTACION SERVICIOS DESARROLLO SOFTWARE",
TaxItems = new List() {
new TaxItem()
{
TaxScheme = ClaveRegimen.RegimenGeneral,
Tax = Impuesto.IGIC,
TaxRate = 7,
TaxBase = 100,
TaxAmount = 7
}
}
};
```
***
## Factura REBU (Régimen especial de los bienes usados, objetos de arte, antigüedades y objetos de colección) [#factura-rebu-régimen-especial-de-los-bienes-usados-objetos-de-arte-antigüedades-y-objetos-de-colección-]
[Impuesto: REBU (Régimen especial de los bienes usados...)](/docs/rtg/pymes/configuracion/impuestos/impuesto-rebu-regimen-especial-de-los-bienes-usados...)
```csharp
var invoice = new Invoice("GIT-EJ-00809", new DateTime(2025, 2, 27), "B12959755")
{
InvoiceType = TipoFactura.F1,
SellerName = "IRENE SOLUTIONS SL",
BuyerID = "B44531218",
BuyerName = "WEFINZ SOLUTIONS SL",
Text = "VENTA SMARTPHONE REACONDICIONADO",
TaxItems = new List() {
new TaxItem()
{
TaxScheme = ClaveRegimen.Rebu,
TaxBase = 1000m,
}
}
};
```
# Empieza a gestionar pedidos (/docs/rtg/pymes/inventario-y-precios/gestion-de-pedidos/guia-inicio-pedidos) La sección **Pedidos** centraliza las solicitudes de productos o servicios de tus clientes (online, internos o externos) antes de convertirlas en [ventas](/docs/rtg/pymes/facturacion/ventas).
### Revisa estados de Pedidos [#revisa-estados-de-pedidos]
En **`TPV > Configuración > Pedidos`** encontrarás la pestaña `Estados`. Agrega los estados en los que pueden encontrarse los pedidos según tu negocio.
**Ejemplo de configuración de estado:**
**Ejemplo sencillo:** crear 3 estados.
1. **Abierto**
1. `Texto Principal`: Abierto
2. `Estado`: Pendiente
3. `Estilo`: 15
2. **Facturado**
1. `Texto Principal`: Facturado
2. `Estado`: Tramitado
3. `Estilo`: 14
3. **Cancelado**
1. `Texto Principal`: Cancelado
2. `Estado`: Cancelado
3. `Estilo`: 20
### Configura un estado como Predeterminado [#configura-un-estado-como-predeterminado]
Navega hacia `Pymes > Configuración > Empresas Administradas` y en el Listado pulsa en el nombre de tu empresa.
En la pestaña de `Pedidos` puedes configurar el `Estado inicial de pedidos` para que se rellene solo.
### Pulsa sobre Agregar Pedidos [#pulsa-sobre-agregar-pedidos]
### Convertir en venta o cancelar [#convertir-en-venta-o-cancelar]
#### Cancelar [#cancelar]
Cambia el estado del pedido a `Cancelado`.
#### Convertir en venta [#convertir-en-venta]
1. Para convertirlo en Venta, abre el pedido y pulsa sobre Flujo
2. Se abre la ventana de [**Flujo de Pedidos**](/docs/rtg/pymes/inventario-y-precios/gestion-de-pedidos). Pulsa el botón `+ Agregar venta`: se abre una vista previa de la venta. Pulsa `Aceptar`.
# Gestión de Pedidos (/docs/rtg/pymes/inventario-y-precios/gestion-de-pedidos)
La sección **Pedidos** centraliza todas las solicitudes de productos o servicios realizadas por tus clientes, ya sea desde canales online, internos o externos. Es la forma en la que tu empresa recibe y organiza las intenciones de compra antes de convertirlas en [ventas](/docs/rtg/pymes/facturacion/ventas).
# Impuesto: Exportación (Canarias, Ceuta y Melilla) (/docs/rtg/pymes/configuracion/impuestos/impuesto-exportacion-canarias-ceuta-y-melilla)
| Campo | Val |
| ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Tipo | `IVA` |
| **Clasificación de operación** | `S1: Operación Sujeta y No exenta - Sin inversión del sujeto pasivo` |
| **Clave de régimen** | `02: Exportación.` |
| **Causa (Sujeción)** | `E2: Exenta por el artículo 21 de la Ley de IVA` |
| **Valor %** | `0` |
| **Recargo de Equivalencia %** | `0` |
| **Limitar a tipo de Venta 1** | [Tipo de Venta: Exportación (Canarias, Ceuta y Melilla)](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-exportacion-canarias-ceuta-y-melilla) |
# Impuesto: Exportación (/docs/rtg/pymes/configuracion/impuestos/impuesto-exportacion)
| Campo | Val |
| ------------------------------ | --------------------------------------------------------------------------------------------------------------------- |
| Tipo | `IVA` |
| **Clasificación de operación** | `S1: Operación Sujeta y No exenta - Sin inversión del sujeto pasivo` |
| **Clave de régimen** | `02: Exportación.` |
| **Causa (Sujeción)** | `E2: Exenta por el artículo 21 de la Ley de IVA` |
| **Valor %** | `0` |
| **Recargo de Equivalencia %** | `0` |
| **Limitar a tipo de Venta 1** | [Tipo de Venta: Exportación](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-exportacion) |
# Impuesto: IVA 21% Régimen general (/docs/rtg/pymes/configuracion/impuestos/impuesto-iva-21-regimen-general)
Este impuesto corresponde al **IVA General del 21%**, aplicable en la mayoría de operaciones sujetas y no exentas dentro del territorio nacional.
| Campo | Val |
| ------------------------------ | -------------------------------------------------------------------- |
| Tipo | `IVA` |
| **Clasificación de operación** | `S1: Operación Sujeta y No exenta - Sin inversión del sujeto pasivo` |
| **Clave de régimen** | `01: Operación de régimen general` |
| **Causa (Sujeción)** | `Sin Exención` |
| **Valor %** | `21` |
| **Recargo de Equivalencia %** | `5,2` |
En Dinaup no hace falta seleccionar expresamente la clave de régimen `18 (L8A)`. El sistema considera idénticas las claves `01` y `18`, de modo que basta con marcar el campo **«Aplica recargo de equivalencia»** al introducir la factura. A partir de ese dato, la propia factura decide si debe incluir el recargo.
Cuando dicha factura se exporta a **Verifactu**, Dinaup incorpora la información fiscal correspondiente (con o sin recargo) y la envía con el formato que exige la AEAT, sin pasos adicionales por tu parte.
**Limitar a tipo de Venta**\
En la mayoría de casos, se puede limitar este impuesto a Facturas simplificadas y Nacionales. De este modo no aparecerá el impuesto en otros tipos de venta.
# Impuesto: IVA para la Administración pública con IVA diferido (/docs/rtg/pymes/configuracion/impuestos/impuesto-iva-para-la-administracion-publica-con-iva-diferido)
| Campo | Val |
| ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------- |
| Tipo | `IVA` |
| **Clasificación de operación** | `S1: Operación Sujeta y No exenta - Sin inversión del sujeto pasivo` |
| **Clave de régimen** | `14: L8A: Factura con IVA pendiente de devengo en certificaciones de obra a Administraciones Públicas. L8B: Factura con IGIC pendiente de devengo` |
| **Causa (Sujeción)** | `Sin Exención` |
| **Valor %** | `21` |
| **Recargo de Equivalencia %** | `0` |
# Impuesto: No Sujeto por reglas de Localización (/docs/rtg/pymes/configuracion/impuestos/impuesto-no-sujeto-por-reglas-de-localizacion)
| Campo | Val |
| ------------------------------ | --------------------------------------------------------------------------------------------------------------------- |
| Tipo | `IVA` |
| **Clasificación de operación** | `N2: Operación No Sujeta por Reglas de localización.` |
| **Clave de régimen** | `01: Operación de régimen general.` |
| **Causa (Sujeción)** | `Sin Exención` |
| **Valor %** | `0` |
| **Recargo de Equivalencia %** | `0` |
| **Limitar a tipo de Venta 1** | [Tipo de Venta: Exportación](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-exportacion) |
# Impuesto: OSS (/docs/rtg/pymes/configuracion/impuestos/impuesto-oss)
Impuesto de otro país de la Unión Europea con el IVA del país de destino, bajo el régimen OSS (One Stop Shop).
| Campo | Val |
| ------------------------------ | ----------------------------------------------------------------------------------------------------- |
| Tipo | `IVA` |
| **Clasificación de operación** | `S1: Operación Sujeta y No exenta - Sin inversión del sujeto pasivo.` |
| **Clave de régimen** | `17: L8A: OSS e IOSS IVA. L8B: Régimen especial de comerciante minorista.` |
| **Causa (Sujeción)** | `Sin Exención` |
| **Valor %** | `20` |
| **Recargo de Equivalencia %** | `0` |
| **País** | `Francia` |
| **Limitar a tipo de Venta 1** | [Tipo de Venta: OSS](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-oss) |
# Impuesto: REBU (Régimen especial de los bienes usados...) (/docs/rtg/pymes/configuracion/impuestos/impuesto-rebu-regimen-especial-de-los-bienes-usados...)
| Campo | Val |
| ------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------- |
| Tipo | `IVA` |
| **Clasificación de operación** | `S1: Operación Sujeta y No exenta - Sin inversión del sujeto pasivo.` |
| **Clave de régimen** | `03: Operaciones a las que se aplique el régimen especial de bienes usados, objetos de arte, antigüedades y objetos de colección.` |
| **Causa (Sujeción)** | `Sin Exención` |
| **Valor %** | `0` |
| **Recargo de Equivalencia %** | `0` |
| **Limitar a tipo de Venta 1** | [Tipo de Venta: REB](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-reb) |
# Impuesto: VIES (/docs/rtg/pymes/configuracion/impuestos/impuesto-vies)
Configuración del impuesto al 0% para **ventas intracomunitarias** a empresas con número de IVA válido en VIES.
| Campo | Val |
| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------- |
| **Tipo** | `IVA` |
| **Clasificación de operación** | `S1: Operación Sujeta y No exenta - Sin inversión del sujeto pasivo` |
| **Clave de régimen** | `01: Operación de régimen general` |
| **Causa (Sujeción)** | `E5: Exenta por artículo 25` |
| **Valor %** | `0` |
| **Recargo de Equivalencia %** | `0` |
| **Limitar a tipo de Venta 1** | [Tipo de Venta: Intracomunitaria (VIES)](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-intracomunitaria-vies) |
# Impuestos (/docs/rtg/pymes/configuracion/impuestos)
### Campos del impuesto [#campos-del-impuesto]
Es el nombre que se mostrará en la factura (por ejemplo, "IVA", "IGIC", "IPSI"...).
El porcentaje del impuesto. En casos exentos o no sujetos, este valor está al 0%.
Porcentaje de recargo de equivalencia para este tipo impositivo. El recargo se activa en las facturas con la casilla `Activar recargo de equivalencia`.
Para Verifactu. Clasifica el impuesto según su naturaleza:
* IVA
* IPSI
* IGIC
* Otros
Para Verifactu. Motivo legal por el que se aplica, no aplica o está exento. Ejemplos:
* E1: Exenta por el artículo 20 de la Ley de IVA
* E2: Exenta por el artículo 21 de la Ley de IVA
* E3: Exenta por artículo 22
* E4: Exenta por artículo 24
* E5: Exenta por artículo 25
* E6: Otros
Para Verifactu.
* 01: Operación de régimen general.
* 02: Exportación.
* 03: Operaciones a las que se aplique el régimen especial de bienes usados, objetos de arte, antigüedades y objetos de colección.
* 04: Régimen especial del oro de inversión.
* 05: Régimen especial de las agencias de viajes.
* 06: Régimen especial grupo de entidades en IVA/IGIC (Nivel Avanzado).
* 07: Régimen especial del criterio de caja.
* 08: L8A: Operaciones sujetas al IPSI / IGIC. L8B: Operaciones sujetas al IPSI / IVA.
* 09: Facturación de servicios de agencias de viaje como mediadoras en nombre y por cuenta ajena.
* 10: Cobros por cuenta de terceros de honorarios profesionales o derechos derivados.
* 11: Operaciones de arrendamiento de local de negocio.
* 14: L8A: Factura con IVA pendiente de devengo en certificaciones de obra a Administraciones Públicas. L8B: Factura con IGIC pendiente de devengo.
* 15: L8A: Factura con IVA pendiente de devengo en operaciones de tracto sucesivo. L8B: Factura con IGIC pendiente de devengo.
* 17: L8A: OSS e IOSS IVA. L8B: Régimen especial de comerciante minorista.
* 18: L8A: Recargo de equivalencia. L8B: Régimen especial del pequeño empresario o profesional.
* 19: L8A: Operaciones de actividades incluidas en el Régimen Especial de Agricultura, Ganadería y Pesca (REAGYP). L8B: Operaciones interiores exentas por aplicación artículo 25 Ley 19/1994.
* 20: Régimen simplificado sólo para IVA.
Para Verifactu.
* S1: Operación Sujeta y No exenta - Sin inversión del sujeto pasivo.
* S2: Operación Sujeta y No exenta - Con Inversión del sujeto pasivo.
* N1: Operación No Sujeta artículo 7, 14, otros.
* N2: Operación No Sujeta por Reglas de localización.
Puedes asociar subcuentas para la contabilidad automática ( [Contabilidad Automática](/docs/rtg/pymes/procesos/contabilidad-automatica) ).
Determina el país del impuesto. Las ventanas de generación de Presupuestos, Ventas, Pedidos... lo tienen en cuenta al seleccionar los impuestos.
Cuatro campos te permiten restringir la aplicación de un impuesto a determinados [Tipos de Ventas e Ingresos](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos).
En ocasiones el filtro por país no basta. Por ejemplo, el impuesto [Impuesto: VIES](/docs/rtg/pymes/configuracion/impuestos/impuesto-vies) se aplica en varios estados, por lo que resulta especialmente útil filtrarlo por tipo de venta [Tipo de Venta: Intracomunitaria (VIES)](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-intracomunitaria-vies).
De igual modo, si trabajas con el impuesto [Impuesto: REBU (Régimen especial de los bienes usados...)](/docs/rtg/pymes/configuracion/impuestos/impuesto-rebu-regimen-especial-de-los-bienes-usados...) , puedes asignarlo únicamente al tipo de venta [Tipo de Venta: REB](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-reb).
***
## Ejemplos [#ejemplos]
IVA general del 21% con recargo de equivalencia, para la mayoría de operaciones nacionales.
Régimen especial de bienes usados, objetos de arte, antigüedades y colección.
Ventas intracomunitarias al 0% a empresas con VAT validado en VIES.
Envíos a Canarias, Ceuta y Melilla, exentos por el artículo 21 de la Ley del IVA.
Ventas a clientes fuera de la UE, exentas por el artículo 21 de la Ley del IVA.
Operaciones no sujetas al IVA por reglas de localización.
# Tipos de Ventas e Ingresos (/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos)
Un **Tipo de Venta** define cómo debe comportarse una factura dentro del sistema. Sirve para adaptar la lógica de facturación según el contexto:
* Factura simplificada
* Venta online
* Operaciones intracomunitarias
* Régimen OSS\
...y cualquier otra necesidad específica.
## Tipos de ventas Pymes y TPV [#tipos-de-ventas-pymes-y-tpv]
Puedes usar los tipos de venta en la aplicación de [TPV](/docs/rtg/tpv) y en [Pymes](/docs/rtg/pymes). En la ficha del **tipo de venta** hay una casilla `Disponible en TPV`.
### Pymes [#pymes]
En Pymes aparecen todos los tipos de venta, ya que esta aplicación está pensada para usuarios avanzados.
### TPV [#tpv]
En `TPV` únicamente aparecen los marcados como `Disponible en TPV`, ya que está pensado para ventas sencillas (generalmente facturas simplificadas en puntos de venta: supermercados, hostelería...).
## Campos [#campos]
Cada Tipo de Venta permite ajustar múltiples opciones para adaptarse a cada situación:
Limita el valor total permitido en la venta (por ejemplo, para cumplir con el tope legal de las facturas simplificadas).
Si el movimiento no es una venta (una subvención, una devolución de impuestos), marca esta opción para que el sistema lo trate como un ingreso contable sin factura asociada.
Determina si este tipo de venta está disponible en la generación automática de asientos contables.
Puedes forzar un impuesto específico que sobrescribe el configurado en productos.
> Ejemplo: aunque los productos estén al 21% de IVA, puedes definir un tipo de venta intracomunitario con un impuesto del 0% si el cliente está dado de alta en el VIES.
Aplica una retención automática a las ventas de este tipo (por ejemplo, IRPF en servicios profesionales).
Clasifica las ventas bajo una categoría específica, que sustituye a la definida en los productos o servicios.
Determina si la factura se confecciona con o sin impuestos incluidos.
Permite configurar si el cliente debe rellenarse o no.
Permite configurar si los datos fiscales del cliente deben rellenarse o no.
Determina si el cliente debe estar dado de alta o no en AEAT.\
Puedes elegir entre:
* **Sin restricción**
* **Debe estar dado de alta en AEAT**
* **No debe estar en AEAT**
Determina si el cliente debe estar dado de alta o no en VIES.\
Opciones disponibles:
* **Sin restricción**
* **Debe estar dado de alta en VIES**
* **No debe estar en VIES**
Puedes definir una **lista de países** usando el formato **ISO 3166-1 alfa-2** (códigos de dos letras), separados por comas.
**Ejemplo 1: Países incluidos**
* **Política de países:** Incluir
* **Lista:**
```
ES,FR,IT
```
→ Solo España, Francia e Italia quedan permitidos.
***
**Ejemplo 2: Países excluidos**
* **Política de países:** Excluir
* **Lista:**
```
ES,FR,IT
```
→ Bloquea España, Francia e Italia; el resto de países quedan permitidos.
***
**Ejemplo 3: Provincias incluidas**
* **Política de países:** Incluir
* **Lista:**
```
ES[Ceuta],ES[Melilla]
```
→ Solo Ceuta y Melilla quedan permitidas.
***
**Ejemplo 4: Provincias excluidas**
* **Política de países:** Incluir
* **Lista:**
```
ES,ES[!Ceuta],ES[!Melilla],ES[!Canarias]
```
→ Toda España queda permitida salvo Ceuta, Melilla y Canarias.
Define cómo debe interpretarse la **lista de países permitidos**.\
Opciones disponibles:
* **Incluir**: solo se permite la venta a los países (o provincias) indicados.
* **Excluir**: se permite la venta a todos los destinos **excepto** los indicados.
Así controlas en qué territorios aplica el tipo de venta, combinando la lista ISO con provincias (`ES[Ceuta]`, `FR[Martinique]`, etc.).
Determina si este tipo de ventas aparece en envíos pendientes (Picking o Sendcloud, Genei...)\
Para determinados usos, puede requerir integraciones y/o personalizaciones.
El sistema no permite seleccionar dirección de envío, lo que además simplifica la interfaz.
Activa esta opción si quieres **impedir que se añadan conceptos de texto libre** a la venta.\
De este modo, el sistema **obliga a seleccionar elementos estructurados**, como productos, recursos o servicios previamente definidos.
> Útil para evitar errores, asegurar trazabilidad o controlar el uso de tarifas preconfiguradas.
Impide que se añadan productos a la venta. Útil si el tipo de venta solo debe usar recursos u otros elementos.
Bloquea la posibilidad de añadir recursos a la venta. Solo se pueden usar productos o conceptos válidos según el tipo de venta.
Determina si este tipo de ventas aparece en el área de clientes. Para determinados usos, puede requerir integraciones y/o personalizaciones.
Permite definir si este tipo de venta **puede ser utilizado desde la aplicación de TPV**.\
Cuando está activado, aparece como opción en el terminal de punto de venta, pensado para ventas rápidas y simplificadas (como hostelería, retail o mostrador).
> Si no se marca, este tipo de venta solo está disponible en la aplicación de PYMES o en otras integraciones del sistema.
Indica si este tipo de venta está **activo y disponible para ser utilizado en el sistema**.\
Si no está marcado como disponible, no puede seleccionarse ni desde TPV, ni desde PYMES, ni desde ninguna otra parte de la plataforma.
> Útil para desactivar un tipo de venta sin tener que eliminarlo.
Permite **asociar este tipo de venta a un libro registro concreto**.
Permite indicar si este tipo de venta **funciona en modo táctil**, pensado para pantallas sin teclado ni ratón (hostelería, kioscos, etc.).
Activa esta opción si el tipo de venta representa **una factura ya emitida externamente**, desde otro programa o sistema de facturación. En ese caso, el sistema no genera numeración, entre otras funcionalidades. Ejemplo: `Facturas Stripe`
## Sugerencias inteligentes [#sugerencias-inteligentes]
Dinaup analiza el nombre de cada tipo de venta y, si encuentra términos como “OSS”, “Ingresos” o “Exportación”, ofrece sugerencias adaptadas al contexto.
#### Palabras clave y sus sugerencias [#palabras-clave-y-sus-sugerencias]
| Palabra clave | Contexto |
| -------------------------- | --------------------------------------------------------------- |
| **Simplificada** | Facturas simplificadas / tickets |
| **Nacional** | Ventas dentro de España |
| **Ceuta/Melilla/Canarias** | Ventas a territorios donde no se aplica el IVA. |
| **OSS** | Ventas a través del One-Stop-Shop (UE) |
| **Exportaciones** | Ventas fuera de la UE |
| **VIES** | Operaciones entre países UE registradas en VIES. |
| **Ingresos** | Entradas sin factura (subvenciones, devoluciones de impuestos…) |
***
*⚠️ Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
# Tipo de Venta: Exportación (Canarias, Ceuta y Melilla) (/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-exportacion-canarias-ceuta-y-melilla)
Usa este tipo para operaciones desde la península a Canarias, Ceuta y Melilla, territorios donde no se aplica el IVA peninsular.
***
*⚠️ Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
# Tipo de Venta: Exportación (/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-exportacion)
Usa este tipo para operaciones con clientes en países terceros: ventas fuera de la Unión Europea a las que no se aplica el IVA español.
***
*⚠️ Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
# Tipo de Venta: Intracomunitaria (VIES) (/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-intracomunitaria-vies)
Tipo de venta para operaciones intracomunitarias a empresas o profesionales con NIF-VAT europeo válido: clientes de la UE (excepto España) dados de alta en el sistema VIES.
### Campos recomendados [#campos-recomendados]
| Parámetro | Valor sugerido | Notas |
| ---------------------- | ------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Nombre** | `VIES` | |
| **Países permitidos** | `AT, BE, BG, HR, CY, CZ, DK, EE, FI, FR, DE, GR, HU, IE, IT, LV, LT, LU, MT, NL, PL, PT, RO, SK, SI, SE` | Francia, Alemania, Italia, etc. Excepto España, que sería [Tipo de Venta: Nacional](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-nacional). |
| **Política de países** | `Incluir` | |
| **Validar NIFs VIES** | `Sí` | Solo admite VAT-UE válido |
| **Impuesto** | [Impuesto: VIES](/docs/rtg/pymes/configuracion/impuestos/impuesto-vies) | |
| **Libro** | `Intracomunitarias` | Agrupa las operaciones VIES |
| **Notas a Incluir** | “*`Reverse charge. VAT to be accounted for by the recipient under Article 196 of the EU VAT Directive`*” | |
***
*⚠️ Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
# Tipo de Venta: Nacional (/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-nacional)
Tipo de venta para cualquier operación a clientes dentro de España peninsular o Baleares, tanto empresas como particulares. Es el tipo más común para ventas nacionales.
### Campos recomendados [#campos-recomendados]
| Parámetro | Valor sugerido | Notas |
| ---------------------- | ------------------------------------------ | ------------------------------------------------------------------------- |
| **Nombre** | `Nacional` | |
| **Países permitidos** | `ES,ES[!Ceuta],ES[!Melilla],ES[!Canarias]` | Aplicable a todo el territorio español excepto Canarias, Ceuta y Melilla. |
| **Política de países** | `Incluir` | |
| **Libro** | `Nacionales` | |
***
*⚠️ Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
# Tipo de Venta: OSS (/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-oss)
Pensado para ventas a consumidores finales en la UE bajo el régimen de ventanilla única (OSS). Permite gestionar IVA extranjero para ventas online o servicios digitales.
### General [#general]
* Nombre: `OSS`
* Descripción: `Venta a consumidor final UE bajo régimen OSS`
* Nota a Incluir: `Factura emitida bajo el régimen especial de ventanilla única (OSS). El IVA aplicado corresponde al país de consumo.`
### Países permitidos [#países-permitidos]
* Lista de Países: Incluye solo los países de la Unión Europea, excluyendo España (ES).
```
AT, BE, BG, HR, CY, CZ, DK, EE, FI, FR, DE, GR, HU, IE, IT, LV, LT, LU, MT, NL, PL, PT, RO, SK, SI, SE
```
* Política: `Incluir`
### Validaciones de NIF [#validaciones-de-nif]
Para minimizar errores, se recomienda aplicar la siguiente configuración:
* Permisión NIF en AEAT: `No`.
* Permisión NIF en VIES: `No`.
Dinaup valida el NIF del cliente para determinar si se debe aplicar esta configuración. Esto asegura que el sistema lo interprete como una venta a consumidor final y no como una operación intracomunitaria o nacional.
***
*⚠️ Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
# Tipo de Venta: REB (/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-reb)
Tipo específico para ventas de bienes usados, antigüedades o arte bajo el régimen especial. No desglosa IVA en la factura, solo aplica a margen de beneficio.
***
*⚠️ Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
# Tipo de Venta: Simplificada (/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-simplificada)
Tipo orientado a ventas de mostrador o tickets, donde no se recogen datos del cliente. Para operaciones rápidas, anónimas y de bajo importe.
***
*⚠️ Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
# Tipo de Venta: TPV Hostelería (/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-tpv-hosteleria)
Tipo de venta pensado para operaciones rápidas en bares, cafeterías o restaurantes. Similar a simplificada, pero permite gestionar tickets, mesas, cuentas y otras funciones específicas de hostelería.
***
*⚠️ Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
Detalle del pedido #1042
Elige cliente y añade las líneas.
Comprueba bases, IVA y total.
Genera el PDF y mándalo al cliente.
Define ubicaciones y stock inicial.
La factura se ha emitido y enviado al cliente correctamente.
Resumen del pedido
") F.WriteText(v.observaciones) F.Write("Total: ") F.WriteMoney(v.total, 2) F.Write("
") ``` ## Plantillas y metadatos [#plantillas-y-metadatos] Ejecutan en documentos dinámicos y funciones API (`MetaData_Read` también en scripts independientes). | Función | Parámetros | Devuelve | Qué hace | | --------------------------- | --------------------------- | -------- | -------------------------------------------------------------------------- | | `Include` | (id) | — | Incluye y renderiza una plantilla de impresión HTML por su identificador. | | `GetDynamicDocumentContent` | (id) | — | Inserta el contenido de un documento dinámico por su identificador. | | `DataListInfoToHTML` | (informeOSeccionId, estilo) | Texto | Devuelve como HTML la información de un informe o una sección. | | `RowToJson` | (seccionId) | Texto | Serializa un registro a JSON, sin los textos primarios de datos estáticos. | | `MetaData_Read` | (clave) | Texto | Lee un parámetro de metadatos por su clave. | | `MetaData_Set` | (clave, valor) | — | Asigna el valor de un parámetro de metadatos. | ## URLs firmadas de archivos [#urls-firmadas-de-archivos] Para enseñar un archivo de Dinaup (una imagen, un PDF) a quien no tiene sesión: generan una URL temporal de acceso público. Solo en documentos dinámicos y funciones API. | Función | Parámetros | Devuelve | Qué hace | | ---------------------- | -------------------------------------------- | -------- | -------------------------------------------------------------------------- | | `SignFileURL` | (archivoId, tamaño, validezSegundos) | Texto | URL firmada del archivo, accesible sin sesión durante la validez indicada. | | `SignFileURL_Advanced` | (archivoId, tamaño, validezSegundos, nombre) | Texto | Igual, con nombre de archivo personalizado. | El parámetro `tamaño` admite los valores `0`, `32`, `100`, `300`, `720` y `1080`.
## DinaScript [#dinascript]
```
.
.
|
Condiciones de pago: |
Vencimiento: |
SALDO
¡Ha acumulado de saldo promocional con esta compra!
¡Ha acumulado de saldo promocional con esta compra!
* A fecha dispone de de saldo promocional que puede aplicar como descuentos en compras futuras.
## DinaScript [#dinascript]
```
💼 - 📄 Libro registro
Compras / Gastos -
| Concepto | Total |
|---|---|
| Suma B.I | |
| Suma IVA | |
| Suma R.E | |
| Suma Retenciones | |
| Suma Totales |
# Ventas (/docs/rtg/pymes/facturacion/ventas)
Emisión y gestión de facturas a clientes:
* [Tipos de Ventas e Ingresos](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos): nacional, intracomunitaria, exportación, OSS, etc.
* [Categorías de Venta](/docs/rtg/pymes/facturacion/ventas/categorias-de-venta): clasificación analítica.
* [Fechas en facturas](/docs/rtg/pymes/facturacion/ventas/fechas-en-facturas): fecha de expedición vs. fecha registro.
* [Libros Registro y Tipos de Venta](/docs/rtg/pymes/facturacion/ventas/libros-registro-y-tipos-de-venta): relación entre tipos y libros oficiales.
* [Verifactu](/docs/rtg/pymes/facturacion/ventas/verifactu): cumplimiento del Real Decreto 1007/2023.
* [Gestión Archivos](/docs/rtg/pymes/facturacion/ventas/gestion-archivos): buzón de documentos con IA.
* [Ventana de Factura](/docs/rtg/pymes/facturacion/ventas/ventana-de-factura): referencia de campos del formulario.
# Libros Registro y Tipos de Venta (/docs/rtg/pymes/facturacion/ventas/libros-registro-y-tipos-de-venta)
Tres conceptos que verás al facturar en Dinaup: **libros registro, tipos de venta y ventas**.
## Libros [#libros]
Un **libro registro** es el listado de todas tus facturas agrupadas por su naturaleza fiscal. Es la forma tradicional de clasificar la facturación para tenerla siempre lista ante Hacienda o tu asesoría. [Puedes exportar estos libros a Excel](/docs/rtg/pymes/procesos/exportacion).
| Ejemplo de libro registro | ¿Qué agrupa? |
| ---------------------------------- | ------------------------------------------- |
| **Ventas nacionales** | Facturas emitidas dentro de España. |
| **Ventas simplificadas (tickets)** | Facturas simplificadas o tickets. |
| **Ventas intracomunitarias** | Facturas a clientes de la UE con NIF-IVA. |
| **Exportaciones fuera de la UE** | Operaciones con clientes extracomunitarios. |
| Ejemplo de tipo | ¿Qué hace diferente? |
| ---------------------------- | ------------------------------------------------- |
| **Factura simplificada** | Usa una serie numérica específica. |
| **Venta online** | Aplica una plantilla de impresión distinta. |
| **Factura intracomunitaria** | Activa *inversión del sujeto pasivo* por defecto. |
## Gasto suplido en análisis [#gasto-suplido-en-análisis]
El importe del suplido **no se suma a las ventas ni al beneficio**, pero sí aparece en “**Suplidos Ventas**” para dejar constancia de lo que el cliente debe reembolsar.
***
*⚠️ Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
# Emitir Factura Exportación (/docs/rtg/pymes/procesos/emision-de-facturas/emitir-factura-exportacion)
En Dinaup, las **exportaciones** son operaciones de venta realizadas **a clientes fuera de la Unión Europea**. Estas operaciones están **exentas de IVA**, según el **artículo 21 de la Ley del IVA**, siempre que puedas acreditar que los bienes han salido efectivamente del territorio aduanero de la UE.
## Requisitos [#requisitos]
1. Un **libro registro de facturas** exportaciones: [Libro de Ventas Exportaciones](/docs/rtg/pymes/libros-registros-de-venta/libro-de-ventas-exportaciones)
2. Un [**impuesto**](/docs/rtg/pymes/configuracion/impuestos) específico.
3. Un **tipo de Venta**: [Tipo de Venta: Exportación](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-exportacion)
***
*⚠️ Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
# Emitir Factura Intracomunitarias (/docs/rtg/pymes/procesos/emision-de-facturas/emitir-factura-intracomunitarias)
En Dinaup, las **ventas intracomunitarias** son, por defecto, **entregas o servicios realizados a clientes de la UE que están dados de alta en el VIES**.
No deben confundirse con:
* Las [**ventas OSS**](/docs/rtg/pymes/procesos/emision-de-facturas/emitir-factura-oss), que aunque se hagan a países de la UE, **siguen un régimen distinto** y se declaran aparte.
* Las **ventas a particulares (B2C)** en la UE, cuando el cliente **no tiene NIF-IVA intracomunitario**. En estos casos, la operación se **registra como nacional**, aplicando el **IVA español**.
## Requisitos [#requisitos]
1. Un **Libro registro de facturas** intracomunitarias: [Libro de Ventas Intracomunitarias](/docs/rtg/pymes/libros-registros-de-venta/libro-de-ventas-intracomunitarias)
2. Un [**Impuesto** ](/docs/rtg/pymes/configuracion/impuestos)específico, recomendado: [Impuesto: VIES](/docs/rtg/pymes/configuracion/impuestos/impuesto-vies)
3. Un **Tipo de Venta**: [Tipo de Venta: Intracomunitaria (VIES)](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-intracomunitaria-vies)
***
*⚠️ Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
# Emitir Factura Nacional (/docs/rtg/pymes/procesos/emision-de-facturas/emitir-factura-nacional)
En Dinaup, las **ventas nacionales** son, por defecto, aquellas realizadas a clientes establecidos en España, ya sea a empresas, profesionales o particulares. Estas operaciones **llevan IVA español**, salvo que estén exentas por algún motivo legal.
## Requisitos [#requisitos]
1. Un **libro registro de facturas** Nacionales: [Libro de Ventas Nacionales](/docs/rtg/pymes/libros-registros-de-venta/libro-de-ventas-nacionales)
2. Un [**impuesto** ](/docs/rtg/pymes/configuracion/impuestos)específico, recomendado.
3. Un **tipo de Venta**: [Tipo de Venta: Nacional](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-nacional)
***
*⚠️ Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
# Emitir Factura OSS (/docs/rtg/pymes/procesos/emision-de-facturas/emitir-factura-oss)
De manera predeterminada, **Dinaup no incluye un libro registro específico para operaciones OSS**. Si tu empresa vende a consumidores finales en la UE bajo el régimen de ventanilla única (One Stop Shop), es necesario **crear manualmente la estructura** para registrar correctamente este tipo de ventas.
En Dinaup, las **facturas simplificadas** son aquellas operaciones documentadas sin identificar al cliente, normalmente para **ventas al por menor**, **tickets de TPV** o **servicios sin necesidad de facturación nominativa**. Estas operaciones están **sujetas al IVA correspondiente**, igual que una factura completa.
## Requisitos [#requisitos]
1. Un **libro registro de facturas** Simplificadas: [Libro de Ventas Simplificadas / Tickets](/docs/rtg/pymes/libros-registros-de-venta/libro-de-ventas-simplificadas-tickets)
2. Un [**impuesto** ](/docs/rtg/pymes/configuracion/impuestos)específico, recomendado.
3. Un **tipo de Venta**: [Tipo de Venta: Simplificada](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-simplificada)
***
*⚠️ Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
# Emisión de Facturas (/docs/rtg/pymes/procesos/emision-de-facturas)
En Dinaup, la emisión de facturas se adapta a distintos tipos de operación: nacionales, intracomunitarias, exportaciones, simplificadas, OSS, entre otras. Cada factura se clasifica sola según el [tipo de venta](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos) seleccionado. Así queda asignada a su [Libro registro](/docs/rtg/pymes/libros-registros-de-venta) **correspondiente** y recibe el **tratamiento fiscal adecuado**.
Elige el escenario que se ajusta a tu operación:
```csharp
var invoice = new Invoice("FCO-6", new DateTime(2024, 10, 14), "B72877814")
{
InvoiceType = TipoFactura.F1,
SellerName = "WEFINZ GANDIA SL",
BuyerID = "B44531218",
BuyerName = "WEFINZ SOLUTIONS SL",
Text = "VENTA A COMERCIO MINORISTA",
TaxItems = new List# Empieza a gestionar pedidos (/docs/rtg/pymes/inventario-y-precios/gestion-de-pedidos/guia-inicio-pedidos) La sección **Pedidos** centraliza las solicitudes de productos o servicios de tus clientes (online, internos o externos) antes de convertirlas en [ventas](/docs/rtg/pymes/facturacion/ventas).
2. Se abre la ventana de [**Flujo de Pedidos**](/docs/rtg/pymes/inventario-y-precios/gestion-de-pedidos). Pulsa el botón `+ Agregar venta`: se abre una vista previa de la venta. Pulsa `Aceptar`.
| Campo | Val |
| ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Tipo | `IVA` |
| **Clasificación de operación** | `S1: Operación Sujeta y No exenta - Sin inversión del sujeto pasivo` |
| **Clave de régimen** | `02: Exportación.` |
| **Causa (Sujeción)** | `E2: Exenta por el artículo 21 de la Ley de IVA` |
| **Valor %** | `0` |
| **Recargo de Equivalencia %** | `0` |
| **Limitar a tipo de Venta 1** | [Tipo de Venta: Exportación (Canarias, Ceuta y Melilla)](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-exportacion-canarias-ceuta-y-melilla) |
# Impuesto: Exportación (/docs/rtg/pymes/configuracion/impuestos/impuesto-exportacion)
| Campo | Val |
| ------------------------------ | --------------------------------------------------------------------------------------------------------------------- |
| Tipo | `IVA` |
| **Clasificación de operación** | `S1: Operación Sujeta y No exenta - Sin inversión del sujeto pasivo` |
| **Clave de régimen** | `02: Exportación.` |
| **Causa (Sujeción)** | `E2: Exenta por el artículo 21 de la Ley de IVA` |
| **Valor %** | `0` |
| **Recargo de Equivalencia %** | `0` |
| **Limitar a tipo de Venta 1** | [Tipo de Venta: Exportación](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-exportacion) |
# Impuesto: IVA 21% Régimen general (/docs/rtg/pymes/configuracion/impuestos/impuesto-iva-21-regimen-general)
Este impuesto corresponde al **IVA General del 21%**, aplicable en la mayoría de operaciones sujetas y no exentas dentro del territorio nacional.
| Campo | Val |
| ------------------------------ | -------------------------------------------------------------------- |
| Tipo | `IVA` |
| **Clasificación de operación** | `S1: Operación Sujeta y No exenta - Sin inversión del sujeto pasivo` |
| **Clave de régimen** | `01: Operación de régimen general` |
| **Causa (Sujeción)** | `Sin Exención` |
| **Valor %** | `21` |
| **Recargo de Equivalencia %** | `5,2` |
| Campo | Val |
| ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------- |
| Tipo | `IVA` |
| **Clasificación de operación** | `S1: Operación Sujeta y No exenta - Sin inversión del sujeto pasivo` |
| **Clave de régimen** | `14: L8A: Factura con IVA pendiente de devengo en certificaciones de obra a Administraciones Públicas. L8B: Factura con IGIC pendiente de devengo` |
| **Causa (Sujeción)** | `Sin Exención` |
| **Valor %** | `21` |
| **Recargo de Equivalencia %** | `0` |
# Impuesto: No Sujeto por reglas de Localización (/docs/rtg/pymes/configuracion/impuestos/impuesto-no-sujeto-por-reglas-de-localizacion)
| Campo | Val |
| ------------------------------ | --------------------------------------------------------------------------------------------------------------------- |
| Tipo | `IVA` |
| **Clasificación de operación** | `N2: Operación No Sujeta por Reglas de localización.` |
| **Clave de régimen** | `01: Operación de régimen general.` |
| **Causa (Sujeción)** | `Sin Exención` |
| **Valor %** | `0` |
| **Recargo de Equivalencia %** | `0` |
| **Limitar a tipo de Venta 1** | [Tipo de Venta: Exportación](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-exportacion) |
# Impuesto: OSS (/docs/rtg/pymes/configuracion/impuestos/impuesto-oss)
Impuesto de otro país de la Unión Europea con el IVA del país de destino, bajo el régimen OSS (One Stop Shop).
| Campo | Val |
| ------------------------------ | ----------------------------------------------------------------------------------------------------- |
| Tipo | `IVA` |
| **Clasificación de operación** | `S1: Operación Sujeta y No exenta - Sin inversión del sujeto pasivo.` |
| **Clave de régimen** | `17: L8A: OSS e IOSS IVA. L8B: Régimen especial de comerciante minorista.` |
| **Causa (Sujeción)** | `Sin Exención` |
| **Valor %** | `20` |
| **Recargo de Equivalencia %** | `0` |
| **País** | `Francia` |
| **Limitar a tipo de Venta 1** | [Tipo de Venta: OSS](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-oss) |
# Impuesto: REBU (Régimen especial de los bienes usados...) (/docs/rtg/pymes/configuracion/impuestos/impuesto-rebu-regimen-especial-de-los-bienes-usados...)
| Campo | Val |
| ------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------- |
| Tipo | `IVA` |
| **Clasificación de operación** | `S1: Operación Sujeta y No exenta - Sin inversión del sujeto pasivo.` |
| **Clave de régimen** | `03: Operaciones a las que se aplique el régimen especial de bienes usados, objetos de arte, antigüedades y objetos de colección.` |
| **Causa (Sujeción)** | `Sin Exención` |
| **Valor %** | `0` |
| **Recargo de Equivalencia %** | `0` |
| **Limitar a tipo de Venta 1** | [Tipo de Venta: REB](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-reb) |
# Impuesto: VIES (/docs/rtg/pymes/configuracion/impuestos/impuesto-vies)
Configuración del impuesto al 0% para **ventas intracomunitarias** a empresas con número de IVA válido en VIES.
| Campo | Val |
| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------- |
| **Tipo** | `IVA` |
| **Clasificación de operación** | `S1: Operación Sujeta y No exenta - Sin inversión del sujeto pasivo` |
| **Clave de régimen** | `01: Operación de régimen general` |
| **Causa (Sujeción)** | `E5: Exenta por artículo 25` |
| **Valor %** | `0` |
| **Recargo de Equivalencia %** | `0` |
| **Limitar a tipo de Venta 1** | [Tipo de Venta: Intracomunitaria (VIES)](/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-intracomunitaria-vies) |
# Impuestos (/docs/rtg/pymes/configuracion/impuestos)
### Campos del impuesto [#campos-del-impuesto]
### TPV [#tpv]
En `TPV` únicamente aparecen los marcados como `Disponible en TPV`, ya que está pensado para ventas sencillas (generalmente facturas simplificadas en puntos de venta: supermercados, hostelería...).
## Campos [#campos]
Cada Tipo de Venta permite ajustar múltiples opciones para adaptarse a cada situación:
Para minimizar errores, se recomienda aplicar la siguiente configuración:
* Permisión NIF en AEAT: `No`.
* Permisión NIF en VIES: `No`.
Dinaup valida el NIF del cliente para determinar si se debe aplicar esta configuración. Esto asegura que el sistema lo interprete como una venta a consumidor final y no como una operación intracomunitaria o nacional.
***
*⚠️ Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
# Tipo de Venta: REB (/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-reb)
Tipo específico para ventas de bienes usados, antigüedades o arte bajo el régimen especial. No desglosa IVA en la factura, solo aplica a margen de beneficio.
***
*⚠️ Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
# Tipo de Venta: Simplificada (/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-simplificada)
Tipo orientado a ventas de mostrador o tickets, donde no se recogen datos del cliente. Para operaciones rápidas, anónimas y de bajo importe.
***
*⚠️ Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*
# Tipo de Venta: TPV Hostelería (/docs/rtg/pymes/facturacion/ventas/tipos-de-ventas-e-ingresos/tipo-de-venta-tpv-hosteleria)
Tipo de venta pensado para operaciones rápidas en bares, cafeterías o restaurantes. Similar a simplificada, pero permite gestionar tickets, mesas, cuentas y otras funciones específicas de hostelería.
***
*⚠️ Esta información tiene carácter orientativo. Te recomendamos consultar con tu asesor fiscal antes de aplicarla a tu caso concreto.*