/*
 * 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.arrebol.taxiservicios.beans.predio;

import com.arrebol.taxiservicios.beans.admin.client.*;
import com.arrebol.taxiservicios.beans.TaxiGenericBean;
import com.arrebol.taxiservicios.controller.catalog.DocumentoController;
import com.arrebol.taxiservicios.controller.catalog.LocationController;
import com.arrebol.taxiservicios.controller.catalog.PaquetesController;
import com.arrebol.taxiservicios.controller.predio.BucketController;
import com.arrebol.taxiservicios.controller.predio.LoteController;
import com.arrebol.taxiservicios.controller.predio.PredioController;
import com.arrebol.taxiservicios.controller.predio.PreventaController;
import com.arrebol.taxiservicios.controller.predio.PropietarioPredioController;
import com.arrebol.taxiservicios.controller.predio.UrbanizacionController;
import com.arrebol.taxiservicios.model.admin.Service;
import com.arrebol.taxiservicios.model.catalog.Documento;
import com.arrebol.taxiservicios.model.catalog.Location;
import com.arrebol.taxiservicios.model.catalog.LocationPaquetes;
import com.arrebol.taxiservicios.model.core.Address;
import com.arrebol.taxiservicios.model.core.ContactNumber;
import com.arrebol.taxiservicios.model.core.Person;
import com.arrebol.taxiservicios.model.core.PersonCommercialInvoice;
import com.arrebol.taxiservicios.model.core.User;
import com.arrebol.taxiservicios.model.enums.AddressType;
import com.arrebol.taxiservicios.model.enums.CompromisoPago;
import com.arrebol.taxiservicios.model.enums.EstatusLote;
import com.arrebol.taxiservicios.model.enums.GenericEnumType;
import com.arrebol.taxiservicios.model.enums.PeriodoPago;
import com.arrebol.taxiservicios.model.enums.TipoAbono;
import com.arrebol.taxiservicios.model.enums.TipoProyecto;
import com.arrebol.taxiservicios.model.predio.AbonoProyecto;
import com.arrebol.taxiservicios.model.predio.Lote;
import com.arrebol.taxiservicios.model.predio.Manzana;
import com.arrebol.taxiservicios.model.predio.Predio;
import com.arrebol.taxiservicios.model.predio.PropietarioPredio;
import com.arrebol.taxiservicios.model.predio.Urbanizacion;
import com.arrebol.taxiservicios.model.predio.proyectosLotesView;
import com.itextpdf.text.Document;
import com.itextpdf.text.DocumentException;
import com.itextpdf.text.Paragraph;
import com.itextpdf.text.pdf.PdfWriter;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Serializable;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.UUID;
import javax.annotation.PostConstruct;
import javax.faces.application.FacesMessage;
import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;
import javax.faces.view.ViewScoped;
import javax.inject.Named;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.primefaces.event.FileUploadEvent;
import org.primefaces.event.RowEditEvent;
import org.primefaces.model.DualListModel;
import org.primefaces.model.UploadedFile;

/**
 *
 * @author Picasso
 */
@Named("predioDetalleBean")
@ViewScoped
public class PredioDetalleBean extends TaxiGenericBean implements Serializable {

    /**
     * Save/Update an customer in the system.
     */
    public void addCustomer() {
        logger.info("addCustomer");
        String mensajeAgregado = "";

        if (isValidadorComentario() == true) {
            getNuevoPropietarioPredio().setComentario(getComentario());
            getNuevoPropietarioPredio().setPredio(getPredio());
            getNuevoPropietarioPredio().setPropetiarioNuevo(new Person(getPropietarioId()));
            getNuevoPropietarioPredio().setPropetiarioViejo(new Person(getAntiguoPropietario().getId()));
            getPredio().setLastUpdatedBy(getLoggedUser());
            getPredio().setLastUpdatedOn(new Date());
            try {
                getPropietarioPredioController().addPropietarioPredio(getNuevoPropietarioPredio(), getLoggedUser());
                setListaPropietarioPredio(getPropietarioPredioController().fillPropietarioPredio());
                mensajeAgregado = "-Propietario cambiado";
            } catch (Exception e) {
                showMessage(FacesMessage.SEVERITY_ERROR,
                        "Cambio de propietario",
                        "Fallo en la insercion de datos");
                return;
            }

        }

        try {

            getPredio().setPropetiario(new Person(getPropietarioId()));
            if (getCompromisoPago().equals("MENSUAL")) {
                getPredio().setCompromisoPago(CompromisoPago.MENSUAL);
            } else if (getCompromisoPago().equals("ANUAL")) {
                getPredio().setCompromisoPago(CompromisoPago.ANUAL);
            } else if (getCompromisoPago().equals("TRIMESTRAL")) {
                getPredio().setCompromisoPago(CompromisoPago.TRIMESTRAL);
            }
            
            switch (getTipoProyecto()) {
                    case "Lotes":
                        getPredio().setTipoProyecto(TipoProyecto.LOTE);
                        break;
                    case "Viviendas":
                        getPredio().setTipoProyecto(TipoProyecto.VIVIENDA);
                        break;
                    case "Departamentos":
                        getPredio().setTipoProyecto(TipoProyecto.DEPARTAMENTO);
                        break;
                    case "Oficinas":
                        getPredio().setTipoProyecto(TipoProyecto.OFICINA);
                        break;    
                    default:
                        break;
                }

            getPredio().setLastUpdatedOn(new Date());

            boolean success = getPredioController().addPredio(getPredio(), getLoggedUser(), false);

            if (success) {
                setAddCustomerBtnOnclick(true);
                showMessage(FacesMessage.SEVERITY_INFO,
                        "Predio",
                        "Se agrego de manera correcta." + mensajeAgregado);
                setComentario("");
                setValidadorComentario(false);

            } else {
                logger.error("Employee " + getPredio() + " was not " + (isAddCustomerBtnOnclick() ? "updated" : "saved"));
                showMessage(FacesMessage.SEVERITY_ERROR,
                        getBundlePropertyFile().getString("customer.add.title"),
                        getBundlePropertyFile().getString("customer.add.fail.desc"));
            }
        } catch (Exception e) {
            logger.error("addEmployee: " + e);
            showMessage(FacesMessage.SEVERITY_FATAL,
                    getBundlePropertyFile().getString("customer.add.title"),
                    getBundlePropertyFile().getString("customer.add.exception.desc"));
        }
    }

