Pedido Activity

PedidosActivity.java

package com.homeelementsweb.pedidosrecaudosmovilsantander.Controladores.Actividades.Pedido;


import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.content.Intent;
import android.graphics.Color;
import android.os.Bundle;
import android.support.v4.view.ViewPager;
import android.util.Log;
import android.view.Gravity;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.ListView;
import android.widget.TextView;
import android.widget.Toast;

import com.homeelementsweb.pedidosrecaudosmovilsantander.Configuracion.Conf_App;
import com.homeelementsweb.pedidosrecaudosmovilsantander.Controladores.Adaptadores.ErroresListAdapter;
import com.homeelementsweb.pedidosrecaudosmovilsantander.Controladores.Adaptadores.PedidosFragmentAdapter;
import com.homeelementsweb.pedidosrecaudosmovilsantander.Modelos.Entidades.CondicionDespacho;
import com.homeelementsweb.pedidosrecaudosmovilsantander.Modelos.Entidades.Descuento;
import com.homeelementsweb.pedidosrecaudosmovilsantander.Modelos.Entidades.DetallePedido;
import com.homeelementsweb.pedidosrecaudosmovilsantander.Modelos.Entidades.Empaque;
import com.homeelementsweb.pedidosrecaudosmovilsantander.Modelos.Entidades.Notas;
import com.homeelementsweb.pedidosrecaudosmovilsantander.Modelos.Entidades.Pedido;
import com.homeelementsweb.pedidosrecaudosmovilsantander.Modelos.Entidades.Producto;
import com.homeelementsweb.pedidosrecaudosmovilsantander.Modelos.Entidades.ProductoDescuento;
import com.homeelementsweb.pedidosrecaudosmovilsantander.Modelos.Entidades.Vendedor;
import com.homeelementsweb.pedidosrecaudosmovilsantander.Modelos.Repositorio.PedidoRepository;
import com.homeelementsweb.pedidosrecaudosmovilsantander.Modelos.Repositorio.VendedorRepository;
import com.homeelementsweb.pedidosrecaudosmovilsantander.R;
import com.homeelementsweb.pedidosrecaudosmovilsantander.Servicios.Sincronizacion.SincronizarPedidos;
import com.homeelementsweb.pedidosrecaudosmovilsantander.Utilidades.Validaciones.PedidosValidaciones;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;

/**
 * Actividad encargada de controlar los fragments pertenecientes a la toma del pedido,
 * también es la encargada de controlar metodos estaticos para la correcta comunicacion entre
 * fragments.
 * @author Alejandro Arroyave Pérez
 * @version 1
 *
 */
public class PedidosActivity extends Activity{


    /**
     * View Pager que contiene los titulos de los fragments que hacen parte del
     * pedido
     */
    private ViewPager viewPager;
    /**
     * Variable que contiene el pedido que se esta tomando en el momento
     * La entidad Pedido no corresponde al pedido completo si no solo
     * a su encabezado
     */
    private static Pedido pedido;
    /**
     * Lista donde se almacenan las lineas que se van agregando al pedido.
     * Se usa ProductoDescuento ya que por medio de esta entidad
     * se pueden obtener las entidades de producto, descuento, detalleproducto
     */
    public static ArrayList<ProductoDescuento> productosDescuento;
    /**
     * Atributo en el cual se van a almacenar las observaciones
     * que se hacen a cada producto. Esto se debe manejar en
     * un array independiente al de productosDescuento debido
     * a que no se tiene una relacion directa de notas con
     * el pedido
     */
    private static ArrayList<Notas> observacionesProductos;
    /**
     * Contiene el total del pedido que se este tomando
     */
    private static float totalPedido;
    /**
     * Contiene el subtotal del pedido
     */
    private static float subtotalAcumulado;
    /**
     * Es el total de iva del pedido (El dinero que representa el iva, no el porcentaje)
     */
    private static float totalIva;
    /**
     * Contiene el numero interno del pedido que se esta digitando (el numero del pedido real se asigna en el servidor)
     */
    private static String numeroPedido;
    /**
     * Adaptador encargado de controlar los fragmentos pertenecientes al pedido:
     *      - CondicionesFragment
     *      - ProductoFragment
     *      - VentaFragment
     */
    private static PedidosFragmentAdapter fragmentAdapter;
    /**
     * Variable en la que se almacena el codigo del tipo de pedido que se está diligenciando actualmente
     */
    private static String tipoPedido;
    /**
     * Vendedor que está realizando
     */
    private static   Vendedor vendedor;

