mirror of
https://git.imnavajas.es/jjimenez/erp-imprimelibros.git
synced 2026-01-12 16:38:48 +00:00
766 lines
31 KiB
Java
766 lines
31 KiB
Java
package com.imprimelibros.erp.pedidos;
|
|
|
|
import java.time.Instant;
|
|
import java.time.LocalDateTime;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.Map;
|
|
|
|
import org.springframework.context.MessageSource;
|
|
import org.springframework.stereotype.Service;
|
|
import org.springframework.transaction.annotation.Transactional;
|
|
|
|
import com.imprimelibros.erp.cart.Cart;
|
|
import com.imprimelibros.erp.cart.CartDireccion;
|
|
import com.imprimelibros.erp.cart.CartItem;
|
|
import com.imprimelibros.erp.cart.CartService;
|
|
import com.imprimelibros.erp.common.Utils;
|
|
import com.imprimelibros.erp.direcciones.Direccion;
|
|
import com.imprimelibros.erp.presupuesto.PresupuestoRepository;
|
|
import com.imprimelibros.erp.presupuesto.dto.Presupuesto;
|
|
import com.imprimelibros.erp.presupuesto.service.PresupuestoService;
|
|
import com.imprimelibros.erp.users.UserService;
|
|
import com.imprimelibros.erp.direcciones.DireccionService;
|
|
import com.imprimelibros.erp.externalApi.skApiClient;
|
|
import com.imprimelibros.erp.facturacion.FacturaDireccion;
|
|
import com.imprimelibros.erp.facturacion.dto.DireccionFacturacionDto;
|
|
import com.imprimelibros.erp.pedidos.PedidoLinea.Estado;
|
|
|
|
@Service
|
|
public class PedidoService {
|
|
|
|
private final PedidoRepository pedidoRepository;
|
|
private final PedidoLineaRepository pedidoLineaRepository;
|
|
private final PresupuestoRepository presupuestoRepository;
|
|
private final PedidoDireccionRepository pedidoDireccionRepository;
|
|
private final DireccionService direccionService;
|
|
private final UserService userService;
|
|
private final PresupuestoService presupuestoService;
|
|
private final CartService cartService;
|
|
private final skApiClient skApiClient;
|
|
private final PresupuestoRepository presupuestoRepo;
|
|
private final MessageSource messageSource;
|
|
|
|
public PedidoService(PedidoRepository pedidoRepository, PedidoLineaRepository pedidoLineaRepository,
|
|
PresupuestoRepository presupuestoRepository, PedidoDireccionRepository pedidoDireccionRepository,
|
|
DireccionService direccionService, UserService userService, PresupuestoService presupuestoService,
|
|
CartService cartService, skApiClient skApiClient, PresupuestoRepository presupuestoRepo,
|
|
MessageSource messageSource) {
|
|
this.pedidoRepository = pedidoRepository;
|
|
this.pedidoLineaRepository = pedidoLineaRepository;
|
|
this.presupuestoRepository = presupuestoRepository;
|
|
this.pedidoDireccionRepository = pedidoDireccionRepository;
|
|
this.direccionService = direccionService;
|
|
this.userService = userService;
|
|
this.presupuestoService = presupuestoService;
|
|
this.cartService = cartService;
|
|
this.skApiClient = skApiClient;
|
|
this.presupuestoRepo = presupuestoRepo;
|
|
this.messageSource = messageSource;
|
|
}
|
|
|
|
public Pedido getPedidoById(Long pedidoId) {
|
|
return pedidoRepository.findById(pedidoId).orElse(null);
|
|
}
|
|
|
|
public PedidoDireccion getPedidoDireccionFacturacionByPedidoId(Long pedidoId) {
|
|
return pedidoDireccionRepository.findByPedidoIdAndFacturacionTrue(pedidoId);
|
|
}
|
|
|
|
@Transactional
|
|
public Pedido crearPedido(
|
|
Long cartId,
|
|
Long direccionFacturacionId,
|
|
String proveedor,
|
|
String proveedorRef) {
|
|
|
|
Pedido pedido = new Pedido();
|
|
|
|
Cart cart = cartService.getCartById(cartId);
|
|
Map<String, Object> cartSummaryRaw = cartService.getCartSummaryRaw(cart, Locale.getDefault());
|
|
|
|
// Datos económicos (ojo con las claves, son las del summaryRaw)
|
|
pedido.setBase((Double) cartSummaryRaw.getOrDefault("base", 0.0d));
|
|
pedido.setEnvio((Double) cartSummaryRaw.getOrDefault("shipment", 0.0d));
|
|
pedido.setIva4((Double) cartSummaryRaw.getOrDefault("iva4", 0.0d));
|
|
pedido.setIva21((Double) cartSummaryRaw.getOrDefault("iva21", 0.0d));
|
|
pedido.setDescuento((Double) cartSummaryRaw.getOrDefault("descuento", 0.0d));
|
|
pedido.setTotal((Double) cartSummaryRaw.getOrDefault("total", 0.0d));
|
|
|
|
// Proveedor
|
|
if (proveedor != null && proveedorRef != null) {
|
|
pedido.setProveedor(proveedor);
|
|
pedido.setProveedorRef(proveedorRef);
|
|
}
|
|
|
|
// Auditoría mínima
|
|
/*
|
|
* Long userId = cart.getUserId();
|
|
* pedido.setCreatedBy(userService.findById(userId));
|
|
* pedido.setUpdatedBy(userService.findById(userId));
|
|
*/
|
|
// Se obtiene el usuario del primer presupuesto del carrito
|
|
Long userId = null;
|
|
List<CartItem> cartItems = cart.getItems();
|
|
if (!cartItems.isEmpty()) {
|
|
Presupuesto firstPresupuesto = cartItems.get(0).getPresupuesto();
|
|
if (firstPresupuesto != null) {
|
|
userId = firstPresupuesto.getUser().getId();
|
|
}
|
|
}
|
|
if (userId == null) {
|
|
userId = cart.getUserId();
|
|
}
|
|
pedido.setCreatedBy(userService.findById(userId));
|
|
pedido.setUpdatedBy(userService.findById(userId));
|
|
pedido.setCreatedAt(Instant.now());
|
|
pedido.setDeleted(false);
|
|
pedido.setUpdatedAt(Instant.now());
|
|
|
|
// Guardamos el pedido
|
|
Pedido pedidoGuardado = pedidoRepository.save(pedido);
|
|
pedidoGuardado.setCreatedBy(userService.findById(userId));
|
|
pedidoGuardado.setUpdatedBy(userService.findById(userId));
|
|
pedidoRepository.save(pedidoGuardado);
|
|
|
|
List<CartItem> items = cart.getItems();
|
|
|
|
for (Integer i = 0; i < items.size(); i++) {
|
|
CartItem item = items.get(i);
|
|
Presupuesto pCart = item.getPresupuesto();
|
|
|
|
// Asegurarnos de trabajar con la entidad gestionada por JPA
|
|
Presupuesto p = presupuestoRepository.findById(pCart.getId())
|
|
.orElseThrow(() -> new IllegalStateException("Presupuesto no encontrado: " + pCart.getId()));
|
|
p.setEstado(Presupuesto.Estado.aceptado);
|
|
presupuestoRepository.save(p);
|
|
|
|
PedidoLinea linea = new PedidoLinea();
|
|
linea.setPedido(pedidoGuardado);
|
|
linea.setPresupuesto(p);
|
|
linea.setCreatedBy(userId);
|
|
linea.setCreatedAt(LocalDateTime.now());
|
|
linea.setEstado(PedidoLinea.Estado.pendiente_pago);
|
|
linea.setEstadoManual(false);
|
|
pedidoLineaRepository.save(linea);
|
|
|
|
// Guardar las direcciones asociadas a la línea del pedido
|
|
Map<String, Object> direcciones_presupuesto = this.getDireccionesPresupuesto(cart, p);
|
|
saveDireccionesPedidoLinea(direcciones_presupuesto, pedidoGuardado, linea, direccionFacturacionId);
|
|
|
|
}
|
|
|
|
return pedidoGuardado;
|
|
}
|
|
|
|
public Boolean markPedidoAsProcesingPayment(Long pedidoId) {
|
|
Pedido pedido = pedidoRepository.findById(pedidoId).orElse(null);
|
|
if (pedido == null) {
|
|
return false;
|
|
}
|
|
List<PedidoLinea> lineas = pedidoLineaRepository.findByPedidoId(pedidoId);
|
|
for (PedidoLinea linea : lineas) {
|
|
linea.setEstado(PedidoLinea.Estado.procesando_pago);
|
|
pedidoLineaRepository.save(linea);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public Boolean markPedidoAsPaymentDenied(Long pedidoId) {
|
|
Pedido pedido = pedidoRepository.findById(pedidoId).orElse(null);
|
|
if (pedido == null) {
|
|
return false;
|
|
}
|
|
List<PedidoLinea> lineas = pedidoLineaRepository.findByPedidoId(pedidoId);
|
|
for (PedidoLinea linea : lineas) {
|
|
linea.setEstado(PedidoLinea.Estado.denegado_pago);
|
|
pedidoLineaRepository.save(linea);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public Pedido findById(Long pedidoId) {
|
|
return pedidoRepository.findById(pedidoId).orElse(null);
|
|
}
|
|
|
|
@Transactional
|
|
public Boolean upsertDireccionFacturacion(Long pedidoId, DireccionFacturacionDto direccionData) {
|
|
|
|
try {
|
|
Pedido pedido = pedidoRepository.findById(pedidoId).orElse(null);
|
|
if (pedido != null) {
|
|
|
|
PedidoDireccion direccionPedido = pedidoDireccionRepository.findByPedidoIdAndFacturacionTrue(pedidoId);
|
|
|
|
if (direccionPedido == null) {
|
|
// crear
|
|
direccionPedido = direccionData.toPedidoDireccion();
|
|
direccionPedido.setPedido(pedido);
|
|
|
|
} else {
|
|
// actualizar en la existente (NO crees una nueva, para conservar ID)
|
|
direccionData.applyTo(direccionPedido); // si implementas applyTo()
|
|
direccionPedido.setFacturacion(true); // por si acaso
|
|
}
|
|
|
|
pedidoDireccionRepository.save(direccionPedido);
|
|
}
|
|
|
|
return true;
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/** Lista de los items del pedido preparados para la vista */
|
|
@Transactional
|
|
public List<Map<String, Object>> getLineas(Long pedidoId, Locale locale) {
|
|
Pedido p = pedidoRepository.findById(pedidoId).orElse(null);
|
|
if (p == null) {
|
|
return new ArrayList<>();
|
|
}
|
|
|
|
List<Map<String, Object>> resultados = new ArrayList<>();
|
|
List<PedidoLinea> items = pedidoLineaRepository.findByPedidoIdOrderByIdAsc(p.getId());
|
|
for (PedidoLinea item : items) {
|
|
|
|
Presupuesto presupuesto = item.getPresupuesto();
|
|
Map<String, Object> elemento = presupuestoService.getPresupuestoInfoForCard(presupuesto, locale);
|
|
elemento.put("estado", item.getEstado());
|
|
elemento.put("fechaEntrega",
|
|
item.getFechaEntrega() != null ? Utils.formatDate(item.getFechaEntrega(), locale) : "");
|
|
elemento.put("lineaId", item.getId());
|
|
resultados.add(elemento);
|
|
}
|
|
return resultados;
|
|
}
|
|
|
|
public PedidoDireccion getDireccionFacturacionPedido(Long pedidoId) {
|
|
return pedidoDireccionRepository.findByPedidoIdAndFacturacionTrue(pedidoId);
|
|
}
|
|
|
|
public List<PedidoDireccion> getDireccionesEntregaPedidoLinea(Long pedidoLineaId) {
|
|
return pedidoDireccionRepository.findByPedidoLinea_Id(pedidoLineaId);
|
|
}
|
|
|
|
public Boolean setOrderAsPaid(Long pedidoId) {
|
|
Pedido pedido = pedidoRepository.findById(pedidoId).orElse(null);
|
|
if (pedido == null) {
|
|
return false;
|
|
}
|
|
List<PedidoLinea> lineas = pedidoLineaRepository.findByPedidoId(pedidoId);
|
|
List<Map<String, Object>> referenciasProveedor = new ArrayList<>();
|
|
Integer total = lineas.size();
|
|
Integer counter = 1;
|
|
for (PedidoLinea linea : lineas) {
|
|
if (linea.getEstado() == Estado.pendiente_pago
|
|
|| linea.getEstado() == Estado.denegado_pago) {
|
|
|
|
Presupuesto presupuesto = linea.getPresupuesto();
|
|
linea.setEstado(getEstadoInicial(presupuesto));
|
|
pedidoLineaRepository.save(linea);
|
|
|
|
// Save presupuesto in SK
|
|
Map<String, Object> result = savePresupuestoSK(linea.getId(), presupuesto, counter, total);
|
|
if (result == null) {
|
|
return false;
|
|
}
|
|
referenciasProveedor.add(result);
|
|
counter++;
|
|
}
|
|
}
|
|
|
|
if (referenciasProveedor.isEmpty()) {
|
|
return false;
|
|
}
|
|
|
|
// Save pedido in SK
|
|
ArrayList<Long> presupuestoSkIds = new ArrayList<>();
|
|
for (Map<String, Object> presData : referenciasProveedor) {
|
|
Long presId = ((Number) presData.get("id")).longValue();
|
|
presupuestoSkIds.add(presId);
|
|
}
|
|
|
|
Map<String, Object> ids = new HashMap<>();
|
|
ids.put("presupuesto_ids", presupuestoSkIds);
|
|
Long skPedidoId = skApiClient.crearPedido(ids);
|
|
if (skPedidoId == null) {
|
|
System.out.println("No se pudo crear el pedido en SK.");
|
|
return false;
|
|
}
|
|
pedido.setProveedor("Safekat");
|
|
pedido.setProveedorRef(skPedidoId.toString());
|
|
pedidoRepository.save(pedido);
|
|
return true;
|
|
}
|
|
|
|
public Map<String, Object> actualizarEstado(Long pedidoLineaId, Locale locale) {
|
|
|
|
PedidoLinea pedidoLinea = pedidoLineaRepository.findById(pedidoLineaId).orElse(null);
|
|
if (pedidoLinea == null) {
|
|
return Map.of(
|
|
"success", false,
|
|
"message", messageSource.getMessage("pedido.errors.linea-not-found", null, locale));
|
|
}
|
|
|
|
PedidoLinea.Estado estadoOld = pedidoLinea.getEstado();
|
|
if (estadoOld == null) {
|
|
return Map.of(
|
|
"success", false,
|
|
"message", messageSource.getMessage("pedido.errors.cannot-update", null, locale));
|
|
}
|
|
|
|
// Rango: >= haciendo_ferro y < enviado
|
|
if (estadoOld.getPriority() < PedidoLinea.Estado.haciendo_ferro.getPriority()
|
|
|| estadoOld.getPriority() >= PedidoLinea.Estado.enviado.getPriority()) {
|
|
return Map.of(
|
|
"success", false,
|
|
"message", messageSource.getMessage("pedido.errors.cannot-update", null, locale));
|
|
}
|
|
|
|
var presupuesto = pedidoLinea.getPresupuesto();
|
|
if (presupuesto == null || presupuesto.getProveedorRef2() == null) {
|
|
return Map.of(
|
|
"success", false,
|
|
"message", messageSource.getMessage("pedido.errors.update-server-error", null, locale));
|
|
}
|
|
|
|
Long refExterna;
|
|
try {
|
|
refExterna = Long.valueOf(presupuesto.getProveedorRef2().toString());
|
|
} catch (Exception ex) {
|
|
return Map.of(
|
|
"success", false,
|
|
"message", messageSource.getMessage("pedido.errors.update-server-error", null, locale));
|
|
}
|
|
|
|
Map<String, Object> result = skApiClient.checkPedidoEstado(refExterna, locale);
|
|
|
|
if (result == null || result.get("estado") == null) {
|
|
return Map.of(
|
|
"success", false,
|
|
"message", messageSource.getMessage("pedido.errors.update-server-error", null, locale));
|
|
}
|
|
|
|
String estadoStr = String.valueOf(result.get("estado"));
|
|
|
|
PedidoLinea.Estado estadoSk;
|
|
try {
|
|
// si la API devuelve minúsculas tipo "produccion", esto funciona
|
|
estadoSk = PedidoLinea.Estado.valueOf(estadoStr.trim().toLowerCase());
|
|
} catch (Exception ex) {
|
|
return Map.of(
|
|
"success", false,
|
|
"message", messageSource.getMessage("pedido.errors.update-server-error", null, locale));
|
|
}
|
|
|
|
if (estadoOld == estadoSk) {
|
|
return Map.of(
|
|
"success", true,
|
|
"state", messageSource.getMessage("pedido.estado." + estadoSk.name(), null, locale),
|
|
"stateKey", estadoSk.name(),
|
|
"message", messageSource.getMessage("pedido.success.same-estado", null, locale));
|
|
}
|
|
|
|
pedidoLinea.setEstado(estadoSk);
|
|
pedidoLineaRepository.save(pedidoLinea);
|
|
|
|
return Map.of(
|
|
"success", true,
|
|
"state", messageSource.getMessage("pedido.estado." + estadoSk.name(), null, locale),
|
|
"stateKey", estadoSk.name(),
|
|
"message", messageSource.getMessage("pedido.success.estado-actualizado", null, locale));
|
|
}
|
|
|
|
public Boolean markPedidoAsMaquetacionDone(Long pedidoId) {
|
|
Pedido pedido = pedidoRepository.findById(pedidoId).orElse(null);
|
|
if (pedido == null) {
|
|
return false;
|
|
}
|
|
List<PedidoLinea> lineas = pedidoLineaRepository.findByPedidoId(pedidoId);
|
|
for (PedidoLinea linea : lineas) {
|
|
if (linea.getEstado() == Estado.maquetacion) {
|
|
linea.setEstado(Estado.haciendo_ferro);
|
|
pedidoLineaRepository.save(linea);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public Map<String, Object> getFilesType(Long pedidoLineaId, Locale locale) {
|
|
PedidoLinea pedidoLinea = pedidoLineaRepository.findById(pedidoLineaId).orElse(null);
|
|
if (pedidoLinea == null) {
|
|
return Map.of("success", false, "message", "Línea de pedido no encontrada.");
|
|
}
|
|
Map<String, Object> files = skApiClient.getFilesTypes(
|
|
Long.valueOf(pedidoLinea.getPresupuesto().getProveedorRef2().toString()), locale);
|
|
return files;
|
|
}
|
|
|
|
public byte[] getFerroFileContent(Long pedidoLineaId, Locale locale) {
|
|
return downloadFile(pedidoLineaId, "ferro", locale);
|
|
}
|
|
|
|
public byte[] getCubiertaFileContent(Long pedidoLineaId, Locale locale) {
|
|
return downloadFile(pedidoLineaId, "cubierta", locale);
|
|
}
|
|
|
|
public byte[] getTapaFileContent(Long pedidoLineaId, Locale locale) {
|
|
return downloadFile(pedidoLineaId, "tapa", locale);
|
|
}
|
|
|
|
public Boolean aceptarFerro(Long pedidoLineaId, Locale locale) {
|
|
PedidoLinea pedidoLinea = pedidoLineaRepository.findById(pedidoLineaId).orElse(null);
|
|
if (pedidoLinea == null) {
|
|
return false;
|
|
}
|
|
if (pedidoLinea.getEstado() != PedidoLinea.Estado.esperando_aceptacion_ferro) {
|
|
return false;
|
|
}
|
|
Boolean result = skApiClient.aceptarFerro(
|
|
Long.valueOf(pedidoLinea.getPresupuesto().getProveedorRef2().toString()), locale);
|
|
if (!result) {
|
|
return false;
|
|
}
|
|
pedidoLinea.setEstado(PedidoLinea.Estado.produccion);
|
|
pedidoLineaRepository.save(pedidoLinea);
|
|
return true;
|
|
}
|
|
|
|
public Boolean cancelarPedido(Long pedidoId) {
|
|
|
|
Pedido pedido = pedidoRepository.findById(pedidoId).orElse(null);
|
|
if (pedido == null) {
|
|
return false;
|
|
}
|
|
Boolean result = skApiClient.cancelarPedido(Long.valueOf(pedido.getProveedorRef()));
|
|
if (!result) {
|
|
return false;
|
|
}
|
|
List<PedidoLinea> lineas = pedidoLineaRepository.findByPedidoId(pedidoId);
|
|
for (PedidoLinea linea : lineas) {
|
|
if (linea.getEstado() != PedidoLinea.Estado.terminado && linea.getEstado() != PedidoLinea.Estado.enviado) {
|
|
linea.setEstado(PedidoLinea.Estado.cancelado);
|
|
pedidoLineaRepository.save(linea);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/***************************
|
|
* MÉTODOS PRIVADOS
|
|
***************************/
|
|
|
|
private byte[] downloadFile(Long pedidoLineaId, String fileType, Locale locale) {
|
|
PedidoLinea pedidoLinea = pedidoLineaRepository.findById(pedidoLineaId).orElse(null);
|
|
if (pedidoLinea == null) {
|
|
return null;
|
|
}
|
|
byte[] fileData = skApiClient.downloadFile(
|
|
Long.valueOf(pedidoLinea.getPresupuesto().getProveedorRef2().toString()),
|
|
fileType,
|
|
locale);
|
|
return fileData;
|
|
}
|
|
|
|
@Transactional
|
|
private Map<String, Object> savePresupuestoSK(Long pedidoLineaId, Presupuesto presupuesto, Integer counter,
|
|
Integer total) {
|
|
|
|
Map<String, Object> data_to_send = presupuestoService.toSkApiRequest(presupuesto, true);
|
|
data_to_send.put("createPedido", 0);
|
|
|
|
// Recuperar el mapa anidado datosCabecera
|
|
@SuppressWarnings("unchecked")
|
|
Map<String, Object> datosCabecera = (Map<String, Object>) data_to_send.get("datosCabecera");
|
|
if (datosCabecera != null) {
|
|
Object tituloOriginal = datosCabecera.get("titulo");
|
|
datosCabecera.put(
|
|
"titulo",
|
|
"[" + (counter) + "/" + total + "] " + (tituloOriginal != null ? tituloOriginal : ""));
|
|
}
|
|
|
|
List<PedidoDireccion> direccionesPedidoLinea = pedidoDireccionRepository
|
|
.findByPedidoLineaId(pedidoLineaId);
|
|
List<Map<String, Object>> direccionesPresupuesto = new ArrayList<>();
|
|
List<Map<String, Object>> direccionEjemplarPrueba = new ArrayList<>();
|
|
|
|
for (PedidoDireccion pd : direccionesPedidoLinea) {
|
|
if (pd.isEjemplarPrueba()) {
|
|
direccionEjemplarPrueba.add(
|
|
pd.toSkMap(presupuesto.getPeso()));
|
|
} else {
|
|
direccionesPresupuesto.add(
|
|
pd.toSkMap(presupuesto.getPeso() * pd.getUnidades()));
|
|
}
|
|
|
|
}
|
|
if (presupuesto.getServiciosJson() != null && presupuesto.getServiciosJson().contains("deposito-legal")) {
|
|
direccionesPresupuesto.add(
|
|
PedidoDireccion.toSkMapDepositoLegal());
|
|
}
|
|
data_to_send.put("direcciones", direccionesPresupuesto);
|
|
if (direccionEjemplarPrueba.size() > 0)
|
|
data_to_send.put("direccionesFP1", direccionEjemplarPrueba.get(0));
|
|
else {
|
|
data_to_send.put("direccionesFP1", new ArrayList<>());
|
|
}
|
|
|
|
Map<String, Object> result = skApiClient.savePresupuesto(data_to_send);
|
|
|
|
if (result.containsKey("error")) {
|
|
System.out.println("Error al guardar presupuesto en SK");
|
|
System.out.println("-------------------------");
|
|
System.out.println(result.get("error"));
|
|
// decide si seguir con otros items o abortar:
|
|
// continue; o bien throw ...
|
|
return null;
|
|
}
|
|
|
|
Object dataObj = result.get("data");
|
|
if (!(dataObj instanceof Map<?, ?> dataRaw)) {
|
|
System.out.println("Formato inesperado de 'data' en savePresupuesto: " + result);
|
|
return null;
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
Map<String, Object> dataMap = (Map<String, Object>) dataRaw;
|
|
Long presId = ((Number) dataMap.get("id")).longValue();
|
|
String skin = ((String) dataMap.get("iskn")).toString();
|
|
presupuesto.setProveedor("Safekat");
|
|
presupuesto.setProveedorRef1(skin);
|
|
presupuesto.setProveedorRef2(presId);
|
|
presupuesto.setEstado(Presupuesto.Estado.aceptado);
|
|
presupuestoRepo.save(presupuesto);
|
|
|
|
return dataMap;
|
|
}
|
|
|
|
// Obtener las direcciones de envío asociadas a un presupuesto en el carrito
|
|
private Map<String, Object> getDireccionesPresupuesto(Cart cart, Presupuesto presupuesto) {
|
|
|
|
List<Map<String, Object>> direccionesPresupuesto = new ArrayList<>();
|
|
List<Map<String, Object>> direccionesPrueba = new ArrayList<>();
|
|
if (cart.getOnlyOneShipment()) {
|
|
List<CartDireccion> direcciones = cart.getDirecciones().stream().limit(1).toList();
|
|
if (!direcciones.isEmpty()) {
|
|
if (presupuesto.getServiciosJson() != null
|
|
&& presupuesto.getServiciosJson().contains("deposito-legal")) {
|
|
direccionesPresupuesto.add(direcciones.get(0).toSkMap(
|
|
presupuesto.getSelectedTirada(),
|
|
presupuesto.getPeso(),
|
|
direcciones.get(0).getIsPalets(),
|
|
false));
|
|
|
|
direccionesPresupuesto.add(direcciones.get(0).toSkMapDepositoLegal());
|
|
} else {
|
|
direccionesPresupuesto.add(direcciones.get(0).toSkMap(
|
|
presupuesto.getSelectedTirada(),
|
|
presupuesto.getPeso(),
|
|
direcciones.get(0).getIsPalets(),
|
|
false));
|
|
}
|
|
if (presupuesto.getServiciosJson() != null
|
|
&& presupuesto.getServiciosJson().contains("ejemplar-prueba")) {
|
|
direccionesPrueba.add(direcciones.get(0).toSkMap(
|
|
1,
|
|
presupuesto.getPeso(),
|
|
false,
|
|
true));
|
|
}
|
|
|
|
Map<String, Object> direccionesRet = new HashMap<>();
|
|
direccionesRet.put("direcciones", direccionesPresupuesto);
|
|
if (!direccionesPrueba.isEmpty())
|
|
direccionesRet.put("direccionesFP1", direccionesPrueba.get(0));
|
|
else {
|
|
direccionesRet.put("direccionesFP1", new ArrayList<>());
|
|
}
|
|
return direccionesRet;
|
|
}
|
|
} else {
|
|
List<CartDireccion> direcciones = cart.getDirecciones().stream()
|
|
.filter(d -> d.getPresupuesto() != null && d.getPresupuesto().getId().equals(presupuesto.getId()))
|
|
.toList();
|
|
|
|
for (CartDireccion cd : direcciones) {
|
|
|
|
// direccion de ejemplar de prueba
|
|
if (cd.getPresupuesto() == null || !cd.getPresupuesto().getId().equals(presupuesto.getId())) {
|
|
continue;
|
|
}
|
|
if (cd.getUnidades() == null || cd.getUnidades() <= 0) {
|
|
direccionesPrueba.add(cd.toSkMap(
|
|
1,
|
|
presupuesto.getPeso(),
|
|
false,
|
|
true));
|
|
} else {
|
|
direccionesPresupuesto.add(cd.toSkMap(
|
|
cd.getUnidades(),
|
|
presupuesto.getPeso(),
|
|
cd.getIsPalets(),
|
|
false));
|
|
}
|
|
}
|
|
if (presupuesto.getServiciosJson() != null
|
|
&& presupuesto.getServiciosJson().contains("deposito-legal")) {
|
|
CartDireccion cd = new CartDireccion();
|
|
direccionesPresupuesto.add(cd.toSkMapDepositoLegal());
|
|
}
|
|
}
|
|
Map<String, Object> direccionesRet = new HashMap<>();
|
|
direccionesRet.put("direcciones", direccionesPresupuesto);
|
|
if (!direccionesPrueba.isEmpty())
|
|
direccionesRet.put("direccionesFP1", direccionesPrueba.get(0));
|
|
else {
|
|
direccionesRet.put("direccionesFP1", new ArrayList<>());
|
|
}
|
|
return direccionesRet;
|
|
}
|
|
|
|
@Transactional
|
|
private void saveDireccionesPedidoLinea(
|
|
Map<String, Object> direcciones,
|
|
Pedido pedido,
|
|
PedidoLinea linea, Long direccionFacturacionId) {
|
|
|
|
String email = pedido.getCreatedBy().getUserName();
|
|
|
|
// direccion prueba
|
|
if (direcciones.containsKey("direccionesFP1")) {
|
|
|
|
try {
|
|
@SuppressWarnings("unchecked")
|
|
Map<String, Object> fp1 = (Map<String, Object>) direcciones.get("direccionesFP1");
|
|
@SuppressWarnings("unchecked")
|
|
PedidoDireccion direccion = saveDireccion(
|
|
email,
|
|
false,
|
|
(HashMap<String, Object>) fp1.get("direccion"),
|
|
pedido,
|
|
linea,
|
|
true,
|
|
false);
|
|
pedidoDireccionRepository.save(direccion);
|
|
} catch (Exception e) {
|
|
// Viene vacio
|
|
}
|
|
}
|
|
if (direcciones.containsKey("direcciones")) {
|
|
List<?> dirs = (List<?>) direcciones.get("direcciones");
|
|
for (Object dir : dirs) {
|
|
@SuppressWarnings("unchecked")
|
|
HashMap<String, Object> direccionEnvio = (HashMap<String, Object>) ((HashMap<String, Object>) dir)
|
|
.get("direccion");
|
|
if (direccionEnvio.get("cantidad") != null && (Integer) direccionEnvio.get("cantidad") == 4
|
|
&& direccionEnvio.get("att").toString().contains("Depósito Legal")) {
|
|
continue; // Saltar la dirección de depósito legal
|
|
}
|
|
@SuppressWarnings("unchecked")
|
|
PedidoDireccion direccion = saveDireccion(
|
|
email,
|
|
((Number) ((HashMap<String, Object>) dir)
|
|
.getOrDefault("entregaPalets", 0))
|
|
.intValue() == 1,
|
|
(HashMap<String, Object>) ((HashMap<String, Object>) dir).get("direccion"),
|
|
pedido,
|
|
linea, false,
|
|
false);
|
|
pedidoDireccionRepository.save(direccion);
|
|
}
|
|
}
|
|
if (direccionFacturacionId != null) {
|
|
Direccion dirFact = direccionService.findById(direccionFacturacionId).orElse(null);
|
|
if (dirFact != null) {
|
|
HashMap<String, Object> dirFactMap = new HashMap<>();
|
|
dirFactMap.put("att", dirFact.getAtt());
|
|
dirFactMap.put("direccion", dirFact.getDireccion());
|
|
dirFactMap.put("cp", dirFact.getCp());
|
|
dirFactMap.put("municipio", dirFact.getCiudad());
|
|
dirFactMap.put("provincia", dirFact.getProvincia());
|
|
dirFactMap.put("pais_code3", dirFact.getPaisCode3());
|
|
dirFactMap.put("telefono", dirFact.getTelefono());
|
|
dirFactMap.put("instrucciones", dirFact.getInstrucciones());
|
|
dirFactMap.put("razon_social", dirFact.getRazonSocial());
|
|
dirFactMap.put("tipo_identificacion_fiscal", dirFact.getTipoIdentificacionFiscal().name());
|
|
dirFactMap.put("identificacion_fiscal", dirFact.getIdentificacionFiscal());
|
|
|
|
PedidoDireccion direccion = saveDireccion(
|
|
email,
|
|
false,
|
|
dirFactMap,
|
|
pedido,
|
|
linea,
|
|
false,
|
|
true);
|
|
pedidoDireccionRepository.save(direccion);
|
|
}
|
|
}
|
|
}
|
|
|
|
private PedidoDireccion saveDireccion(
|
|
String email,
|
|
Boolean palets,
|
|
HashMap<String, Object> dir,
|
|
Pedido pedido,
|
|
PedidoLinea linea,
|
|
Boolean isEjemplarPrueba,
|
|
Boolean isFacturacion) {
|
|
|
|
PedidoDireccion direccion = new PedidoDireccion();
|
|
direccion.setEmail(email);
|
|
direccion.setPalets(isEjemplarPrueba || isFacturacion ? false : palets);
|
|
direccion.setPedidoLinea(isFacturacion ? null : linea);
|
|
if (isFacturacion) {
|
|
direccion.setUnidades(null);
|
|
direccion.setFacturacion(true);
|
|
direccion.setPedido(pedido);
|
|
|
|
} else {
|
|
if (isEjemplarPrueba) {
|
|
direccion.setUnidades(1);
|
|
direccion.setEjemplarPrueba(true);
|
|
} else {
|
|
direccion.setUnidades((Integer) dir.getOrDefault("cantidad", 1));
|
|
direccion.setEjemplarPrueba(false);
|
|
}
|
|
direccion.setFacturacion(false);
|
|
}
|
|
|
|
direccion.setAtt((String) dir.getOrDefault("att", ""));
|
|
direccion.setDireccion((String) dir.getOrDefault("direccion", ""));
|
|
direccion.setCp((Integer) dir.getOrDefault("cp", 0));
|
|
direccion.setCiudad((String) dir.getOrDefault("municipio", ""));
|
|
direccion.setProvincia((String) dir.getOrDefault("provincia", ""));
|
|
direccion.setPaisCode3((String) dir.getOrDefault("pais_code3", "esp"));
|
|
direccion.setTelefono((String) dir.getOrDefault("telefono", ""));
|
|
direccion.setInstrucciones((String) dir.getOrDefault("instrucciones", ""));
|
|
direccion.setRazonSocial((String) dir.getOrDefault("razon_social", ""));
|
|
direccion.setTipoIdentificacionFiscal(Direccion.TipoIdentificacionFiscal
|
|
.valueOf((String) dir.getOrDefault("tipo_identificacion_fiscal",
|
|
Direccion.TipoIdentificacionFiscal.DNI.name())));
|
|
direccion.setIdentificacionFiscal((String) dir.getOrDefault("identificacion_fiscal", ""));
|
|
|
|
return direccion;
|
|
|
|
}
|
|
|
|
private Estado getEstadoInicial(Presupuesto p) {
|
|
|
|
if (presupuestoService.hasMaquetacion(p)) {
|
|
return Estado.maquetacion;
|
|
} else {
|
|
return Estado.haciendo_ferro;
|
|
}
|
|
}
|
|
|
|
}
|