    public void validarDescripcion() {
        if (getAntiguoPropietario().getId().equals(getPropietarioId())) {
            setValidadorComentario(false);
        } else {

            setValidadorComentario(true);
        }
    }

    public void updateLote() {
        logger.info("updateLote");        
        try {
            // Validación del paquete 
            setPaquetesController(new PaquetesController());
            setLoteController(new LoteController());
            List<LocationPaquetes> Lpack = getPaquetesController().fillAllLocationPaquetesByLocationAndEstatusActivo(getLoggedUser().getLocation(), GenericEnumType.ENABLED);      
            // Se carga la cantidad de lotes existentes 
            Long lotesExistentes =  getLoteController().contarLotesByLocation(getLoggedUser().getLocation());
            Integer difLotes = Lpack.get(0).getPaquete().getNumeroLotes()-lotesExistentes.intValue();
            // se valida el numero de lotes 
            if (lotesExistentes<Lpack.get(0).getPaquete().getNumeroLotes()) {
                if (selectedLote.getId() == null) {
                    addNewLote();
                    setLostes(getPreventaController().fillAllLotes(getSelectedLote().getManzana()));
                } else {
                    getSelectedLote().setLastUpdatedOn(new Date());
                    getPredioController().addLote(getSelectedLote(), getLoggedUser(), false);
                    showMessage(FacesMessage.SEVERITY_INFO, "Lote",
                            "Lote actualizado Correctamente");
                    setLostes(getPreventaController().fillAllLotes(getSelectedLote().getManzana()));
                }
                setSelectedLote(null);
            }else{
                 if(difLotes<0){
                    showMessage(FacesMessage.SEVERITY_ERROR, "Error", "No puede insertar más lotes deacuerdo al paquete asociado a la locación actual.");
                }else{
                    showMessage(FacesMessage.SEVERITY_ERROR, "Error", "Solo puede insertar "+difLotes+" lotes más deacuerdo al paquete asociado a la locación actual.");
                }  
            }            
        } catch (Exception e) {

        }
    }

    public void resetselectedLote() {
        setSelectedLote(new Lote());
    }

    public void agregarUrbanizacion() {
        if (getNuevaUrbanizacion().getId() != null) {
            getUrbanizacionController().addUrbanizacion(getNuevaUrbanizacion(), usuarioLogeado);
            showMessage(FacesMessage.SEVERITY_INFO, "Obras y Reparaciones",
                    "Obra o Reparacion fue actualizada Correctamente");
        } else {
            getNuevaUrbanizacion().setPredio(getPredio());
            getNuevaUrbanizacion().setActivo(GenericEnumType.ENABLED);
            getUrbanizacionController().addUrbanizacion(getNuevaUrbanizacion(), usuarioLogeado);
            getListaUrbanizacion().add(getNuevaUrbanizacion());
            setNuevaUrbanizacion(new Urbanizacion());
            showMessage(FacesMessage.SEVERITY_INFO, "Obras y Reparaciones",
                    "Obra o Reparacion fue agregada Correctamente");
        }
    }

    public void updateManzanas() {

        setManzana(getPreventaController().fillAllManzanas(getPredio()));

        Collections.reverse(getManzana());
        try {
            setSelectedManzana(getManzana().get(0));
            setLotesVendidosApartados(getPredioController().contarLotesVendidosApartados(getSelectedManzana()));
            setLostes(getPreventaController().fillAllLotes(getManzana().get(0)));

        } catch (Exception e) {
            setSelectedManzana(null);
            setLotesVendidosApartados(false);
            setLostes(null);

        }

    }

    public void onChange() {
        if (getPeriodoPago().equals("PERSONALIZADO")) {
            setPerosonalizado(true);
            setMensual(false);
            setQuincenal(false);
        } else if (getPeriodoPago().equals("MENSUAL")) {
            setPerosonalizado(false);
            setMensual(true);
            setQuincenal(false);
        } else if (getPeriodoPago().equals("QUINCENAL")) {
            setPerosonalizado(false);
            setMensual(false);
            setQuincenal(true);
        }
    }

