451 lines
21 KiB
Java
451 lines
21 KiB
Java
/*
|
|
* To change this license header, choose License Headers in Project Properties.
|
|
* To change this template file, choose Tools | Templates
|
|
* and open the template in the editor.
|
|
*/
|
|
package com.qsoft.erp.dominio.util;
|
|
|
|
import com.fasterxml.jackson.core.JsonParser;
|
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
|
import com.qsoft.dao.exception.DaoException;
|
|
import com.qsoft.util.constantes.CodigoRespuesta;
|
|
import com.qsoft.util.constantes.ErrorTipo;
|
|
import com.qsoft.util.ms.pojo.HeaderMS;
|
|
import com.qsoft.erp.constantes.DetalleCatalogoEnum;
|
|
import com.qsoft.erp.constantes.DominioConstantes;
|
|
import com.qsoft.erp.constantes.EntidadEnum;
|
|
import com.qsoft.erp.constantes.EstadoLiquidacionEnum;
|
|
import com.qsoft.erp.dao.DaoGenerico;
|
|
import com.qsoft.erp.dto.DetalleLiquidacionDTO;
|
|
import com.qsoft.erp.dto.DocumentoDTO;
|
|
import com.qsoft.erp.dto.EstadoLiquidacionDTO;
|
|
import com.qsoft.erp.dto.LiquidacionDTO;
|
|
import com.qsoft.erp.model.DetalleCatalogo;
|
|
import com.qsoft.erp.model.DetalleLiquidacion;
|
|
import com.qsoft.erp.model.Documento;
|
|
import com.qsoft.erp.model.EstadoLiquidacion;
|
|
import com.qsoft.erp.model.Liquidacion;
|
|
import com.qsoft.erp.model.Usuario;
|
|
import java.io.File;
|
|
import java.io.FileOutputStream;
|
|
import java.io.IOException;
|
|
import java.util.ArrayList;
|
|
import java.util.Calendar;
|
|
import java.util.Date;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import javax.annotation.PostConstruct;
|
|
import javax.ejb.EJB;
|
|
import javax.ejb.Stateless;
|
|
import static com.qsoft.erp.dominio.AccionGenerica.ACTUALIZA;
|
|
import static com.qsoft.erp.dominio.AccionGenerica.CONSULTA;
|
|
import static com.qsoft.erp.dominio.AccionGenerica.ELIMINA;
|
|
import static com.qsoft.erp.dominio.AccionGenerica.GUARDA;
|
|
import static com.qsoft.erp.dominio.AccionGenerica.ACTUALIZA_ONSITE;
|
|
import static com.qsoft.erp.dominio.AccionGenerica.CANCELA;
|
|
import com.qsoft.erp.dominio.exception.DominioExcepcion;
|
|
import com.qsoft.erp.dominio.mapper.DetalleLiquidacionMapper;
|
|
import com.qsoft.erp.constantes.SecuenciaEnum;
|
|
import com.qsoft.erp.dto.TarifaLiquidacionDTO;
|
|
import com.qsoft.erp.model.Poliza;
|
|
import com.qsoft.erp.model.TarifaLiquidacion;
|
|
import java.util.HashMap;
|
|
import java.util.Objects;
|
|
import javax.transaction.Transactional;
|
|
|
|
/**
|
|
*
|
|
* @author james
|
|
*/
|
|
@Stateless
|
|
public class LiquidacionUtil {
|
|
|
|
@EJB
|
|
private DominioUtil dominioUtil;
|
|
|
|
@EJB
|
|
private LiquidacionCalc liquidacionCalcs;
|
|
|
|
@EJB
|
|
private NotificadorUtil notificadorUtil;
|
|
|
|
@EJB
|
|
private SecuenciaUtil secuenciaUtil;
|
|
|
|
@EJB
|
|
private CatalogoUtil catalogoUtil;
|
|
|
|
@PostConstruct
|
|
public void postConstruct() {
|
|
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param header
|
|
* @param datos
|
|
* @return
|
|
* @throws DominioExcepcion
|
|
*/
|
|
@Transactional(Transactional.TxType.REQUIRES_NEW)
|
|
public List<Liquidacion> guardarLiquidacion(HeaderMS header, Map<String, LiquidacionDTO> datos) throws DominioExcepcion {
|
|
List<Liquidacion> data = new ArrayList<>();
|
|
DaoGenerico<Liquidacion, Integer> daoliq = new DaoGenerico<>(Liquidacion.class);
|
|
DaoGenerico<Usuario, Integer> daousu = new DaoGenerico<>(Usuario.class);
|
|
DaoGenerico<Poliza, Integer> daopol = new DaoGenerico<>(Poliza.class);
|
|
for (Map.Entry<String, LiquidacionDTO> entry : datos.entrySet()) {
|
|
try {
|
|
Liquidacion liq;
|
|
System.out.println("==============> GUARDAR LIQUIDACION.....");
|
|
liq = (Liquidacion) this.dominioUtil.getEntidad(EntidadEnum.Liquidacion.getMapper(), entry.getValue());
|
|
long cod = this.secuenciaUtil.getSecuencia(SecuenciaEnum.LIQMED);
|
|
liq.setLiqNemonico(this.dominioUtil.getCodLiquidacion(cod));
|
|
Poliza pol = daopol.cargar(entry.getValue().getPolCodigo());
|
|
liq.setPolCodigo(pol);
|
|
liq.setLiqFechaRegistro(new Date());
|
|
liq.setDocumentoCollection(this.crearDocumentos(liq, entry.getValue()));
|
|
liq.setEstadoLiquidacionCollection(new ArrayList<>());
|
|
Usuario usuario = EstadoLiquidacionEnum.ESTLI.getUsuarioGenerico();
|
|
liq.getEstadoLiquidacionCollection().add(this.crearEstadoInicial(liq, usuario));
|
|
daoliq.guardar(liq);
|
|
Usuario user = new Usuario();
|
|
user.setUsuUsuario(header.getUsuario());
|
|
user.setUsuEstado(DominioConstantes.ACTIVO);
|
|
user = daousu.buscarUnico(user);
|
|
this.notificadorUtil.notificarLiquidacion(user, liq);
|
|
data.add(liq);
|
|
} catch (DaoException ex) {
|
|
throw new DominioExcepcion(ErrorTipo.FATAL, CodigoRespuesta.CODIGO_VALOR_NULO,
|
|
"Error registrando liquidacion en BDD " + ex);
|
|
}
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param header
|
|
* @param datos
|
|
* @param tipoAccion
|
|
* @return
|
|
* @throws DominioExcepcion
|
|
*/
|
|
@Transactional(Transactional.TxType.REQUIRES_NEW)
|
|
public List<Liquidacion> actualizarLiquidacion(HeaderMS header, Map<String, LiquidacionDTO> datos, int tipoAccion) throws DominioExcepcion {
|
|
List<Liquidacion> data = new ArrayList<>();
|
|
DaoGenerico<Liquidacion, Integer> daoliq = new DaoGenerico<>(Liquidacion.class);
|
|
for (Map.Entry<String, LiquidacionDTO> entry : datos.entrySet()) {
|
|
LiquidacionDTO liquidacion = entry.getValue();
|
|
Liquidacion liq = null;
|
|
//TODO: aqui puede ser consulta por CONTRATO
|
|
liq = daoliq.buscar(liquidacion.getLiqCodigo());
|
|
if (liq != null) {
|
|
try {
|
|
boolean saltoFlujo = false;
|
|
EstadoLiquidacion estado = null;
|
|
liq.getDocumentoCollection().addAll(this.crearDocumentos(liq, liquidacion));
|
|
if (tipoAccion != ACTUALIZA_ONSITE) {
|
|
EstadoLiquidacion previo = null;
|
|
for (EstadoLiquidacion es : liq.getEstadoLiquidacionCollection()) {
|
|
if (Objects.equals(DominioConstantes.ACTIVO, es.getEslEstado())) {
|
|
es.setEslEstado(DominioConstantes.INACTIVO);
|
|
es.setEslFechaFin(new Date());
|
|
previo = es;
|
|
}
|
|
}
|
|
if (liquidacion.getEstados() != null && !liquidacion.getEstados().isEmpty()) {
|
|
System.out.println("=====> ATENCION? " + liq.getDetAtencion() + " => " + liquidacion.getDetAtencion());
|
|
Integer codAt = liq.getDetAtencion() != null && liq.getDetAtencion().getDetCodigo() != null
|
|
? liq.getDetAtencion().getDetCodigo() : liquidacion.getDetAtencion();
|
|
DetalleCatalogo atencion = this.catalogoUtil.cargar(codAt);
|
|
|
|
saltoFlujo = atencion != null && atencion.getDetNemonico().equals(DetalleCatalogoEnum.ATHE.name())
|
|
|| atencion != null && atencion.getDetNemonico().equals(DetalleCatalogoEnum.ATAH.name())
|
|
|| atencion != null && atencion.getDetNemonico().equals(DetalleCatalogoEnum.ATHOS.name());
|
|
for (EstadoLiquidacionDTO es : liquidacion.getEstados()) {
|
|
estado = this.crearEstado(liq, es, previo, saltoFlujo, tipoAccion);
|
|
liq.getEstadoLiquidacionCollection().add(estado);
|
|
}
|
|
}
|
|
}
|
|
daoliq.actualizar(liq);
|
|
if (estado != null && estado.getDetEstado().getDetNemonico().equalsIgnoreCase(EstadoLiquidacionEnum.ESTLIC.name())
|
|
&& liq.getDetTipo().getDetNemonico().equalsIgnoreCase(DetalleCatalogoEnum.TIPLQPR.name()) && !saltoFlujo && tipoAccion == GUARDA) {
|
|
System.out.println("PROCESAR LIQUIDACION PRESTADOR ESTLIC");
|
|
liq = this.liquidacionCalcs.procesarLiquidacion(liq, true);
|
|
}
|
|
if (estado != null && estado.getDetEstado().getDetNemonico().equalsIgnoreCase(EstadoLiquidacionEnum.ESTLQC.name())
|
|
&& liq.getDetTipo().getDetNemonico().equalsIgnoreCase(DetalleCatalogoEnum.TIPLQPR.name()) && saltoFlujo && tipoAccion == GUARDA) {
|
|
System.out.println("PROCESAR LIQUIDACION PRESTADOR ESTLQC");
|
|
liq = this.liquidacionCalcs.procesarLiquidacion(liq, false);
|
|
}
|
|
if (estado != null && estado.getDetEstado().getDetNemonico().equalsIgnoreCase(EstadoLiquidacionEnum.ESTLQC.name())
|
|
&& !liq.getDetTipo().getDetNemonico().equalsIgnoreCase(DetalleCatalogoEnum.TIPLQPR.name()) && tipoAccion == GUARDA) {
|
|
System.out.println("PROCESAR LIQUIDACION NO PRESTADOR ESTLQC");
|
|
liq = this.liquidacionCalcs.procesarLiquidacion(liq, false);
|
|
}
|
|
|
|
Usuario user = this.dominioUtil.getTitularLiquidacion(liq.getLiqCodigo());
|
|
if (tipoAccion != ACTUALIZA_ONSITE && estado != null) {
|
|
this.notificadorUtil.notificarEstadoLiquidacion(liq, user, estado);
|
|
}
|
|
data.add(liq);
|
|
} catch (DaoException ex) {
|
|
throw new DominioExcepcion(ErrorTipo.FATAL, CodigoRespuesta.CODIGO_ERROR_GUARDA_BDD, "ERROR, " + ex);
|
|
}
|
|
} else {
|
|
throw new DominioExcepcion(ErrorTipo.ERROR, CodigoRespuesta.CODIGO_VALOR_NULO, "ERROR, No existe la liquidacion con el codigo " + liquidacion.getLiqCodigo());
|
|
}
|
|
}
|
|
return data;
|
|
}
|
|
|
|
/**
|
|
* @param header
|
|
* @param entidades
|
|
* @param tipoAccion
|
|
* @return
|
|
* @throws com.qsoft.erp.dominio.exception.DominioExcepcion
|
|
*/
|
|
@Transactional(Transactional.TxType.REQUIRES_NEW)
|
|
public List<DetalleLiquidacion> procesarDetalleLiquidacion(HeaderMS header, List<Map<String, Object>> entidades, int tipoAccion) throws DominioExcepcion {
|
|
List<DetalleLiquidacion> data = new ArrayList<>();
|
|
for (Map<String, Object> ent : entidades) {
|
|
DetalleLiquidacionDTO detalle = (DetalleLiquidacionDTO) dominioUtil.crearObjeto(DetalleLiquidacionDTO.class, ent);
|
|
List<TarifaLiquidacionDTO> lista = new ArrayList<>();
|
|
ObjectMapper maper = new ObjectMapper();
|
|
maper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
|
|
if (ent.containsKey("detalle")) {
|
|
for (Object row : (List<Object>) ent.get("detalle")) {
|
|
TarifaLiquidacionDTO col = (TarifaLiquidacionDTO) dominioUtil.crearObjeto(TarifaLiquidacionDTO.class, (Map<String, Object>) row);
|
|
lista.add(col);
|
|
}
|
|
}
|
|
detalle.setDetalle(lista);
|
|
DetalleLiquidacion result = crudDetalle(detalle, tipoAccion);
|
|
data.add(result);
|
|
}
|
|
return data;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param detalle
|
|
* @param tipoAccion
|
|
* @return
|
|
* @throws DominioExcepcion
|
|
*/
|
|
@Transactional(Transactional.TxType.REQUIRES_NEW)
|
|
private DetalleLiquidacion crudDetalle(DetalleLiquidacionDTO detalle, int tipoAccion) throws DominioExcepcion {
|
|
DaoGenerico<DetalleLiquidacion, Integer> daodel = new DaoGenerico<>(DetalleLiquidacion.class);
|
|
DetalleLiquidacion result;
|
|
result = DetalleLiquidacionMapper.INSTANCE.getEntidad(detalle);
|
|
result.setTarifaLiquidacionCollection(this.crearTarifas(detalle, result));
|
|
switch (tipoAccion) {
|
|
case CONSULTA: {
|
|
throw new DominioExcepcion(ErrorTipo.ERROR, CodigoRespuesta.CODIGO_ERROR_GENERICO,
|
|
"Operacion CONSULTA no soportada para el controlador de Accion");
|
|
}
|
|
case GUARDA: {
|
|
try {
|
|
daodel.guardar(result);
|
|
} catch (DaoException ex) {
|
|
throw new DominioExcepcion(ErrorTipo.FATAL, CodigoRespuesta.CODIGO_ERROR_GUARDA_BDD, ex.toString());
|
|
}
|
|
}
|
|
break;
|
|
case ACTUALIZA: {
|
|
try {
|
|
DaoGenerico<TarifaLiquidacion, Integer> daotar = new DaoGenerico<>(TarifaLiquidacion.class);
|
|
for (TarifaLiquidacion tar : result.getTarifaLiquidacionCollection()) {
|
|
daotar.actualizar(tar);
|
|
}
|
|
result = daodel.actualizar(result);
|
|
} catch (DaoException ex) {
|
|
throw new DominioExcepcion(ErrorTipo.FATAL, CodigoRespuesta.CODIGO_ERROR_ACTUALIZA_BDD, ex.toString());
|
|
}
|
|
}
|
|
break;
|
|
case ELIMINA: {
|
|
throw new DominioExcepcion(ErrorTipo.ERROR, CodigoRespuesta.CODIGO_ERROR_GENERICO,
|
|
"Operacion ELIMINACION aun no permitida, debe eliminar la Liquidacion");
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return
|
|
*/
|
|
private EstadoLiquidacion crearEstadoInicial(Liquidacion liquidacion, Usuario usuario) throws DaoException {
|
|
EstadoLiquidacion est = new EstadoLiquidacion();
|
|
est.setDetEstado(EstadoLiquidacionEnum.ESTLI.getDetalle());
|
|
est.setEslEstado(DominioConstantes.ACTIVO);
|
|
est.setEslFechaInicio(new Date());
|
|
est.setEslMensaje(DominioConstantes.MENSAJE_AUTO);
|
|
est.setLiqCodigo(liquidacion);
|
|
est.setUsuCodigo(usuario);
|
|
return est;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param liquida
|
|
* @param liquidacion
|
|
* @throws DaoException
|
|
*/
|
|
private EstadoLiquidacion crearEstado(Liquidacion liquida, EstadoLiquidacionDTO estadoDto,
|
|
EstadoLiquidacion previo, boolean saltoFlujo, int tipoAccion) throws DaoException {
|
|
EstadoLiquidacion estado = new EstadoLiquidacion();
|
|
DetalleCatalogo est = new DetalleCatalogo();
|
|
|
|
if (tipoAccion == GUARDA) { //TODO: Avanza estado
|
|
if (liquida.getDetTipo().getDetNemonico().equalsIgnoreCase(DetalleCatalogoEnum.TIPLQPR.name())
|
|
&& previo.getDetEstado().getDetNemonico().equals(EstadoLiquidacionEnum.ESTLI.name()) && !saltoFlujo) {
|
|
est = EstadoLiquidacionEnum.ESTLIC.getDetalle();
|
|
} else {
|
|
est = EstadoLiquidacionEnum.getSiguiente(previo.getDetEstado().getDetCodigo(), true);
|
|
}
|
|
} else if (tipoAccion == ACTUALIZA) {//TODO: Retroceder estado, siempre retrocede al usuario previo
|
|
if (liquida.getDetTipo().getDetNemonico().equalsIgnoreCase(DetalleCatalogoEnum.TIPLQPR.name())
|
|
&& previo.getDetEstado().getDetNemonico().equals(EstadoLiquidacionEnum.ESTLIC.name()) && !saltoFlujo) {
|
|
est = EstadoLiquidacionEnum.ESTLI.getDetalle();
|
|
} else {
|
|
est = EstadoLiquidacionEnum.getSiguiente(previo.getDetEstado().getDetCodigo(), false);
|
|
}
|
|
if (est != null && est.getDetNemonico().equalsIgnoreCase(EstadoLiquidacionEnum.ESTALI.name())) {
|
|
estado.setUsuCodigo(this.dominioUtil.getTitularLiquidacion(liquida.getLiqCodigo()));
|
|
}
|
|
} else if (tipoAccion == CANCELA) {
|
|
est = EstadoLiquidacionEnum.ESTCAN.getDetalle();
|
|
estado.setUsuCodigo(previo.getUsuCodigo());
|
|
} else {
|
|
throw new DaoException("Especificar si desea avanzar o retroceder de estado");
|
|
}
|
|
for (EstadoLiquidacion esli : liquida.getEstadoLiquidacionCollection()) {
|
|
if (esli.getDetEstado().getDetNemonico().equals(est.getDetNemonico())) {
|
|
estado.setUsuCodigo(esli.getUsuCodigo());
|
|
}
|
|
}
|
|
if (estado.getUsuCodigo() == null || estado.getUsuCodigo().getUsuCodigo() == null) {
|
|
EstadoLiquidacionEnum enu = EstadoLiquidacionEnum.valueOf(est.getDetNemonico());
|
|
System.out.println("No hay usuario, vamos a obtener el generico " + enu);
|
|
estado.setUsuCodigo(enu.getUsuarioGenerico());
|
|
}
|
|
estado.setDetEstado(est);
|
|
estado.setEslFechaInicio(new Date());
|
|
estado.setEslEstado(DominioConstantes.ACTIVO);
|
|
estado.setEslMensaje(estadoDto.getEslMensaje());
|
|
estado.setLiqCodigo(liquida);
|
|
return estado;
|
|
}
|
|
|
|
public HashMap<String,String> obtenerTodosDocumentosLiquidacion(Integer liqCodigo) throws DaoException, DominioExcepcion{
|
|
DaoGenerico<Liquidacion,Integer> daoliq = new DaoGenerico<>(Liquidacion.class);
|
|
DaoGenerico<Documento,Integer> daodoc = new DaoGenerico<>(Documento.class);
|
|
HashMap<String,String> result = new HashMap<>();
|
|
Liquidacion liquidacion = daoliq.buscarUnico(new Liquidacion(liqCodigo));
|
|
//List<String> result = new ArrayList<>();
|
|
if(liquidacion == null){
|
|
throw new DominioExcepcion(ErrorTipo.ERROR, CodigoRespuesta.CODIGO_ERROR_CONSULTA_BDD,
|
|
"No se encontro la liquidacion para el codigo enviado");
|
|
}
|
|
Documento documentoPlantilla = new Documento();
|
|
documentoPlantilla.setDocEstado(DominioConstantes.ACTIVO);
|
|
documentoPlantilla.setLiqCodigo(liquidacion);
|
|
List<Documento> lstDocumentos = daodoc.buscarLista(documentoPlantilla);
|
|
if(lstDocumentos == null || lstDocumentos.isEmpty()){
|
|
throw new DominioExcepcion(ErrorTipo.ERROR, CodigoRespuesta.CODIGO_ERROR_CONSULTA_BDD,
|
|
String.format("No se ha encontrado documentos para la liquidacion %s", liquidacion.getLiqNemonico()));
|
|
}
|
|
|
|
File archivoZip = procesarZipLiquidacion(liquidacion, lstDocumentos);
|
|
result.put("nombre",archivoZip.getName());
|
|
result.put("documento",dominioUtil.getArchivo(archivoZip.getAbsolutePath()));
|
|
|
|
archivoZip.delete();
|
|
return result;
|
|
}
|
|
|
|
private File procesarZipLiquidacion(Liquidacion liquidacion, List<Documento> lstDocumentos){
|
|
String url = DetalleCatalogoEnum.URLLIQ.getDetalle().getDetOrigen();
|
|
Documento primero = lstDocumentos.get(0);
|
|
String nemonico = liquidacion.getLiqNemonico();
|
|
String urlTmp = String.format("tmp", nemonico);
|
|
|
|
String folderPrimero = primero.getDocUrl();
|
|
String folderAnio[] = folderPrimero.split("/".concat(primero.getDocNombre()));
|
|
String folderArchivoPosible = folderAnio[0];
|
|
File zip = dominioUtil.crearZip(folderArchivoPosible, liquidacion.getLiqNemonico().concat(".zip"), true);
|
|
// /data/wmp/liquidacion/2020/LQ0000000080/img076.pdf
|
|
|
|
return zip;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param liquidacion
|
|
*/
|
|
private List<Documento> crearDocumentos(Liquidacion liquida, LiquidacionDTO liquidacion) throws DaoException {
|
|
List<Documento> documentos = new ArrayList<>();
|
|
if (liquidacion.getDocumentos() != null) {
|
|
for (DocumentoDTO doc : liquidacion.getDocumentos()) {
|
|
Documento dcto = (Documento) dominioUtil.getEntidad(EntidadEnum.Documento.getMapper(), doc);
|
|
dcto.setDetTipo(DetalleCatalogoEnum.HABIL.getDetalle());
|
|
dcto.setDocEstado(DominioConstantes.ACTIVO);
|
|
dcto.setLiqCodigo(liquida);
|
|
dcto.setPolCodigo(liquida.getPolCodigo());
|
|
String url = this.grabaDocumento(doc, liquida.getLiqNemonico());
|
|
dcto.setDocUrl(url);
|
|
documentos.add(dcto);
|
|
}
|
|
}
|
|
return documentos;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param doc
|
|
* @param contrato
|
|
* @param liquidacion
|
|
* @return
|
|
*/
|
|
private String grabaDocumento(DocumentoDTO doc, String liquidacion) {
|
|
String url = DetalleCatalogoEnum.URLLIQ.getDetalle().getDetOrigen();
|
|
int year = Calendar.getInstance().get(Calendar.YEAR);
|
|
url = String.format(url, "" + year, liquidacion);
|
|
File file = new File(url);
|
|
try {
|
|
file.mkdirs();
|
|
url = url.concat(doc.getDocNombre());
|
|
FileOutputStream writer;
|
|
writer = new FileOutputStream(new File(url));
|
|
writer.write(doc.getData());
|
|
writer.close();
|
|
} catch (IOException | NullPointerException ex) {
|
|
url = null;
|
|
}
|
|
return url;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param detalleDTO
|
|
* @return
|
|
* @throws DaoException
|
|
*/
|
|
private List<TarifaLiquidacion> crearTarifas(DetalleLiquidacionDTO detalleDTO, DetalleLiquidacion detalle) {
|
|
List<TarifaLiquidacion> data = new ArrayList<>();
|
|
for (TarifaLiquidacionDTO tarDto : detalleDTO.getDetalle()) {
|
|
TarifaLiquidacion tarifa = (TarifaLiquidacion) dominioUtil.getEntidad(EntidadEnum.TarifaLiquidacion.getMapper(), tarDto);
|
|
tarifa.setDelCodigo(detalle);
|
|
data.add(tarifa);
|
|
}
|
|
System.out.println("=========> TARIFAS " + data);
|
|
return data;
|
|
}
|
|
|
|
}
|