AsientoPredefinidoEjecutado.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using sage.ew.enumerations;
using sage.ew.interficies;

namespace sage.ew.contabilidad
{
    internal class AsientoPredefinidoEjecutado
    {
        #region Variables

        private readonly AsientosPredefinidosGenerador generadorPredefinidos;
        private readonly IEnumerable<AsientoPredefinido.LineaAsientoPredefinido> lineasPredefinido;
        private readonly IAsientos asientoGenerado;
        private eTipoAsientoPredefinidoPrevisto tipoAsientoPrevisto = eTipoAsientoPredefinidoPrevisto.Indetermiando;

        #endregion Variables

        #region Constructores

        private AsientoPredefinidoEjecutado() { }

        public AsientoPredefinidoEjecutado(AsientosPredefinidosGenerador toGenerador, IEnumerable<AsientoPredefinido.LineaAsientoPredefinido> toLineas, IAsientos toAsiento)
        {
            lineasPredefinido = toLineas;
            asientoGenerado = toAsiento;
            generadorPredefinidos = toGenerador;

            evaluarTipoAsiento();
        }

        #endregion Constructores

        #region Métodos públicos

        #region Getters

        public AsientosPredefinidosGenerador GetGenerador()
        {
            return generadorPredefinidos;
        }

        public IAsientos GetAsiento()
        {
            return asientoGenerado;
        }

        public IEnumerable<AsientoPredefinido.LineaAsientoPredefinido> GetLineas()
        {
            return lineasPredefinido;
        }

        public eTipoAsientoPredefinidoPrevisto GetTipoAsientoPrevisto()
        {
            return tipoAsientoPrevisto;
        }

        #endregion Getters

        public bool EsFactura()
        {
            return generadorPredefinidos._DebeContenerInformacionDeFactura(lineasPredefinido);
        }

        public bool EsFacturaDeVenta()
        {
            return generadorPredefinidos._EsFacturaVenta(lineasPredefinido);
        }

        public bool EsFacturaDeCompra()
        {
            return generadorPredefinidos._EsFacturaCompra(lineasPredefinido);
        }

        public bool EsUnCobro()
        {
            return tipoAsientoPrevisto == eTipoAsientoPredefinidoPrevisto.Cobro;
        }

        public bool EsUnPago()
        {
            return tipoAsientoPrevisto == eTipoAsientoPredefinidoPrevisto.Pago;
        }

        public bool EsUnCobroConRelaciones()
        {
            bool cobro = tipoAsientoPrevisto == eTipoAsientoPredefinidoPrevisto.Cobro;
            bool relaciones = ContieneRelaciones();
            return (cobro && relaciones);
        }

        public bool EsUnPagoConRelaciones()
        {
            bool pago = tipoAsientoPrevisto == eTipoAsientoPredefinidoPrevisto.Pago;
            bool relaciones = ContieneRelaciones();
            return (pago && relaciones);
        }

        public bool ContieneBancos()
        {
            var lineasDeBancos = lineasPredefinido.Where(lolinea => CONTABILIDAD._EsBanco(lolinea._Cuenta)).ToList();
            return lineasDeBancos.Any();
        }

        public bool ContieneTesoreria()
        {
            var lineasDeCajas = lineasPredefinido.Where(lolinea => CONTABILIDAD._EsTesoreria(lolinea._Cuenta)).ToList();
            return lineasDeCajas.Any();
        }

        public bool ContieneClientes()
        {
            var lineasDeClientes = lineasPredefinido.Where(lolinea => CONTABILIDAD._EsCliente(lolinea._Cuenta)).ToList();
            return lineasDeClientes.Any();
        }

        public bool ContieneProveedores()
        {
            var lineasDeProveedores = lineasPredefinido.Where(lolinea => CONTABILIDAD._EsProveedor(lolinea._Cuenta)).ToList();
            return lineasDeProveedores.Any();
        }

        public bool ContieneTrabajadores()
        {
            var lineasDeTrabajadores = lineasPredefinido.Where(lolinea => CONTABILIDAD._EsTrabajador(lolinea._Cuenta)).ToList();
            return lineasDeTrabajadores.Any();
        }

        public bool ContieneRelaciones()
        {
            return lineasPredefinido.Any(lolinea => !String.IsNullOrWhiteSpace(lolinea._Relacion));
        }

        public IEnumerable<string> ObtenerRelaciones()
        {
            List<string> lisRelaciones = new List<string>();
            var lineasConRelaciones = lineasPredefinido.Where(lolinea => !String.IsNullOrWhiteSpace(lolinea._Relacion)).ToList();
            lineasConRelaciones.ForEach(loLinea => lisRelaciones.Add(loLinea._Relacion));
            return lisRelaciones;
        }

        #endregion Métodos públicos

        #region Métodos privados

        private void evaluarTipoAsiento()
        {
            if (asientoGenerado == null)
                tipoAsientoPrevisto = eTipoAsientoPredefinidoPrevisto.Ninguno;
            else
            {
                if (generadorPredefinidos._DebeContenerInformacionDeFactura(lineasPredefinido)) //Determino si es una factura
                {
                    evaluarTipoAsiento_Facturas();
                }
                else  //No es una factura, trato de determinar si es un cobro-pago
                {
                    if (ContieneTesoreria())
                    {
                        evaluarTipoAsiento_CobrosPagos();
                    }
                    else //No se que es... 
                        tipoAsientoPrevisto = eTipoAsientoPredefinidoPrevisto.Indetermiando;
                }
            }

        }

        private void evaluarTipoAsiento_Facturas()
        {
            bool esFacturaVenta = EsFacturaDeVenta();
            bool esFacturaCompra = EsFacturaDeCompra();

            if (esFacturaVenta && esFacturaCompra)
            {
                tipoAsientoPrevisto = eTipoAsientoPredefinidoPrevisto.Indetermiando; //Caso no contemplado => posible error
            }
            else
            {
                if (esFacturaVenta)
                    tipoAsientoPrevisto = eTipoAsientoPredefinidoPrevisto.FacturaVenta;

                if (esFacturaCompra)
                    tipoAsientoPrevisto = eTipoAsientoPredefinidoPrevisto.FacturaCompra;
            }
        }

        private void evaluarTipoAsiento_CobrosPagos()
        {
            bool tieneClientes = ContieneClientes();
            bool tieneProveedores = ContieneProveedores() || ContieneTrabajadores(); //Los trabajadores son de alguna forma 'proveedores de servicios'

            if (tieneClientes && tieneProveedores)
            {
                tipoAsientoPrevisto = eTipoAsientoPredefinidoPrevisto.Indetermiando; //Caso no contemplado => posible error
            }
            else
            {
                if (tieneClientes)
                    tipoAsientoPrevisto = eTipoAsientoPredefinidoPrevisto.Cobro;

                if (tieneProveedores)
                    tipoAsientoPrevisto = eTipoAsientoPredefinidoPrevisto.Pago;
            }
        }

        #endregion Métodos privados
    }
}