    public void subirCroquis() throws IOException {
        try {
            if (file != null) {
                try {
                    String extencion = file.getFileName();
                    String[] subString = extencion.split("\\.", 2);

                    String fileName = "croquis." + subString[1];
                    InputStream inputStream = file.getInputstream();
                    OutputStream outputStream = new FileOutputStream(fileName);

                    int bytesRead;
                    byte[] buffer = new byte[8192];

                    while ((bytesRead = inputStream.read(buffer, 0, 8192)) != -1) {
                        outputStream.write(buffer, 0, bytesRead);
                    }

                    outputStream.flush();
                    outputStream.close();
                    inputStream.close();
                    File xmlSubir = new File(fileName);
                    subirCroquisBucket(xmlSubir);
                    if (xmlSubir.exists()) {
                        boolean eliminado = xmlSubir.delete();
                        if (eliminado) {
                            System.out.println("Archivo eliminado correctamente");
                        } else {
                            System.out.println("No se ha podido eliminar el archivo");
                        }
                    } else {
                        System.out.println("El archivo no existe");
                    }

                    String link = getBundleTaxiFile().getString("outcome.predio.detalle") + ".jsf?customerForm:predioDtTbl_selection=" + getPredioId() + "&msg=2";
                    redireccionar(link);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        } catch (Exception e) {
            String link2 = getBundleTaxiFile().getString("outcome.predio.detalle") + ".jsf?customerForm:predioDtTbl_selection=" + getPredioId() + "&msg=3";
            redireccionar(link2);
        }
    }

    public void subirCroquisBucket(File documento) throws IOException {
        try {
            File nada = getControladorBucket().utilizarBucket(getBundlePropertyFile().getString("aws.access.key"), getBundlePropertyFile().getString("aws.secret.access.key"), getBundlePropertyFile().getString("aws.region"), getBundlePropertyFile().getString("aws.bucket"), getPredio(), 0, documento, null);
            Documento documentoSubir = new Documento();
            documentoSubir.setDescripcion("croquis del predio " + getPredio().getNombreProyecto());
            documentoSubir.setNombre(documento.getName());
            documentoSubir.setPredio(getPredio());
            getControladorDocumento().addDocumento(documentoSubir, getLoggedUser());
            getPredio().setCroquis(getPredioId() + "-" + documento.getName());
            getPredioController().addPredio(getPredio(), getLoggedUser(), false);
        } catch (Exception e) {
            String link2 = getBundleTaxiFile().getString("outcome.predio.detalle") + ".jsf?customerForm:predioDtTbl_selection=" + getPredioId() + "&msg=3";
            redireccionar(link2);
        }
    }

    public void addAbonoProyecto() {
        logger.info("addManzana");

        AbonoProyecto abonoProyecto = new AbonoProyecto();

        abonoProyecto.setId(UUID.randomUUID().toString());
        getAbonosProyecto().add(abonoProyecto);

    }

    public void deleteUrbanizacion() {
        getNuevaUrbanizacion().setActivo(GenericEnumType.DISABLED);
        try {
            getUrbanizacionController().disabledUrbanizacion(getNuevaUrbanizacion(), usuarioLogeado);
            showMessage(FacesMessage.SEVERITY_WARN, "Obras y Reparaciones",
                    "La Obra o Reparacion fue borrada de manera correcta.");
            setListaUrbanizacion(getUrbanizacionController().fillAllUrbanizacionesByPredio(getPredio()));
        } catch (Exception e) {
            showMessage(FacesMessage.SEVERITY_WARN, "Obras y Reparaciones",
                    "La Obra o Reparacion fue no se pudo borrar.");
        }
    }

    public void editRowAbono(RowEditEvent event) {
        try {
            AbonoProyecto p = (AbonoProyecto) event.getObject();

            getAbonosProyecto().forEach((AbonoProyecto Temp) -> {
                if (p.getId().equals(Temp.getId())) {
                    Temp.setPago(p.getPago());
                    Temp.setFechaAPagar(p.getFechaAPagar());

                }
            });

            setAdeudo(getPredio().getCosto() - getPredio().getAnticipo() - calculateAbono());

        } catch (Exception e) {
            logger.error("editRow: " + e);
            showMessage(FacesMessage.SEVERITY_FATAL, "Compras",
                    "Error al editar el producto");
        }

    }

    public void deleteSelectedProduct() {
        logger.info("deleteSelectedProduct");
        try {
            getAbonosProyecto().remove(getSelectedAbonoProyecto());

            setAdeudo(getPredio().getCosto() - getPredio().getAnticipo() - calculateAbono());

        } catch (Exception e) {
            logger.error("deleteSelectedProduct", e);
            showMessage(FacesMessage.SEVERITY_FATAL,
                    getBundlePropertyFile().getString("garage.title"),
                    getBundlePropertyFile().getString("fatal.access.details"));
        }
    }

    public Double calculateAbono() {
        Double totalAbonos = 0D;

        if (!getAbonosProyecto().isEmpty()) {
            totalAbonos = getAbonosProyecto()
                    .stream()
                    .map(row -> row.getPago())
                    .reduce(totalAbonos, (accumulator, _item) -> accumulator + _item);
        }

        return totalAbonos;

    }

    public void saveAbonoProyecto() {

        if (getAdeudo() > 0) {

            showMessage(FacesMessage.SEVERITY_WARN, "Pagos",
                    "El adeudo por pagos personalizados debe de ser 0");
            return;

        }
        setAnterior(getPredio().getCosto() - getPredio().getAnticipo());

        Collections.sort(getAbonosProyecto());

        getAbonosProyecto().forEach((AbonoProyecto temp) -> {

            Calendar fechaInicial = Calendar.getInstance();
            fechaInicial.setTime(temp.getFechaAPagar());
            fechaInicial.add(Calendar.DATE, 1);

            temp.setFechaAPagar(fechaInicial.getTime());

            temp.setSaldoAnterior(getAnterior());
            temp.setSaldoNuevo(getAnterior() - temp.getPago());
            temp.setTipoAbono(TipoAbono.ABONO);
            temp.setEstatusActivo(GenericEnumType.ENABLED);
            temp.setPagoEstatus(GenericEnumType.DISABLED);
            temp.setPredio(getPredio());

            getPredioController().addAbonoProyecto(temp, getLoggedUser(), true);

            setAnterior(getAnterior() - temp.getPago());

        });

        setPerosonalizado(false);
        setMensual(false);
        setQuincenal(false);
        setAbonosProyecto(new ArrayList<>());
        setAdeudo(getPredio().getCosto() - getPredio().getAnticipo());

        showMessage(FacesMessage.SEVERITY_INFO, "Pagos",
                "Pagos creados Correctamente");

    }

    public void saveAbonoProyectoMensual() {

        //Definición de la fecha de inicio y numero de pagos
        Calendar fechaInicial = Calendar.getInstance();
        fechaInicial.setTime(getDiaAPagar());
        fechaInicial.add(Calendar.DATE, 1);

        int numeroPagos = getPlazoMeses();
        //lista de fechas de pago
        List<Calendar> fechasDePago = new ArrayList<>();
        // Cargado de las fechas de pago por MES

        fechasDePago.add(fechaInicial);
        Calendar fechaActual = (Calendar) fechaInicial.clone();
        //captura el dia de una fecha en caso de que no se encuntre en le mes siguinte 
        boolean detenerFecha = false;
        Calendar fechaDetenida = Calendar.getInstance();
        for (int i = 1; i < numeroPagos; i++) {
            Calendar fechaSiguiente = (Calendar) fechaActual.clone();
            fechaSiguiente.add(Calendar.MONTH, 1);
            if (detenerFecha == false) {
                if (fechaActual.get(Calendar.DAY_OF_MONTH) > fechaSiguiente.getActualMaximum(Calendar.DAY_OF_MONTH)) {
                    detenerFecha = true;
                    fechaDetenida = (Calendar) fechaActual.clone();
                    fechaSiguiente.set(Calendar.DAY_OF_MONTH, fechaSiguiente.getActualMaximum(Calendar.DAY_OF_MONTH));
                }
            } else {
                if (fechaSiguiente.get(Calendar.DAY_OF_MONTH) <= fechaDetenida.get(Calendar.DAY_OF_MONTH)) {
                    detenerFecha = false;
                    fechaSiguiente.set(Calendar.DAY_OF_MONTH, fechaDetenida.get(Calendar.DAY_OF_MONTH));
                } else {
                    fechaSiguiente.set(Calendar.DAY_OF_MONTH, fechaSiguiente.getActualMaximum(Calendar.DAY_OF_MONTH));
                }
            }
            fechasDePago.add(fechaSiguiente);
            fechaActual = fechaSiguiente;
        }

        // Definision de la cantidad a pagar
        Double pagoPorMes = (getPredio().getCosto() - getPredio().getAnticipo()) / getPlazoMeses();
        Double anteriorMensual = getPredio().getCosto() - getPredio().getAnticipo();
        // Creación de pagos por fecha
        for (Calendar fecha : fechasDePago) {
            logger.info("Nuevo abono para el dia: (" + fecha + ")");
            try {

                AbonoProyecto abono = new AbonoProyecto();
                abono.setPredio(getPredio());
                abono.setTipoAbono(TipoAbono.ABONO);
                abono.setEstatusActivo(GenericEnumType.ENABLED);
                abono.setPagoEstatus(GenericEnumType.DISABLED);
                abono.setFechaAPagar(fecha.getTime());
                abono.setPago(pagoPorMes);
                abono.setSaldoAnterior(anteriorMensual);
                abono.setSaldoNuevo(anteriorMensual - pagoPorMes);
                anteriorMensual = anteriorMensual - pagoPorMes;
                getPredioController().addAbonoProyecto(abono, getLoggedUser(), true);
            } catch (Exception e) {
                logger.error("Error al capturar el abono del dia: (" + fecha + ") " + e);
                showMessage(FacesMessage.SEVERITY_FATAL, "Error", "Error al capturar el abono del dia (" + fecha + ")");
            }
        }

        setPerosonalizado(false);
        setMensual(false);
        setQuincenal(false);
        setPagos(getPredioController().contarAbonos(getPredio()));
        setAbonosProyectoCreados(getPredioController().fillAllAbonoProyecto(getPredio()));
        showMessage(FacesMessage.SEVERITY_INFO, "Pagos",
                "Pagos creados Correctamente");

    }

    public void addManzana() {
        logger.info("addManzana");

        Manzana manzanaNueva = new Manzana();

        manzanaNueva.setId(UUID.randomUUID().toString());
        getNewManzana().add(manzanaNueva);

    }

    public void editRowManzana(RowEditEvent event) {
        try {
            Manzana p = (Manzana) event.getObject();

            getManzana().forEach((Manzana manzanaTemp) -> {
                if (p.getId().equals(manzanaTemp.getId())) {
                    manzanaTemp.setNombre(p.getNombre());
                    manzanaTemp.setNumLotes(p.getNumLotes());

                }
            });

        } catch (Exception e) {
            logger.error("editRow: " + e);
            showMessage(FacesMessage.SEVERITY_FATAL, "Compras",
                    "Error al editar el producto");
        }

    }

    public void deleteSelectedManzana() {
        logger.info("deleteSelectedProduct");
        try {
            getNewManzana().remove(getSelectedManzana());

        } catch (Exception e) {
            logger.error("deleteSelectedProduct", e);
            showMessage(FacesMessage.SEVERITY_FATAL,
                    getBundlePropertyFile().getString("garage.title"),
                    getBundlePropertyFile().getString("fatal.access.details"));
        }
    }

    public void addNewManzana() {
        logger.info("addNewManzana");        
        // Validación del paquete 
        setPaquetesController(new PaquetesController());
        setLoteController(new LoteController());
        List<LocationPaquetes> Lpack = getPaquetesController().fillAllLocationPaquetesByLocationAndEstatusActivo(getLoggedUser().getLocation(), GenericEnumType.ENABLED);  
        
        if(!getNewManzana().isEmpty()){
            // Se cuentan el número de lotes que se pretende insertar
            setNumLotes(0);
            getNewManzana().forEach((Manzana manzanaTemp) -> {
                for (int i = 0; i < manzanaTemp.getNumLotes(); i++) {
                    setNumLotes(getNumLotes() + 1);
                }
            });
            // Se carga la cantidad de lotes existentes 
            Long lotesExistentes =  getLoteController().contarLotesByLocation(getLoggedUser().getLocation());
            // Lotes totales 
            Integer lotesTotales = lotesExistentes.intValue()+getNumLotes();
            Integer difLotes = Lpack.get(0).getPaquete().getNumeroLotes()-lotesExistentes.intValue();
            // se valida el numero de lotes 
            if (lotesTotales<=Lpack.get(0).getPaquete().getNumeroLotes()) {
                getNewManzana().forEach((Manzana manzanaTemp) -> {
                    manzanaTemp.setCreatedBy(getLoggedUser());
                    manzanaTemp.setPredio(getPredio());
                    boolean successManzana = getPredioController().addManzana(manzanaTemp, getLoggedUser(), true);
                    if (successManzana) {
                        for (int i = 0; i < manzanaTemp.getNumLotes(); i++) {
                            Lote lote = new Lote();
                            lote.setId(UUID.randomUUID().toString());
                            lote.setManzana(manzanaTemp);
                            lote.setEstatusLote(EstatusLote.DISPONIBLE);
                            lote.setPeriodoPago(PeriodoPago.MENSUAL);
                            boolean succesLote = getPredioController().addLote(lote, getLoggedUser(), true);
                        }
                    }
                });
                updateManzanas();
                setNewManzana(new ArrayList<>());
                showMessage(FacesMessage.SEVERITY_INFO, "Manzana","Nueva manzana agregada correctamente");            
            }else{
                 if(difLotes<0){
                    showMessage(FacesMessage.SEVERITY_ERROR, "Error", "No puede insertar más lotes deacuerdo al paquete asociado a la locación actual.");
                }else{
                    showMessage(FacesMessage.SEVERITY_ERROR, "Error", "Solo puede insertar "+difLotes+" lotes más deacuerdo al paquete asociado a la locación actual.");
                }  
            }   
        }else{
            showMessage(FacesMessage.SEVERITY_WARN, "Advertencia", "No agrego ninguna manzana a crear.");
        }
        
    }

    public void addNewLote() {

        logger.info("addNewLote");

        Lote lote = getSelectedLote();

        lote.setId(UUID.randomUUID().toString());
        lote.setManzana(getSelectedManzana());
        lote.setEstatusLote(EstatusLote.DISPONIBLE);
        lote.setPeriodoPago(PeriodoPago.MENSUAL);

        boolean succesLote = getPredioController().addLote(lote, getLoggedUser(), true);

        if (succesLote) {

            showMessage(FacesMessage.SEVERITY_INFO, "Lote",
                    "Nueva lote agregada correctamente");
        } else {
            showMessage(FacesMessage.SEVERITY_ERROR, "Lote",
                    "No se pudo agregar el lote nuevo");

        }

    }

    public void deleteSelectedLote() {

        logger.info("updateLote");

        try {

            getSelectedLote().setLastUpdatedOn(new Date());
            getSelectedLote().setEstatusActivo(GenericEnumType.DISABLED);
            getPredioController().addLote(getSelectedLote(), getLoggedUser(), false);
            getPredioController().deleteAbonosLoteByLote(selectedLote, getLoggedUser());
            showMessage(FacesMessage.SEVERITY_INFO, "Lote",
                    "Lote eliminado Correctamente");
            setLostes(getPreventaController().fillAllLotes(getSelectedLote().getManzana()));
            setLotesVendidosApartados(getPredioController().contarLotesVendidosApartados(getSelectedManzana()));

            setSelectedLote(null);

        } catch (Exception e) {

        }

    }

    public void handleFileUpload() throws IOException {
        try {
            if (file != null) {
                try {
                    if((getNombreDocumento()!=null && !getNombreDocumento().isEmpty()) && (getDescripcionDocumento()!=null && !getDescripcionDocumento().isEmpty())){
                        String extencion = file.getFileName();
                        String[] subString = extencion.split("\\.", 2);

                        String fileName = getNombreDocumento() + "." + subString[1];
                        InputStream inputStream = file.getInputstream();
                        OutputStream outputStream = new FileOutputStream(fileName);

                        int bytesRead;
                        byte[] buffer = new byte[8192];

                        while ((bytesRead = inputStream.read(buffer, 0, 8192)) != -1) {
                            outputStream.write(buffer, 0, bytesRead);
                        }

                        outputStream.flush();
                        outputStream.close();
                        inputStream.close();
                        File xmlSubir = new File(fileName);
                        subirDocumentoBucket(xmlSubir);
                        if (xmlSubir.exists()) {
                            boolean eliminado = xmlSubir.delete();
                            if (eliminado) {
                                System.out.println("Archivo eliminado correctamente");
                            } else {
                                System.out.println("No se ha podido eliminar el archivo");
                            }
                        } else {
                            System.out.println("El archivo no existe");
                        }

                        String link = getBundleTaxiFile().getString("outcome.predio.detalle") + ".jsf?customerForm:predioDtTbl_selection=" + getPredioId() + "&msg=2";
                        redireccionar(link);
                    }else{
                        showMessage(FacesMessage.SEVERITY_ERROR,"Error","Debe de colocar el nombre del archivo y su descripción para subir el documento");
                    }                   
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        } catch (Exception e) {
            String link2 = getBundleTaxiFile().getString("outcome.predio.detalle") + ".jsf?customerForm:predioDtTbl_selection=" + getPredioId() + "&msg=3";
            redireccionar(link2);
        }
    }

    public void subirDocumentoBucket(File documento) throws IOException {
        try {
            File nada = getControladorBucket().utilizarBucket(getBundlePropertyFile().getString("aws.access.key"), getBundlePropertyFile().getString("aws.secret.access.key"), getBundlePropertyFile().getString("aws.region"), getBundlePropertyFile().getString("aws.bucket"), getPredio(), 0, documento, null);
            Documento documentoSubir = new Documento();
            documentoSubir.setDescripcion(getDescripcionDocumento());
            documentoSubir.setNombre(documento.getName());
            documentoSubir.setPredio(getPredio());
            getControladorDocumento().addDocumento(documentoSubir, getLoggedUser());

        } catch (Exception e) {
            String link2 = getBundleTaxiFile().getString("outcome.predio.detalle") + ".jsf?customerForm:predioDtTbl_selection=" + getPredioId() + "&msg=3";
            redireccionar(link2);
        }
    }

    public void descargarDocumento() throws IOException {
        String nombreDocumentoNuevo = getSelectDocumento().getPredio().getId() + "-" + getSelectDocumento().getNombre();
        File documento = getControladorBucket().utilizarBucket(getBundlePropertyFile().getString("aws.access.key"), getBundlePropertyFile().getString("aws.secret.access.key"), getBundlePropertyFile().getString("aws.region"), getBundlePropertyFile().getString("aws.bucket"), getPredio(), 1, null, nombreDocumentoNuevo);
        String[] formato = nombreDocumentoNuevo.split("\\.", 2);
        //Validadores del tipo de documento
        if (formato[1].equals("pdf")) {
            FacesContext context = FacesContext.getCurrentInstance();
            Object response = context.getExternalContext().getResponse();

            if (response instanceof HttpServletResponse) {
                HttpServletResponse hrs = (HttpServletResponse) response;
                hrs.setContentType("application/pdf");
                hrs.addHeader("Content-Disposition", "attachment; filename=" + nombreDocumentoNuevo);

                try ( OutputStream outStream = hrs.getOutputStream();  FileInputStream fileInputStream = new FileInputStream(documento)) {
                    byte[] buffer = new byte[4096];
                    int bytesRead;
                    while ((bytesRead = fileInputStream.read(buffer)) != -1) {
                        outStream.write(buffer, 0, bytesRead);
                    }
                    outStream.flush();
                    context.responseComplete();
                    if (documento.exists()) {
                        boolean eliminado = documento.delete();
                        if (eliminado) {
                            System.out.println("Archivo eliminado correctamente");
                        } else {
                            System.out.println("No se ha podido eliminar el archivo");
                        }
                    } else {
                        System.out.println("El archivo no existe");
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        } else if (formato[1].equals("png") || formato[1].equals("jpeg") || formato[1].equals("jpg")) {
            FacesContext context = FacesContext.getCurrentInstance();
            Object response = context.getExternalContext().getResponse();

            if (response instanceof HttpServletResponse) {
                HttpServletResponse hrs = (HttpServletResponse) response;
                hrs.setContentType("image/" + formato[1]); // Reemplaza con el tipo de contenido de tu imagen, por ejemplo, "image/png" para imágenes PNG
                hrs.addHeader("Content-Disposition", "attachment; filename=" + nombreDocumentoNuevo);

                try ( OutputStream outStream = hrs.getOutputStream();  FileInputStream fileInputStream = new FileInputStream(documento)) {
                    byte[] buffer = new byte[4096];
                    int bytesRead;
                    while ((bytesRead = fileInputStream.read(buffer)) != -1) {
                        outStream.write(buffer, 0, bytesRead);
                    }
                    outStream.flush();
                    context.responseComplete();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public void redireccionar(String link) throws IOException {
        ExternalContext externalContext = FacesContext.getCurrentInstance().getExternalContext();
        //Nota: en local es necesario así:externalContext.redirect("/crovinmobiliaria" + link);
        //en product:externalContext.redirect(link);

        externalContext.redirect(link);
    }

    public void deleteSelectedManzanaEstatus() {

        logger.info("updateLote");

        try {
            getSelectedManzana().setLastUpdatedOn(new Date());
            getSelectedManzana().setEstatusActivo(GenericEnumType.DISABLED);
            getPredioController().addManzana(getSelectedManzana(), getLoggedUser(), false);
            getPredioController().deleteLoteByManzana(selectedManzana, getLoggedUser());
            getPredioController().deleteAbonoLoteByManzana(selectedManzana, getLoggedUser());
            showMessage(FacesMessage.SEVERITY_INFO, "Manzana",
                    "Manzana eliminada Correctamente");
            updateManzanas();

            setSelectedLote(null);
            setSelectedManzana(null);

        } catch (Exception e) {

        }

    }
    
    public Double getTotalUrbanizacion(String idUrbanizacion){
    
        return getPredioController().getTotalUrbanizacion(idUrbanizacion);
    }

    /**
     * Add RFC, Email, CURP, and Local/Mobile phones to customer.
     */
    private static final long serialVersionUID = -4594340936069728620L;

    final Logger logger = LogManager.getLogger(CustomerAddBean.class
    );

    private PredioController predioController;
    private UploadedFile file;
    private String descripcionDocumento;
    private PreventaController preventaController;
    private List<Urbanizacion> listaUrbanizacion;
    private UrbanizacionController urbanizacionController;
    private Predio predio;
    private String validador = "1";
    private PropietarioPredio nuevoPropietarioPredio;
    private PropietarioPredioController propietarioPredioController;
    private List<ContactNumber> contactNumbers;
    private Documento selectDocumento;
    private Address address;
    private PersonCommercialInvoice customerCommercialInvoice;
    private User usuarioLogeado = getLoggedUser();

    private List<Manzana> manzana;
    private List<Manzana> newManzana;
    private Manzana selectedManzana;
    List<Lote> lostes;
    List<AbonoProyecto> abonosProyecto;
    List<AbonoProyecto> abonosProyectoCreados;
    AbonoProyecto selectedAbonoProyecto;
    Lote selectedLote;
    private boolean addCustomerBtnOnclick;

    private Date sixteenYearsOld;
    private DualListModel<Service> services;

    private LocationController locationController;

    private String locationId;

    private List<Location> locations;
    private List<PropietarioPredio> listaPropietarioPredio;
    private String predioId;
    private String propietarioId;
    private String nombreDocumento;
    private String compromisoPago;
    private Person propietarioProyecto;
    private String comentario;
    private Person antiguoPropietario;
    private boolean validadorComentario;

    private String activeTap;

    private String periodoPago;
    private Urbanizacion nuevaUrbanizacion;

    private boolean perosonalizado;
    private boolean mensual;
    private boolean quincenal;

    private Double adeudo;
    private Double anterior;

    private Date diaAPagar;
    private BucketController controladorBucket;
    private DocumentoController controladorDocumento;
    private int plazoMeses;

    boolean pagos;
    boolean lotesVendidosApartados;
    
    private Boolean limiteProyectos;
    private Integer numLotes;
    private LoteController loteController;
    private PaquetesController paquetesController;
    
    private String tipoProyecto;
    private proyectosLotesView proyectoLotes;
    
    private Boolean editarAbreviatura;

    @PostConstruct
    public void init() {
        logger.info("init");
        try {
            Calendar calendar = Calendar.getInstance();

            calendar.add(Calendar.YEAR, -15);
            setSixteenYearsOld(calendar.getTime());

            loadBundlePropertyFile();
            loadTaxiPropertyFile();
            setNuevaUrbanizacion(new Urbanizacion());

            setSelectDocumento(new Documento());
            setNombreDocumento("");
            setDescripcionDocumento("");
            setNuevoPropietarioPredio(new PropietarioPredio());
            setPropietarioPredioController(new PropietarioPredioController());
            setPredioController(new PredioController());
            setLocationController(new LocationController());
            setPreventaController(new PreventaController());
            setValidadorComentario(false);
            setControladorBucket(new BucketController());
            setControladorDocumento(new DocumentoController());
            setLocations(getLocationController().fillLocationDatatable());
            try {
                setValidador(externalContext().getRequestParameterMap().get("msg"));
            } catch (Exception e) {
                setValidador("1");
            }

            if (getValidador().equals("2")) {
                showMessage(FacesMessage.SEVERITY_INFO, "Documento",
                        "Nuevo documento agregado correctamente");
                setValidador("1");
            }
            if (getValidador().equals("3")) {
                showMessage(FacesMessage.SEVERITY_ERROR, "Documento",
                        "Fallo en el documento");
                setValidador("1");
            }

            setPredioId(externalContext().getRequestParameterMap().get("customerForm:predioDtTbl_selection"));
            setPredio(getPredioController().getPredioById(getPredioId()));
            setPropietarioProyecto(getPredio().getPropetiario());
            setAntiguoPropietario(getPredio().getPropetiario());
            setComentario("");
            setPropietarioId(getPredio().getPropetiario().getId());
            setPreventaController(new PreventaController());
            setListaPropietarioPredio(getPropietarioPredioController().fillPropietarioPredioByPredio(getPredio()));
            updateManzanas();

            switch (getPredio().getCompromisoPago()) {
                case MENSUAL:
                    setCompromisoPago("MENSUAL");
                    break;
                case ANUAL:
                    setCompromisoPago("ANUAL");
                    break;
                case TRIMESTRAL:
                    setCompromisoPago("TRIMESTRAL");
                    break;
                default:
                    break;
            }
            
            switch (getPredio().getTipoProyecto()) {
                case LOTE:
                    setTipoProyecto("Lotes");
                    break;
                case VIVIENDA:
                    setTipoProyecto("Viviendas");
                    break;
                case DEPARTAMENTO:
                    setTipoProyecto("Departamentos");
                    break;
                case OFICINA:
                    setTipoProyecto("Oficinas");
                    break;    
                default:
                    break;
            }

            setCustomerCommercialInvoice(new PersonCommercialInvoice());
            setAddress(new Address(AddressType.HOME));
            setAddCustomerBtnOnclick(false);

            setPerosonalizado(false);
            setUrbanizacionController(new UrbanizacionController());
            setMensual(false);
            setQuincenal(false);
            setAbonosProyecto(new ArrayList<>());
            setAdeudo(getPredio().getCosto() - getPredio().getAnticipo());
            setListaUrbanizacion(getUrbanizacionController().fillAllUrbanizacionesByPredio(getPredio()));
            setPagos(getPredioController().contarAbonos(getPredio()));
            setAbonosProyectoCreados(getPredioController().fillAllAbonoProyecto(getPredio()));
            setProyectoLotes(getPredioController().getProyectoLotes(getPredio().getId()));
            setNewManzana(new ArrayList<>());
            setAddCustomerBtnOnclick(true);
            
            if(getPredio().getAbreviatura()!=null && !getPredio().getAbreviatura().isEmpty()){
                setEditarAbreviatura(true);
            }else{
                setEditarAbreviatura(false);
            }

        } catch (Exception e) {
            logger.error("init", e);
        }
    }

    public LocationController getLocationController() {
        return locationController;
    }

    public void setLocationController(LocationController locationController) {
        this.locationController = locationController;
    }

    public String getLocationId() {
        return locationId;
    }

    public void setLocationId(String locationId) {
        this.locationId = locationId;
    }

    public List<Location> getLocations() {
        return locations;
    }

    public void setLocations(List<Location> locations) {
        this.locations = locations;
    }

    public Predio getPredio() {
        return predio;
    }

    public void setPredio(Predio predio) {
        this.predio = predio;
    }

    public PredioController getPredioController() {
        return predioController;
    }

    public void setPredioController(PredioController predioController) {
        this.predioController = predioController;
    }

    public List<ContactNumber> getContactNumbers() {
        if (null == contactNumbers) {
            contactNumbers = new ArrayList<>();
        }
        return contactNumbers;
    }

    public void setContactNumbers(List<ContactNumber> contactNumbers) {
        this.contactNumbers = contactNumbers;
    }

    public Address getAddress() {
        return address;
    }

    public UploadedFile getFile() {
        return file;
    }

    public void setFile(UploadedFile file) {
        this.file = file;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public boolean isAddCustomerBtnOnclick() {
        return addCustomerBtnOnclick;
    }

    public void setAddCustomerBtnOnclick(boolean addCustomerBtnOnclick) {
        this.addCustomerBtnOnclick = addCustomerBtnOnclick;
    }

    public Date getSixteenYearsOld() {
        return sixteenYearsOld;
    }

    public void setSixteenYearsOld(Date sixteenYearsOld) {
        this.sixteenYearsOld = sixteenYearsOld;
    }

    public DualListModel<Service> getServices() {
        return services;
    }

    public void setServices(DualListModel<Service> services) {
        this.services = services;
    }

    public PersonCommercialInvoice getCustomerCommercialInvoice() {
        return customerCommercialInvoice;
    }

    public void setCustomerCommercialInvoice(PersonCommercialInvoice customerCommercialInvoice) {
        this.customerCommercialInvoice = customerCommercialInvoice;
    }

    public String getPredioId() {
        return predioId;
    }

    public void setPredioId(String predioId) {
        this.predioId = predioId;
    }

    public String getPropietarioId() {
        return propietarioId;
    }

    public void setPropietarioId(String propietarioId) {
        this.propietarioId = propietarioId;
    }

    public String getCompromisoPago() {
        return compromisoPago;
    }

    public void setCompromisoPago(String compromisoPago) {
        this.compromisoPago = compromisoPago;
    }

    public List<Person> getProviders() {
        return getPredioController().fillProviderComboBox(getLoggedUser().getLocation());
    }

    public List<Manzana> getManzana() {
        return manzana;
    }

    public void setManzana(List<Manzana> manzana) {
        this.manzana = manzana;
    }

    public PreventaController getPreventaController() {
        return preventaController;
    }

    public void setPreventaController(PreventaController preventaController) {
        this.preventaController = preventaController;
    }

    public void updateLotes(Manzana manzana) {
        setPreventaController(new PreventaController());
        setLostes(getPreventaController().fillAllLotes(manzana));
        setSelectedManzana(manzana);
        setLotesVendidosApartados(getPredioController().contarLotesVendidosApartados(getSelectedManzana()));

    }

    public List<Lote> getLostes() {
        return lostes;
    }

    public void setLostes(List<Lote> lostes) {
        this.lostes = lostes;
    }

    public Lote getSelectedLote() {

        if (selectedLote == null) {
            selectedLote = new Lote();

        }
        return selectedLote;
    }

    public void setSelectedLote(Lote selectedLote) {
        this.selectedLote = selectedLote;
    }

    public String getActiveTap() {
        return activeTap;
    }

    public void setActiveTap(String activeTap) {
        this.activeTap = activeTap;
    }

    public String getPeriodoPago() {
        return periodoPago;
    }

    public void setPeriodoPago(String periodoPago) {
        this.periodoPago = periodoPago;
    }

    public boolean isPerosonalizado() {
        return perosonalizado;
    }

    public void setPerosonalizado(boolean perosonalizado) {
        this.perosonalizado = perosonalizado;
    }

    public boolean isMensual() {
        return mensual;
    }

    public void setMensual(boolean mensual) {
        this.mensual = mensual;
    }

    public boolean isQuincenal() {
        return quincenal;
    }

    public void setQuincenal(boolean quincenal) {
        this.quincenal = quincenal;
    }

    public List<AbonoProyecto> getAbonosProyecto() {
        return abonosProyecto;
    }

    public void setAbonosProyecto(List<AbonoProyecto> abonosProyecto) {
        this.abonosProyecto = abonosProyecto;
    }

    public AbonoProyecto getSelectedAbonoProyecto() {
        return selectedAbonoProyecto;
    }

    public void setSelectedAbonoProyecto(AbonoProyecto selectedAbonoProyecto) {
        this.selectedAbonoProyecto = selectedAbonoProyecto;
    }

    public double getAdeudo() {
        return adeudo;
    }

    public void setAdeudo(Double adeudo) {
        this.adeudo = adeudo;
    }

    public Double getAnterior() {
        return anterior;
    }

    public void setAnterior(Double anterior) {
        this.anterior = anterior;
    }

    public Date getDiaAPagar() {
        return diaAPagar;
    }

    public void setDiaAPagar(Date diaAPagar) {
        this.diaAPagar = diaAPagar;
    }

    public int getPlazoMeses() {
        return plazoMeses;
    }

    public void setPlazoMeses(int plazoMeses) {
        this.plazoMeses = plazoMeses;
    }

    public boolean isPagos() {
        return pagos;
    }

    public void setPagos(boolean pagos) {
        this.pagos = pagos;
    }

    public List<AbonoProyecto> getAbonosProyectoCreados() {
        return abonosProyectoCreados;
    }

    public void setAbonosProyectoCreados(List<AbonoProyecto> abonosProyectoCreados) {
        this.abonosProyectoCreados = abonosProyectoCreados;
    }

    public List<Manzana> getNewManzana() {
        return newManzana;
    }

    public void setNewManzana(List<Manzana> newManzana) {
        this.newManzana = newManzana;
    }

    public Manzana getSelectedManzana() {
        return selectedManzana;
    }

    public void setSelectedManzana(Manzana selectedManzana) {
        this.selectedManzana = selectedManzana;
    }

    public boolean isLotesVendidosApartados() {
        return lotesVendidosApartados;
    }

    public void setLotesVendidosApartados(boolean lotesVendidosApartados) {
        this.lotesVendidosApartados = lotesVendidosApartados;
    }

    public User getUsuarioLogeado() {
        return usuarioLogeado;
    }

    public void setUsuarioLogeado(User usuarioLogeado) {
        this.usuarioLogeado = usuarioLogeado;
    }

    public List<Urbanizacion> getListaUrbanizacion() {
        return listaUrbanizacion;
    }

    public void setListaUrbanizacion(List<Urbanizacion> listaUrbanizacion) {
        this.listaUrbanizacion = listaUrbanizacion;
    }

    public UrbanizacionController getUrbanizacionController() {
        return urbanizacionController;
    }

    public void setUrbanizacionController(UrbanizacionController urbanizacionController) {
        this.urbanizacionController = urbanizacionController;
    }

    public Urbanizacion getNuevaUrbanizacion() {
        return nuevaUrbanizacion;
    }

    public void setNuevaUrbanizacion(Urbanizacion nuevaUrbanizacion) {
        this.nuevaUrbanizacion = nuevaUrbanizacion;
    }

    public Person getPropietarioProyecto() {
        return propietarioProyecto;
    }

    public void setPropietarioProyecto(Person propietarioProyecto) {
        this.propietarioProyecto = propietarioProyecto;
    }

    public String getComentario() {
        return comentario;
    }

    public void setComentario(String comentario) {
        this.comentario = comentario;
    }

    public Person getAntiguoPropietario() {
        return antiguoPropietario;
    }

    public void setAntiguoPropietario(Person antiguoPropietario) {
        this.antiguoPropietario = antiguoPropietario;
    }

    public boolean isValidadorComentario() {
        return validadorComentario;
    }

    public void setValidadorComentario(boolean validadorComentario) {
        this.validadorComentario = validadorComentario;
    }

    public PropietarioPredio getNuevoPropietarioPredio() {
        return nuevoPropietarioPredio;
    }

    public void setNuevoPropietarioPredio(PropietarioPredio nuevoPropietarioPredio) {
        this.nuevoPropietarioPredio = nuevoPropietarioPredio;
    }

    public PropietarioPredioController getPropietarioPredioController() {
        return propietarioPredioController;
    }

    public void setPropietarioPredioController(PropietarioPredioController propietarioPredioController) {
        this.propietarioPredioController = propietarioPredioController;
    }

    public List<PropietarioPredio> getListaPropietarioPredio() {
        return listaPropietarioPredio;
    }

    public void setListaPropietarioPredio(List<PropietarioPredio> listaPropietarioPredio) {
        this.listaPropietarioPredio = listaPropietarioPredio;
    }

    public String getNombreDocumento() {
        return nombreDocumento;
    }

    public void setNombreDocumento(String nombreDocumento) {
        this.nombreDocumento = nombreDocumento;
    }

    public String getDescripcionDocumento() {
        return descripcionDocumento;
    }

    public void setDescripcionDocumento(String descripcionDocumento) {
        this.descripcionDocumento = descripcionDocumento;
    }

    public BucketController getControladorBucket() {
        return controladorBucket;
    }

    public void setControladorBucket(BucketController controladorBucket) {
        this.controladorBucket = controladorBucket;
    }

    public DocumentoController getControladorDocumento() {
        return controladorDocumento;
    }

    public void setControladorDocumento(DocumentoController controladorDocumento) {
        this.controladorDocumento = controladorDocumento;
    }

    public String getValidador() {
        return validador;
    }

    public void setValidador(String validador) {
        this.validador = validador;
    }

    public Documento getSelectDocumento() {
        return selectDocumento;
    }

    public void setSelectDocumento(Documento selectDocumento) {
        this.selectDocumento = selectDocumento;
    }

    public Boolean getLimiteProyectos() {
        return limiteProyectos;
    }

    public void setLimiteProyectos(Boolean limiteProyectos) {
        this.limiteProyectos = limiteProyectos;
    }

    public Integer getNumLotes() {
        return numLotes;
    }

    public void setNumLotes(Integer numLotes) {
        this.numLotes = numLotes;
    }

    public LoteController getLoteController() {
        return loteController;
    }

    public void setLoteController(LoteController loteController) {
        this.loteController = loteController;
    }

    public PaquetesController getPaquetesController() {
        return paquetesController;
    }

    public void setPaquetesController(PaquetesController paquetesController) {
        this.paquetesController = paquetesController;
    }

    public String getTipoProyecto() {
        return tipoProyecto;
    }

    public void setTipoProyecto(String tipoProyecto) {
        this.tipoProyecto = tipoProyecto;
    }

    public proyectosLotesView getProyectoLotes() {
        return proyectoLotes;
    }

    public void setProyectoLotes(proyectosLotesView proyectoLotes) {
        this.proyectoLotes = proyectoLotes;
    }

    public Boolean getEditarAbreviatura() {
        return editarAbreviatura;
    }

    public void setEditarAbreviatura(Boolean editarAbreviatura) {
        this.editarAbreviatura = editarAbreviatura;
    }
    
}