    private VendedorRepository vendedorRepository;
    /**
     * Atributo para almacenar las observaciones comerciales del pedido (quedan guadradas en notas con origen 0)
     */
    private String observacionesComerciales;
    /**
     * Atributo para almacenar el subcanal al cual pertenece el cliente que se le está tomando el pedido
     */
    private String subcanal;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_pedidos);
        fragmentAdapter = new PedidosFragmentAdapter(getFragmentManager());
        viewPager = (ViewPager) findViewById(R.id.pagerPedidos);
        viewPager.setAdapter(fragmentAdapter);
        totalPedido = 0f;
        subtotalAcumulado = 0f;
        obtenerNumeroPedido();
        vendedorRepository = new VendedorRepository(this);
        vendedor = vendedorRepository._obtenerVendedor();
        observacionesProductos = (observacionesProductos==null)? new ArrayList<Notas>() : observacionesProductos;
        Bundle datosActivity = this.getIntent().getExtras();
        subcanal = datosActivity.getString("SubcanalCliente");

    }

    public void cambiarFragment(int posicion){
        viewPager.setCurrentItem(posicion);
    }



    /**
     * Metodo encargado de advertir al usuario que se perderan los datos digitados
     * cuando preciona la tecla de retroceso
     */
    @Override
    public void onBackPressed() {
        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setTitle("¿Realmente desea regresar?");
        builder.setMessage("Si regresa se perderá el pedido que está realizando actualmente");
        builder.setPositiveButton("Regresar", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                Regresar();

            }
        });
        builder.setNegativeButton("Cancelar", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {

            }
        });
        builder.create().show();


    }

    public void digitarProducto(Producto producto){
        Intent intent = new Intent(this, DigitaProductoPedidoActivity.class);
        Bundle datosActivity = this.getIntent().getExtras();
        intent.putExtra("IdProducto",producto.getId());
        intent.putExtra("ListaPrecios", datosActivity.getString("ListaPrecios"));
        intent.putExtra("SubcanalCliente", datosActivity.getString("SubcanalCliente"));
        intent.putExtra("totalPedido", totalPedido);
        intent.putExtra("TipoPedido", tipoPedido);
        startActivity(intent);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
    }

    /**
     * Metodo que se debe llama al presionar la tecla de regresar,
     *  es utilizado para reiniciar variables estaticas que podrian
     *  generar conflicto al instanciar de nuevo la actividad
     */
    private void Regresar(){
        pedido = null;
        productosDescuento = null;
        observacionesProductos = null;
        totalPedido = 0;
        subtotalAcumulado = 0;
        totalIva = 0;
        numeroPedido = null;
        tipoPedido = null;
        vendedor = null;
        super.onBackPressed();
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_pedidos, menu);
        // -------------------------------------------------
        return true;

    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();

        fragmentAdapter.onClickActionBar(id, viewPager.getCurrentItem());
        //noinspection SimplifiableIfStatement
        if (id==R.id.guardarPedido)
        {
           guardarPedido();
        }

        return super.onOptionsItemSelected(item);
    }

    /**
     * Metodo que es utilizado para guardar un pedido
     * el metodo no deja guardar el pedido en caso
     * de que no sean válidos los datos
     */
    private void guardarPedido(){
        pedido = fragmentAdapter.obtenerEncabezado();
        observacionesComerciales = fragmentAdapter.obtenerObservacionesComerciales();
        CondicionDespacho condicionDespacho = fragmentAdapter.obtenerCondicionDespacho();
        pedido.setCondicionDespacho(condicionDespacho);
        PedidoRepository pedidoRepository = new PedidoRepository(this);

        if(validarGuadar())
        {
            try
            {
                asignarEncabezadoADetalle();
                asignarObservacionComercial();
                pedidoRepository._guardarPedido(pedido, productosDescuento, observacionesProductos);
                mostrarMensaje("Pedido guardado correctamente");
                SincronizarPedidos sincronizarPedido = new SincronizarPedidos(null,this);
                sincronizarPedido.execute();

                Regresar();
            }
            catch (SQLException e)
            {
                mostrarMensajeError("Error al intentar guardar el pedido ");
                Log.e("GuardarPedido",e.toString());
            }

        }

    }

    /**
     * Metodo para agregar la observacion comercial a las notas
     * ya que la observacion comercial es la nota del encabezado
     * y se debe poner con origen 0 en las notas del pedido
     */
    private void asignarObservacionComercial(){
       observacionesProductos = (observacionesProductos==null)? new ArrayList<Notas>() : observacionesProductos;
        Notas nota = new Notas();
        nota.setTransaccion(vendedor.getComprobanteAsignado());
        nota.setIdDispositivo(numeroPedido);
        nota.setOrigen(0);
        nota.setNota(observacionesComerciales);
        observacionesProductos.add(0, nota);
    }

    /**
     * Metodo que se utiliza para asignar la entidad pedido
     * a los detalles del pedido.
     */
    private void asignarEncabezadoADetalle(){
        for (ProductoDescuento productoDescuento : productosDescuento)
        {
            productoDescuento.getDetallePedido().setPedido(pedido);
            productoDescuento.getDetallePedido().setIdPedidoDispositivo(pedido.getIdPedidoDispositivo());
        }
    }

    /**
     * Metodo para validar los campos necesarios al momento de dar click sobre guardar
     * @return true si la validacion fue correcta. false en caso contrario
     */
    private boolean validarGuadar(){
        if (productosDescuento!= null) {
            String montoMinimo = PedidosValidaciones.validarMontoMinimo(subtotalAcumulado, pedido.getTipoPedido().getTipo());
            String encabezado = PedidosValidaciones.validarEncabezado(pedido);
            String productoDescuento = PedidosValidaciones.validarProductosDescuento(productosDescuento);
            HashMap<String, String> validaciones = PedidosValidaciones.validarPedido(pedido, productosDescuento, subcanal, this, caluclarSubtotal(productosDescuento));

            if (!montoMinimo.equals(PedidosValidaciones.SUCCESS)) {
                mostrarMensajeError(montoMinimo);
                return false;
            } else if (!encabezado.equals(PedidosValidaciones.SUCCESS)) {
                mostrarMensajeError(encabezado);
                return false;
            } else if (!productoDescuento.equals(PedidosValidaciones.SUCCESS)) {
                mostrarMensajeError(productoDescuento);
                return false;
            } else if (!PedidosValidaciones.pedidoValido(validaciones, productosDescuento.size())) {
                mostrarVentanaError(validaciones);
                return false;
            } else {
                return true;
            }
        }else{
            mostrarMensajeError("No hay productos agregados a la venta");
            return false;
        }
    }

    /**
     * Metodo encargado de calcular el subtotal del pedido
     * utiliza los detalles del pedido para iterarlos
     * y realizar la sumatoria
     * @param productosDescuento
     * @return
     */
    public float caluclarSubtotal(ArrayList<ProductoDescuento> productosDescuento){
        float sumatoria = 0;
        for (ProductoDescuento productoDescuento : productosDescuento){
            sumatoria += productoDescuento.getDetallePedido().getValor();
        }
        return sumatoria;
    }

    /**
     * Metodo para desplegar la ventana flotante que muestra los errores
     * que son detectados y por los cuales no se deja guardar el pedido
     * @param validaciones
     */
    private void mostrarVentanaError(HashMap<String,String> validaciones){
        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setTitle("Errores reportados");
        ListView lv_errores = new ListView(this);
        ErroresListAdapter adapter = new ErroresListAdapter(validaciones,this);
        lv_errores.setAdapter(adapter);
        builder.setView(lv_errores);
        builder.setNeutralButton("OK", null);
        AlertDialog alertDialog = builder.create();
        alertDialog.show();

    }


    /**
     *  Metodo de agregar una linea al producto, manteniendola en memoria
     * @param producto     El producto que se va a agregar a la venta
     * @param descuento    Entidad Descuento que contiene el descuento base, el descuento promocional y el valor del descuento aplicado
     * @param cantidad     Cantidad pedida
     * @param iva          Iva del producto
     * @param valorTotal   Cálculo del valor total del producto
     * @param subtotal     Cálculo del subtotal del producto
     * @param observacion  Es la observación que se digita por cada producto
     * @param precioListaPrecios Es el valor unitario del producto sin iva para la lista de precios a la cual pertenece el cliente
     * @param empaque            Es el empaque del producto que se selecciono al pedir el producto (unidad medida)
     */
    public static void agregarLinea(Producto producto, Descuento descuento, int cantidad, float iva, float valorTotal, float subtotal, String observacion,float precioListaPrecios, Empaque empaque){

        DetallePedido detalle = setDetalle(cantidad, precioListaPrecios, iva, empaque);
        agregarProductoDescuento(producto, descuento, detalle, empaque);
        if(observacion!=null && !observacion.equals(""))
        {
             ProductoDescuento productoExistente = productoAgregado(producto.getItem());
            if(productoExistente==null)
            {
                //Si el producto no ha sido agregado a la venta se le dice que el origen de la nota es el del ultimo de la lista
                agregarNota(observacion, productosDescuento.size());
            }
            else
            {
                //Si el producto ya existe quiere decir que se está editando, por lo tanto se debe respetar el origen que tiene en la lista
                agregarNota(observacion,productoExistente.getDetallePedido().getOrigen());
            }
        }

        //Si el pedido es un obsequio se asigna 0 de lo contrario se hace la suma correspondiente
        setTotalPedido((tipoPedido.equals(Conf_App.TIPO_PEDIDO_OBSEQUIO)) ? 0 : (totalPedido + valorTotal));
        setSubtotalPedido((tipoPedido.equals(Conf_App.TIPO_PEDIDO_OBSEQUIO)) ? 0 : (subtotalAcumulado + subtotal));
        float cantidadUnd = cantidad * empaque.getTipoEmpaque().getContenido();
        actualizarTotalIva(precioListaPrecios, cantidadUnd, iva, true, descuento.getValor());
        fragmentAdapter.actualizarProductosAgregados();
        fragmentAdapter.actualizarTotalDescuento();
    }

    /**
     * Calcula el un precio con el iva pasado como parametro
     * @param iva       El iva a aplicar (16 , 19, 20 etc)
     * @param precio    El precio sin el iva
     * @return   Precio con el iva incluido
     */
    private static float calcularPrecioConIva(float iva, float precio){
        return (1+iva)*precio;
    }

    private static void agregarNota(String observacion,int origen){
        observacionesProductos = (observacionesProductos==null)? new ArrayList<Notas>() : observacionesProductos;
        Notas nota = new Notas();
        nota.setIdDispositivo(numeroPedido);
        nota.setOrigen(origen);
        nota.setNota(observacion);
        nota.setTransaccion(vendedor.getComprobanteAsignado());
        observacionesProductos.add(nota);
    }


    /**
     * Metodo encargado de agregar un productoDescuento a la lista de productos descuentos
     * que son las que representan las lineas del pedido
     * @param producto  producto a agregar
     * @param descuento entidad Descuento que contiene el descuento base, promocional y el valor del descuento asignado
     * @param detalle   entidad Detalle que corresponde al detalle del pedido para esa linea que se está agregando
     */
    private static void agregarProductoDescuento(Producto producto, Descuento descuento, DetallePedido detalle,Empaque empaque){
        productosDescuento = (productosDescuento ==null)?new ArrayList<ProductoDescuento>(): productosDescuento;
        ProductoDescuento productoDescuento = new ProductoDescuento();
        productoDescuento.setDescuento(null);
        productoDescuento.setDetallePedido(detalle);
        productoDescuento.setProducto(producto);
        productoDescuento.setDescuento(descuento);
        detalle.setOrigen(productosDescuento.size() + 1);
        ProductoDescuento productoExistente = productoAgregado(producto.getItem());
        if(productoExistente!=null)
        {
            int posicion = productosDescuento.indexOf(productoExistente);
            eliminarLinea(posicion);
            productosDescuento.add(posicion, productoDescuento);

        }
        else
        {
            productosDescuento.add(productoDescuento);
        }



    }

    /**
     * Metodo encargado de recibir la cantidad, el valor, el iva y el empaue, para devolverlo
     * en una entidad DetallePedido. (El detalle de pedido corresponde a una sola linea del pedido)
     * @param cantidad  cantidad que se pidio
     * @param valor     precio unitario del producto (precio de la lista de precios)
     * @param iva       iva que se cobra por el producto
     * @param empaque   Empaque que se eligio al pedir el producto
     * @return DetallePedido con el detalle correspondiente a la información que se pasó como parametro
     */
    private static DetallePedido setDetalle(int cantidad,float valor,float iva,Empaque empaque){
        DetallePedido detalle = new DetallePedido();
        detalle.setCantidad(cantidad);
        detalle.setValor(valor * (cantidad * empaque.getTipoEmpaque().getContenido()) );
        detalle.setIva(iva);
        detalle.setCodigoEmpaque(empaque.getCodigo());
        detalle.setContenidoEmpaque(empaque.getTipoEmpaque().getContenido());
        detalle.setValorUnitario(valor);
        detalle.setValorUnitarioEmpaque(valor * empaque.getTipoEmpaque().getContenido());

        return detalle;
    }

    /**
     * Metodo encargado de obtener de la base de datos el numero de pedido
     * que se le puede asignar al pedido que se está tomando, y lo instancia
     * en el atributo numeroPedido
     */
    private void obtenerNumeroPedido(){
        PedidoRepository pedidoRepository = new PedidoRepository(this);
        try
        {
           numeroPedido = pedidoRepository._obtenerNumeroPedido();
        }
        catch (SQLException e)
        {
            mostrarMensajeError("No se encontro numero del pedido en el dispositivo");
            Log.e("NumeroPedido",e.toString() + " Clase PedidosActivity - Metodo: obtenerNumeroPedido" );
        }
    }

    /**
     * Metodo encargado de actualizar el valor total del iva del pedido, sumandole o restandole
     * la cantiadad * el precio que se pasan como parametros
     * @param precio        El precio unitario y sin iva del producto (precio de la lista de precios)
     * @param cantidad      La cantidad en UNIDADES que se pidio
     * @param iva           El iva que se le aplica a dicho producto
     */
    public static void actualizarTotalIva(float precio, float cantidad, float iva,boolean sumar,float valorDescuento){
        float subtotal = cantidad * precio;
        float precioIvaItem = (subtotal - valorDescuento) * (iva/100);
        totalIva = (sumar)? (totalIva + precioIvaItem) : (totalIva - precioIvaItem);
        fragmentAdapter.actualizarTotalIva(totalIva);
    }

    public static float obtenerCantidadTotalItems(){
        float cantidad =0;
        for (ProductoDescuento productoDescuento : productosDescuento){
            cantidad += productoDescuento.getDetallePedido().getCantidad() * productoDescuento.getDetallePedido().getContenidoEmpaque();
        }
        return cantidad;
    }


    /**
     * Metodo encargado de asignar al atributo pedido, el pedido que es pasado comoparametro
     * @param encabezado
     */
    public static void setPedido(Pedido encabezado)
    {
        pedido = encabezado;

    }

    /**
     * Metodo encargaddo de poner el tipo de pedido que fue seleccionado
     * y de verificar que si se realizao un cambio de un tipo de pedido
     * a un tipo de pedido obsequio, llamar al metodo cambiarProductosAObsequios()
     * @param tip_pedido tipo de pedido (codigo del tipo de pedido)
     */
    public static void setTipoPedido(String tip_pedido){
        if(tipoPedido!=null)
        {
            /* Si se hizo un cambio de tipo de un tipo de pedido que no es obsequio, a un tipo de pedido
            que es obsequio, se debe actualizar la lista de productos que ya tenía instanciada */
            if (!tipoPedido.equals(Conf_App.TIPO_PEDIDO_OBSEQUIO) && tip_pedido.equals(Conf_App.TIPO_PEDIDO_OBSEQUIO))
                cambiarProductosAObsequios();
        }
        tipoPedido = tip_pedido;
        fragmentAdapter.actualizarTipoPedido(tip_pedido);

    }

    /**
     * Metodo encargado de cambiar los valores necesarios cuando por ejemplo
     * se cambia de un tipo de pedido normal a un tipo de pedido obsequio
     */
    private static void cambiarProductosAObsequios(){
        if(productosDescuento !=null)
        {
            for (ProductoDescuento productoDescuento : productosDescuento)
            {
                productoDescuento.getDetallePedido().setValor(0);
                productoDescuento.getDescuento().setDescuentoBase(0f);
                productoDescuento.getDescuento().setDescuentoPromocional(0f);
            }
        }
    }

    /**
     * Metodo encargado de asignar el total del pedido
     * y de avisar al fragmentAdapter que este valor cambio
     * para que a su vez, el fragmentAdapter le avise
     * a los fragmentos que lo requieran
     *
      * @param total El valor que se le desea asignar al total del pedido
     */
    private static void setTotalPedido(float total){
        totalPedido = total;
        fragmentAdapter.setValorTotalPedido(Conf_App.FORMATO_DECIMAL.format(total));
    }


    /**
     * Metodo encargado de asignar el subtotal del pedido
     * y de abisar al fragmentAdapter que este valor cambio
     * para que a su vez, el fragmentAdapter le avise
     * a los fragmentos que lo requieran
     * @param subtotal
     */
    private static void setSubtotalPedido(float subtotal){
        subtotalAcumulado = subtotal;
        fragmentAdapter.setSubtotalPedido(Conf_App.FORMATO_DECIMAL.format(subtotalAcumulado));
    }


    /**
     * Elimina una linea del pedido (Que se tiene en memoria)
     * @param posicion La linea que se desea eliminar.
     */
    public static void eliminarLinea(int posicion){
        ProductoDescuento productoDescuento =  PedidosActivity.productosDescuento.get(posicion);
        float cantidadUnd = productoDescuento.getDetallePedido().getCantidad() * productoDescuento.getDetallePedido().getContenidoEmpaque();
        float valorUnitario = productoDescuento.getDetallePedido().getValor() / cantidadUnd;

        float totalProducto = obtenerTotalProducto(posicion);
        float subtotal = valorUnitario * cantidadUnd;

        int origenAEliminar = productoDescuento.getDetallePedido().getOrigen();
        productosDescuento.remove(posicion);
        eliminarNota(origenAEliminar);
        moverOrigen();
        setTotalPedido(totalPedido - totalProducto);
        setSubtotalPedido(subtotalAcumulado - subtotal);

        actualizarTotalIva(valorUnitario,cantidadUnd,productoDescuento.getProducto().getIva(),false,productoDescuento.getDescuento().getValor());
        fragmentAdapter.actualizarProductosAgregados();

    }

    /**
     * Metodo encargado de cambiar los origenes en el pedido
     * en el momento que es eliminado un producto de la venta
     */
    public static void moverOrigen(){
        //Se mueven todos los origenes dependiendo de la posicion donde quede cada elemento en la lista
        for(int origen =0 ; origen < productosDescuento.size(); origen++)
        {
            int origenAnterior = productosDescuento.get(origen).getDetallePedido().getOrigen();
            productosDescuento.get(origen).getDetallePedido().setOrigen(origen+1);
            for (Notas nota : observacionesProductos)
            {
                if(nota.getOrigen()==origenAnterior)
                {
                    nota.setOrigen(origen+1);
                }
            }
        }
    }

    /**
     * Elimina una nota de la lista de notas (observaciones de productos)
     * @param origen El origen que posee la nota a eliminar (linea de producto)
     */
    public static void eliminarNota(int origen){
        for (Notas nota : observacionesProductos)
        {
            if (nota.getOrigen()==origen)
            {
                observacionesProductos.remove(nota);
                break;
            }
        }
    }

    /**
     * Metodo que calcula el precio total de un producto que fue agregado a la venta
     * el precio es el total del producto (cantidad * precio) con descuento e iva incluido
     * @param posicion la posicion del producto en la lista de productosDescuento (Lista de productos agregados a la venta)
     * @return  El precio total del producto
     */
    public static float obtenerTotalProducto(int posicion){
        ProductoDescuento productoDescuento = productosDescuento.get(posicion);
        int cantidad = productoDescuento.getDetallePedido().getCantidad();
        float cantidadUnd = productoDescuento.getDetallePedido().getContenidoEmpaque() * cantidad;
        float precioProducto = productoDescuento.getDetallePedido().getValor() / cantidadUnd;

        float iva = productoDescuento.getDetallePedido().getIva()/100;
        float descuentoBase = productoDescuento.getDescuento().getDescuentoBase()/100;
        float descuentoPromocional = productoDescuento.getDescuento().getDescuentoPromocional()/100;
        float descuentoAplicado = ((1-descuentoBase) * (1 - descuentoPromocional));
        float subtotal = precioProducto * cantidadUnd;
        float subtotalConDescuento = subtotal * descuentoAplicado;
        float total = calcularPrecioConIva(iva, subtotalConDescuento);
        return total;
    }

    /**
     * Metodo encargado de devolver un ProductoDescuento
     * en caso de que exista un producto agregado a la venta
     * si no existe el producto devuelve null
     * @param item  codigo del producto que se desea verificar si se agrego a la venta
     * @return
     */
    public static ProductoDescuento productoAgregado(String item){
        if (productosDescuento !=null)
        {
            for (ProductoDescuento productoDescuento : productosDescuento)
            {
                if (productoDescuento.getProducto().getItem().equals(item))
                {
                    return productoDescuento;
                }
            }
        }
        return null;
    }

    /**
     * Metodo que es llamado cuando se desea editar un producto que ya fue
     * agregado a la venta
     * @param posicion posicion del producto en la lista de productosDescuentos (lineas del pedido)
     */
    public static void editarProducto(int posicion)
    {
        Producto producto = productosDescuento.get(posicion).getProducto();
        fragmentAdapter.editarProducto(producto);
    }

    /**
     * Metodo encargado de obtener el total del descuento del
     * pedido (en dinero) a partir de la lista de productosDescuento (lineas del pedido)
     * @return
     */
    public static float obtenerTotalDescuento(){
        float valor = 0f;
        for (ProductoDescuento productoDescuento : productosDescuento)
        {
            valor += productoDescuento.getDescuento().getValor();
        }
        return valor;
    }

    public static String getNumeroPedido(){
        return numeroPedido;
    }


    /**
     * Metodo encargado de mostrar un Toast centrado en la pantalla
     * con el mensaje que es pasado como parámetro
     * @param mensaje
     */
    private void mostrarMensaje(String mensaje){
        Toast toast = Toast.makeText(this,mensaje,Toast.LENGTH_LONG);
        toast.setGravity(Gravity.CENTER,0,0);
        toast.show();
    }

    /**
     *Metodo encargado de mostrar un Toast centrado en la pantalla
     * con el mensaje que es pasado como parámetro (El mensaje es mostrado de color rojo)
     * @param mensaje
     */
    private void mostrarMensajeError(String mensaje){
        Toast toast = Toast.makeText(this,mensaje,Toast.LENGTH_LONG);
        TextView texto = (TextView) toast.getView().findViewById(android.R.id.message);
        texto.setTextColor(Color.RED);
        toast.setGravity(Gravity.CENTER,0,0);
        toast.show();
    }

    public static float getTotalPedido() {
        return totalPedido;
    }

    public static float getTotalIva(){ return totalIva; }
}