Docsven_CalculoLineaCosteBeneficio.cs

using sage.ew.objetos;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Drawing;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using sage.ew.ewbase;
using sage.ew.global;
using sage.ew.db;
using System.Data;
using sage.ew.cliente;
using sage.ew.docsven;
using sage.ew.articulo;
using sage.ew.contabilidad;
using sage.ew.docventatpv;
using static sage.ew.docsven.Docsven;
using sage.ew.functions;
using System.Linq;
using sage.ew.global.Diccionarios;
using Sage.ES.S50.UnitTest.Tools;

namespace Sage.ES.S50.UnitTest.Docsven
{
    [TestClass()]
    public class Docsven_CalculoLineaCosteBeneficio
    {
        #region TestContext
        private TestContext testContextInstance;

        public TestContext TestContext
        {
            get
            {
                return testContextInstance;
            }
            set
            {
                testContextInstance = value;
            }
        }
        #endregion TestContext

        #region Atributos de prueba adicionales
        private static string _cUsuario = string.Empty;
        private static bool _llPeso = false;
        private static string _cSerie = "CB"; // Serie CB Coste beneficio
        private static string _Empresa = "01";

        private static string _cAlbaranVenta = string.Empty;
        private static string _cMensaje_Error = string.Empty;

        private const string _cCliente = "43098761";
        private const string _cFormaPago = "FB";
        private const string _Pais = "034";
        private const string _Moneda = "000";

        private const string _cTipoIVA = "FB";
        private const string _cFamilia = "FB";

        private const string _cCtaCompraFamilia = "60098761";
        private const string _cCtaVentaFamilia = "60098761";

        private const string _cArticuloUnidades = "UNI";
        private const string _cArticuloPeso = "PES";
        private const string _cArticuloCajaPeso = "CAJPES";
        private const string _cArticuloCajaPesoPVPPorCaja = "CAJPESPC";
        private const string _cArticuloCaja = "CAJ";
        private const string _cArticuloCajaPVPPorCaja = "CAJCAJ";
        private const string _cArticuloCajaPVPPorMil = "CAJMIL";
        private const string _cArticuloCajaPVPPorComprarCajasVendUni = "CAJCVMIL";
        private const string _cArticuloPE96778 = "APE96778";

        private static ewDocVentaTPV _oewDocVentaTPV = null;

        private static Dictionary<string, ArticuloBeneficio> _dictArticulos = new Dictionary<string, ArticuloBeneficio>();

        private string _Ejercicio
        {
            get { return Convert.ToString(EW_GLOBAL._GetVariable("wc_any")); }
        }
        #endregion Atributos de prueba adicionales

        #region Métodos públicos de inicialización / clean del test
        // 
        //Puede utilizar los siguientes atributos adicionales mientras escribe sus pruebas:
        //
        //Use ClassInitialize para ejecutar código antes de ejecutar la primera prueba en la clase 
        [ClassInitialize()]
        public static void MyClassInitialize(TestContext testContext)
        {
            //Conexion a Base de Datos
            testContext.__Test_LoadRandomConfig();

            _cUsuario = Convert.ToString(EW_GLOBAL._GetVariable("wc_usuario"));

            if (_cUsuario != "SUPERVISOR")
                EW_GLOBAL.ValorEnClave_VarGlob("wc_usuario", "SUPERVISOR");

            // Certificamos que trabajamos con series de albaranes
            EW_GLOBAL._SetVariable("wl_Factser", true);  // Series de albaranes
            EW_GLOBAL._SetVariable("wl_peso", true); // Activamos trabajar con peso
            EW_GLOBAL._SetVariable("wl_cajas", true); // Activamos trabajar con peso

            _llPeso = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_Peso"));

            EW_GLOBAL._SetVariable("wl_CosteLin", false); //presentar coste total por linea

            configurarDatos();
        }

        //
        //Use ClassCleanup para ejecutar código después de haber ejecutado todas las pruebas en una clase
        [ClassCleanup()]
        public static void MyClassCleanup()
        {
            eliminarDocumentoVenta();
            eliminarSerieDocumento();

            eliminarCliente();

            eliminarArticulos();
            eliminarTipoIVA();
            elminarCuentasTipoIVA();
            eliminarFamilia();
            eliminarCuentasFamilia();

            if (_cUsuario != "SUPERVISOR")
                EW_GLOBAL.ValorEnClave_VarGlob("wc_usuario", _cUsuario);
        }

        //Use TestInitialize para ejecutar código antes de ejecutar cada prueba
        //[TestInitialize()]
        //public void MyTestInitialize()
        //{
        //}

        //Use TestCleanup para ejecutar código después de que se hayan ejecutado todas las pruebas
        //[TestCleanup()]
        //public void MyTestCleanup()
        //{
        //}
        #endregion Métodos públicos de inicialización / clean del test

        #region Test

        private void testBeneficioCoste(string tcArticulo)
        {
            bool llOk = string.IsNullOrWhiteSpace(_cMensaje_Error);

            ArticuloBeneficio loArticuloBeneficio = _dictArticulos[tcArticulo];

            decimal lnCosteUnitarioBeneficioExpected = loArticuloBeneficio._CosteUnitarioBeneficioExpected;
            decimal lnCosteLineaBeneficioExpected = loArticuloBeneficio._CosteLineaBeneficioExpected;
            decimal lnPorcenBeneficioExpected = loArticuloBeneficio._PorcenBeneficioExpected;

            decimal lnCosteUnitarioBeneficio = 0;
            decimal lnCosteLineaBeneficio = 0;
            decimal lnPorcenBeneficioLinea = 0;

            if (llOk)
                CalculoBeneficio(ref lnCosteUnitarioBeneficio, ref lnCosteLineaBeneficio, ref lnPorcenBeneficioLinea, loArticuloBeneficio._Codigo);

            if (!llOk)
                Assert.Fail($"Se ha producido un error al crear los mantenimientos y documentos necesarios para la validación del test. Se cancela la ejecución del test que gestiona el % de beneficio de los documentos de venta. {_cMensaje_Error}");
            else
            {
                Assert.AreEqual(lnCosteUnitarioBeneficio, lnCosteUnitarioBeneficioExpected, $"El coste unitario del beneficio de la línea del artículo {tcArticulo} no es el esperado. ({loArticuloBeneficio._Nombre}");
                Assert.AreEqual(lnCosteLineaBeneficio, lnCosteLineaBeneficioExpected, $"El coste lineal del beneficio del la línea del artículo {tcArticulo} no es el esperado. ({loArticuloBeneficio._Nombre}");
                Assert.AreEqual(lnPorcenBeneficioLinea, lnPorcenBeneficioExpected, $"El % de beneficio del la línea del artículo {tcArticulo} no es el esperado. ({loArticuloBeneficio._Nombre}");
            }
        }

        private void testBeneficioCosteTotalDocumento()
        {
            bool llOk = string.IsNullOrWhiteSpace(_cMensaje_Error);

            decimal lnCosteTotal = 0, lnCosteTotalDocumento = 0, lnBeneficioTotal = 0, lnTotalBeneficioDocumento = 0, lnPorcenBeneficioDocumento = 0;
            decimal lnCosteTotalExpected = 0 ;

            // De momento estos valores lo dejamos prefijados
            decimal lnBeneficioTotalExpected = 52558;
            decimal lnPorcenBeneficioDocumentoExpected = 80;


            lnBeneficioTotal = _oewDocVentaTPV._Beneficio_doc(out lnCosteTotal);

            lnCosteTotalExpected = _dictArticulos.AsEnumerable().Select(art => string.IsNullOrWhiteSpace(art.Value._Codigo) ? 0 : art.Value._CosteLineaBeneficioExpected).Sum();

            lnTotalBeneficioDocumento = _oewDocVentaTPV._Beneficio_doc(out lnCosteTotalDocumento);

            lnPorcenBeneficioDocumento = _oewDocVentaTPV._PorcentajeBeneficio_doc(lnTotalBeneficioDocumento);

            lnPorcenBeneficioDocumento = new ewMascara(Convert.ToString(EW_GLOBAL._GetMascara(KeyDiccionarioMascara.wc_tpc))).Redondeo(lnPorcenBeneficioDocumento);
            

            if (!llOk)
                Assert.Fail($"Se ha producido un error al crear los mantenimientos y documentos necesarios para la validación del test. Se cancela la ejecución del test que gestiona el % de beneficio de los documentos de venta. {_cMensaje_Error}");
            else
            {
                Assert.AreEqual(lnCosteTotal, lnCosteTotalExpected, $"El coste total del documento no es el esperado.");
                Assert.AreEqual(lnBeneficioTotal, lnBeneficioTotalExpected, $"El beneficio total del documento no es el esperado.");
                Assert.AreEqual(lnPorcenBeneficioDocumento, lnPorcenBeneficioDocumentoExpected, $"El % de beneficio total del documento no es el esperado.");
            }
        }

        [Owner(Owners.Diego_Martinez),
        TestMethod(),
        Description("Prueba 1 del UserControl que gestiona el % de Beneficio (ctDocBeneficio). " +
                    "Artículo PES: articulo que trabaja con PESO - Tipo PVP por UNIDADES")]
        [Priority(2)]
        public void Beneficio_Articulo_SoloPeso()
        {
            testBeneficioCoste(_cArticuloPeso);
        }

        [Owner(Owners.Diego_Martinez),
        TestMethod(),
        Description("Prueba 2 del UserControl que gestiona el % de Beneficio (ctDocBeneficio). " +
                    "Artículo CAJPES: artículo que trabaja con PESO, CAJAS y Tipo PVP por UNIDADES")]
        [Priority(2)]
        public void Beneficio_Articulo_Cajas_Peso_TipoPVPUnidades()
        {
            testBeneficioCoste(_cArticuloCajaPeso);
        }

        [Owner(Owners.Diego_Martinez),
        TestMethod(),
        Description("Prueba 3 del UserControl que gestiona el % de Beneficio (ctDocBeneficio). " +
                    "Artículo CAJPESPC: artículo que trabaja con PESO, CAJAS y Tipo PVP por CAJAS")]
        [Priority(2)]
        public void Beneficio_Articulo_Cajas_Peso_TipoPVPCajas()
        {
            testBeneficioCoste(_cArticuloCajaPesoPVPPorCaja);
        }

        [Owner(Owners.Diego_Martinez),
        TestMethod(),
        Description("Prueba 4 del UserControl que gestiona el % de Beneficio (ctDocBeneficio). " +
                    "Artículo CAJ: artículo que trabaja con CAJAS (1) - Tipo PVP por UNIDADES")]
        [Priority(2)]
        public void Beneficio_Articulo_Cajas_TipoPVPUnidades()
        {
            testBeneficioCoste(_cArticuloCaja);
        }

        [Owner(Owners.Diego_Martinez),
        TestMethod(),
        Description("Prueba 5 del UserControl que gestiona el % de Beneficio (ctDocBeneficio). " +
                    "Artículo CAJ: artículo que trabaja con CAJAS (1) - Tipo PVP por CAJAS")]
        [Priority(2)]
        public void Beneficio_Articulo_Cajas_TipoPVPCajas()
        {
            testBeneficioCoste(_cArticuloCajaPVPPorCaja);
        }

        [Owner(Owners.Diego_Martinez),
        TestMethod(),
        Description("Prueba 6 del UserControl que gestiona el % de Beneficio (ctDocBeneficio). " +
                    "Artículo CAJ: artículo que trabaja con CAJAS (1) - Tipo PVP por MIL")]
        [Priority(2)]
        public void Beneficio_Articulo_Cajas_TipoPVPPorMil()
        {
            testBeneficioCoste(_cArticuloCajaPVPPorMil);
        }

        [Owner(Owners.Diego_Martinez),
        TestMethod(),
        Description("Prueba 7 del UserControl que gestiona el % de Beneficio (ctDocBeneficio). " +
                    "Artículo CAJ: artículo que trabaja con CAJAS (10) - Tipo PVP Comprar por CAJAS vender por UNIDADES")]
        [Priority(2)]
        public void Beneficio_Articulo_Cajas_TipoPVPPorComprarCajasVenderUnidades()
        {
            testBeneficioCoste(_cArticuloCajaPVPPorComprarCajasVendUni);
        }

        [Owner(Owners.Diego_Martinez),
        TestMethod(),
        Description("Prueba 8 del UserControl que gestiona el % de Beneficio (ctDocBeneficio). " +
                    "Artículo CAJ: artículo que trabaja con CAJAS (1), PESO - Tipo PVP por CAJAS")]
        [Priority(2)]
        public void Beneficio_Articulo_Cajas_Peso_TipoPVPPorCajas_PE92678()
        {
            testBeneficioCoste(_cArticuloPE96778);
        }
        
        [Owner(Owners.Diego_Martinez),
        TestMethod(),
        Description("Prueba 9 del UserControl que gestiona el % de Beneficio (ctDocBeneficio). " +
                    "Artículo UNI: artículo solo UNIDADES, que NO trabaja con CAJAS ni PESO - Tipo PVP por UNIDADES")]
        [Priority(2)]
        public void Beneficio_Articulo_Unidades()
        {
            testBeneficioCoste(_cArticuloUnidades);
        }

        [Owner(Owners.Diego_Martinez),
        TestMethod(),
        Description("Prueba 10 del UserControl que gestiona el % de Beneficio (ctDocBeneficio). " +
                    "Cáclulo del beneficio total del documento")]
        [Priority(2)]
        public void Beneficio_TotalDocumento()
        {
            testBeneficioCosteTotalDocumento();
        }
        #endregion Test

        #region Métodos de configuración de los datos para la ejecución del test
        private static void populateArticulos()
        {
            newArticulo(_cArticuloPeso, $"Artículo {_cArticuloPeso} que trabaja con PESO (10) - Tipo PVP por UNIDADES",
                tnPeso: 10, tnPvp: 500,  // Artículo
                tnCosteVenta: 100, tnCajasVenta: 0, tnUnidadesVenta: 1, tnPesoVenta: 10, tnPrecioVenta: 500, // Valores de la venta
                tnCosteUnitarioBeneficioExpected: 1000, tnCosteLineaBeneficioExpected: 1000, tnPorcenBeneficioExpected: 80); // Valores esperados de coste/beneficio

            newArticulo(_cArticuloCajaPeso, $"Artículo {_cArticuloCajaPeso} que trabaja con CAJAS (1) y PESO (10) - Tipo PVP por UNIDADES",
                tnPeso: 10, tnUnicaja: 1, tnPvp: 500,  // Artículo
                tnCosteVenta: 100, tnCajasVenta: 5, tnUnidadesVenta: 5, tnPesoVenta: 50, tnPrecioVenta: 500, // Valores de la venta
                tnCosteUnitarioBeneficioExpected: 1000, tnCosteLineaBeneficioExpected: 5000, tnPorcenBeneficioExpected: 80); // Valores esperados de coste/beneficio

            newArticulo(_cArticuloCajaPesoPVPPorCaja, $"Artículo {_cArticuloCajaPesoPVPPorCaja} que trabaja con CAJAS (1) y PESO (10) - Tipo PVP por CAJAS",
                tnPeso: 10, tnUnicaja: 1, tnPvp: 500, tnTipo_PVP: 2,   // Artículo
                tnCosteVenta: 100, tnCajasVenta: 5, tnUnidadesVenta: 5, tnPesoVenta: 50, tnPrecioVenta: 500, // Valores de la venta
                tnCosteUnitarioBeneficioExpected: 100, tnCosteLineaBeneficioExpected: 500, tnPorcenBeneficioExpected: 80); // Valores esperados de coste/beneficio

            newArticulo(_cArticuloCaja, $"Artículo {_cArticuloCaja} que trabaja con CAJAS (1) - Tipo PVP por UNIDADES",
                tnUnicaja: 2, tnPvp: 500, tnTipo_PVP: 1,   // Artículo
                tnCosteVenta: 100, tnCajasVenta: 1, tnUnidadesVenta: 2, tnPrecioVenta: 500, // Valores de la venta
                tnCosteUnitarioBeneficioExpected: 100, tnCosteLineaBeneficioExpected: 200, tnPorcenBeneficioExpected: 80); // Valores esperados de coste/beneficio

            newArticulo(_cArticuloCajaPVPPorCaja, $"Artículo {_cArticuloCajaPVPPorCaja} que trabaja con CAJAS (2) - Tipo PVP por CAJAS",
                tnUnicaja: 2, tnPvp: 500, tnTipo_PVP: 2,  // Artículo
                tnCosteVenta: 50, tnCajasVenta: 1, tnUnidadesVenta: 2, tnPrecioVenta: 500, // Valores de la venta
                tnCosteUnitarioBeneficioExpected: 50, tnCosteLineaBeneficioExpected: 100, tnPorcenBeneficioExpected: 80); // Valores esperados de coste/beneficio

            newArticulo(_cArticuloCajaPVPPorMil, $"Artículo {_cArticuloCajaPVPPorMil} que trabaja con CAJAS (2) - Tipo PVP por MIL",
                tnUnicaja: 2, tnPvp: 500, tnTipo_PVP: 4,  // Artículo
                tnCosteVenta: 1, tnCajasVenta: 500, tnUnidadesVenta: 1000, tnPrecioVenta: 5000, // Valores de la venta
                tnCosteUnitarioBeneficioExpected: 1, tnCosteLineaBeneficioExpected: 1000, tnPorcenBeneficioExpected: 80); // Valores esperados de coste/beneficio

            newArticulo(_cArticuloCajaPVPPorComprarCajasVendUni, $"Artículo {_cArticuloCajaPVPPorComprarCajasVendUni} que trabaja con CAJAS (10) - Tipo PVP Comprar por CAJAS vender por UNIDADES",
                tnUnicaja: 10, tnPvp: 500, tnTipo_PVP: 3,  // Artículo
                tnCosteVenta: 100, tnCajasVenta: 5, tnUnidadesVenta: 50, tnPrecioVenta: 500, // Valores de la venta
                tnCosteUnitarioBeneficioExpected: 100, tnCosteLineaBeneficioExpected: 5000, tnPorcenBeneficioExpected: 80); // Valores esperados de coste/beneficio

            newArticulo(_cArticuloPE96778, $"Artículo {_cArticuloPE96778} que trabaja con CAJAS (1) y PESO (2) - Tipo PVP por CAJAS",
                tnUnicaja: 1, tnPeso: 2, tnPvp: 100, tnTipo_PVP: 2,  // Artículo
                tnCosteVenta: 21, tnCajasVenta: 2, tnPesoVenta: 4, tnUnidadesVenta: 2, tnPrecioVenta: 100, // Valores de la venta
                tnCosteUnitarioBeneficioExpected: 21, tnCosteLineaBeneficioExpected: 42, tnPorcenBeneficioExpected: 79); // Valores esperados de coste/beneficio

            newArticulo(_cArticuloUnidades, $"Artículo {_cArticuloUnidades} que NO trabaja con CAJAS ni PESO - Tipo PVP por UNIDADES",
                tnPeso: 0, tnUnicaja: 0, tnPvp: 500,  // Artículo
                tnCosteVenta: 100, tnCajasVenta: 0, tnUnidadesVenta: 3, tnPesoVenta: 0, tnPrecioVenta: 500, // Valores de la venta
                tnCosteUnitarioBeneficioExpected: 100, tnCosteLineaBeneficioExpected: 300, tnPorcenBeneficioExpected: 80); // Valores esperados de coste/beneficio
        }

        private void CalculoBeneficio(ref decimal tnCosteUnitarioBeneficio, ref decimal tnCosteLineaBeneficio, ref decimal tnPorcenBeneficioLinea, string tcArticulo)
        {
            // Porcentaje de beneficio
            List<IDocVentaLin> lstLineas = _oewDocVentaTPV._Lineas.Where(lin => lin._Articulo == tcArticulo).ToList<IDocVentaLin>(); // .ConvertAll<IDocVentaLin>(lnLin => (IDocVentaLin)lnLin);

            if (lstLineas.Count > 0)
            {
                ewDocVentaLin loLinea = (ewDocVentaLin)lstLineas.First(); // IDocVentaLin

                // Asignamos los valores del beneficio
                tnCosteUnitarioBeneficio = loLinea._BeneficioCosteUnitario();
                tnCosteLineaBeneficio = loLinea._BeneficioCosteLinea();

                // Asignamos el tanto de Porcentaje de beneficio de la línea
                tnPorcenBeneficioLinea = loLinea._BeneficioPorcentajeLinea();

                tnPorcenBeneficioLinea = new ewMascara(Convert.ToString(EW_GLOBAL._GetMascara(KeyDiccionarioMascara.wc_tpc))).Redondeo(tnPorcenBeneficioLinea);
            }
            else
                _cMensaje_Error = $"No se ha encontrado el artículo {tcArticulo} en el albarán de venta";
        }

        private static void configurarDatos()
        {
            populateArticulos();

            configurarSerieDocumento();

            configurarCuentasTipoIVA();
            configurarTipoIVA();

            configurarCliente();

            configurarFamilia();
            configurarArticulos();

            crearAlbaranVenta();
        }

        private static bool crearAlbaranVenta()
        {
            bool llOk = false;

            _oewDocVentaTPV = new ewDocVentaTPV();

            _oewDocVentaTPV._Letra = _cSerie;
            _oewDocVentaTPV._Cabecera._Cliente = _cCliente;
            _oewDocVentaTPV._Cabecera._FormaPago = _cFormaPago; ;
            _oewDocVentaTPV._Save();

            if (_oewDocVentaTPV._New(_Empresa, _cSerie))
            {
                _cAlbaranVenta = _oewDocVentaTPV._Numero;

                foreach (KeyValuePair<string, ArticuloBeneficio> loArticulo in _dictArticulos)
                {
                    ArticuloBeneficio loArticuloBeneficio = loArticulo.Value;

                    ewDocVentaLin loLin = _oewDocVentaTPV._AddLinea();
                    loLin._Articulo = loArticuloBeneficio._Codigo;
                    loLin._TipoIva = _cTipoIVA;

                    if (loArticuloBeneficio._CajasVenta != 0)
                        loLin._Cajas = loArticuloBeneficio._CajasVenta;

                    loLin._Unidades = loArticuloBeneficio._UnidadesVenta;

                    if (loArticuloBeneficio._PesoVenta != 0)
                        loLin._Peso = loArticuloBeneficio._PesoVenta;

                    loLin._Coste = loArticuloBeneficio._CosteVenta;
                    loLin._Precio = loArticuloBeneficio._PrecioVenta;
                }

                llOk = _oewDocVentaTPV._Save();
            }

            return llOk;
        }

        private static ArticuloBeneficio newArticulo(string tcArticulo, string tcNombre, decimal tnUnicaja = 0, decimal tnPeso = 0, int tnTipo_PVP = 1, decimal tnPvp = 0,
                decimal tnCajasVenta = 0, decimal tnUnidadesVenta = 1, decimal tnPesoVenta = 0, decimal tnCosteVenta = 0, decimal tnPrecioVenta = 0,
                decimal tnCosteUnitarioBeneficioExpected = 0, decimal tnCosteLineaBeneficioExpected = 0, decimal tnPorcenBeneficioExpected = 0)
        {

            if (_dictArticulos.ContainsKey(tcArticulo))
                return _dictArticulos[tcArticulo];
            else
            {
                ArticuloBeneficio loArticuloBeneficio = new ArticuloBeneficio(tcArticulo, tcNombre, tnUnicaja, tnPeso, tnTipo_PVP, tnPvp,
                        tnCajasVenta, tnUnidadesVenta, tnPesoVenta, tnCosteVenta, tnPrecioVenta,
                        tnCosteUnitarioBeneficioExpected, tnCosteLineaBeneficioExpected, tnPorcenBeneficioExpected);

                _dictArticulos.Add(tcArticulo, loArticuloBeneficio);

                return loArticuloBeneficio;
            }
        }

        private static bool configurarArticulos()
        {
            bool llOk = true;

            foreach (KeyValuePair<string, ArticuloBeneficio> loArticulo in _dictArticulos)
            {
                ArticuloBeneficio loArticuloBeneficio = loArticulo.Value;

                llOk = llOk && configurarArticulo(loArticuloBeneficio);
            }

            return llOk;
        }

        private static bool configurarArticulo(ArticuloBeneficio toArticuloBeneficio)
        {
            bool llOk = false;

            using (Articulo loArticulo = new Articulo())
            {
                loArticulo._Codigo = toArticuloBeneficio._Codigo;

                if (!loArticulo._Existe_Registro())
                {
                    loArticulo._New(toArticuloBeneficio._Codigo);
                }

                loArticulo._Nombre = toArticuloBeneficio._Nombre;
                loArticulo._Familia = _cFamilia;
                loArticulo._Tipo_Iva = _cTipoIVA;

                loArticulo._Peso = toArticuloBeneficio._Peso;
                loArticulo._Unicaja = toArticuloBeneficio._Unicaja;
                loArticulo._Tipo_PVP = toArticuloBeneficio._Tipo_PVP;

                llOk = loArticulo._Save();

                if (!llOk)
                    _cMensaje_Error = $"Se ha producido un error al crear el artículo {toArticuloBeneficio._Codigo}. {loArticulo._Error_Message}";
            }

            return llOk;
        }

        private static void configurarSerieDocumento()
        {
            eliminarSerieDocumento();

            using (Letras loLetras = new Letras())
            {
                loLetras._Codigo = _cSerie;

                if (!loLetras._Existe_Registro())
                    loLetras._Codigo = _cSerie;

                loLetras._Nombre = "Serie pruebas coste beneficio de documentos de venta";
                loLetras._Save();
            }
        }

        private static void configurarCliente()
        {
            using (sage.ew.cliente.Cliente loCliente = new sage.ew.cliente.Cliente())
            {
                loCliente._Codigo = _cCliente;

                if (!loCliente._Existe_Registro())
                    loCliente._New(_cCliente, "Cliente " + _cCliente + " para pruebas");

                loCliente._Nombre = "Cliente " + _cCliente + " para pruebas";
                loCliente._Pais = _Pais;
                loCliente._Moneda = _Moneda;
                loCliente._ProntoPago = 0;
                loCliente._RECC = false;
                loCliente._Recargo = false;
                loCliente._RetencionFiscal = false;
                loCliente._TipoIVA = "";
                loCliente._TipoCliente = sage.ew.cliente.Cliente.TipoCliente.Nacional;

                bool llOk = loCliente._Save();
            }
        }

        private static void configurarTipoIVA()
        {
            bool llOk = false;

            using (TipoIVA loTipoIva = new TipoIVA())
            {
                loTipoIva._Codigo = _cTipoIVA;
                if (!loTipoIva._Existe_Registro())
                {
                    loTipoIva._New(loTipoIva._Codigo);
                    loTipoIva._Codigo = _cTipoIVA;
                }

                loTipoIva._Nombre = "IVA 21% (5,2%) ";
                loTipoIva._IVA = 21;
                loTipoIva._Recargo = 5.2M;
                loTipoIva._Cta_IVA_Rep = "47700190";
                loTipoIva._Cta_IVA_Sop = "47200190";
                loTipoIva._Cta_REC_Rep = "47700191";
                loTipoIva._Cta_REC_Sop = "47200191";

                loTipoIva._Pendevrep = "47710180";
                loTipoIva._Recrepcdev = "47710195";
                loTipoIva._Pendedsop = "47210180";
                loTipoIva._Recsopcdev = "47210195";

                loTipoIva._Cta_IVA_Sop_Nodeduc = "47200170";
                loTipoIva._Pendedsop_Nodeduc = "47210171";

                loTipoIva._IVA_Deducible = true;
                loTipoIva._IVA_Exento = false;

                loTipoIva._Tipo = TipoIVA.TipoImpuesto.IVA;

                llOk = loTipoIva._Save();
            }
        }

        private static bool configurarFamilia()
        {
            bool llOk = true;

            configurarCuentaContable(_cCtaCompraFamilia, $"CUENTA DE COMPRAS DE LA FAMILIA {_cFamilia}");
            configurarCuentaContable(_cCtaVentaFamilia, $"CUENTA DE VENTAS DE LA FAMILIA {_cCtaVentaFamilia}");

            using (Familia loFamilia = new Familia())
            {
                loFamilia._Codigo = _cFamilia;

                if (!loFamilia._Existe_Registro())
                {
                    loFamilia._New(_cFamilia);
                }

                loFamilia._Nombre = "FAMILIA TEST CÁLCULO DE COSTE BENEFICIO";
                loFamilia._CtaCompra = _cCtaCompraFamilia;
                loFamilia._CtaVenta = _cCtaVentaFamilia;

                llOk = loFamilia._Save();
            }

            return llOk;
        }

        private static bool configurarCuentaContable(string tcCodigo, string tcNombre)
        {
            bool llOk = true;

            using (Cuenta loCuenta = new Cuenta())
            {
                loCuenta._Codigo = tcCodigo;
                if (!loCuenta._Existe_Registro())
                    llOk = loCuenta._New(tcCodigo, tcNombre);
            }

            return llOk;
        }

        private static bool configurarCuentasTipoIVA()
        {
            bool llOk = true;

            llOk = configurarCuentaContable("47700190", "IVA REPERCUTIDOO ");
            llOk = llOk && configurarCuentaContable("47200190", "IVA SOPORTADO");

            llOk = llOk && configurarCuentaContable("47700191", "RECARGO REPERCUTIDO");
            llOk = llOk && configurarCuentaContable("47200191", "RECARGO SOPORTADO");

            llOk = llOk && configurarCuentaContable("47710180", "CUENTA _Pendevrep");
            llOk = llOk && configurarCuentaContable("47710195", "CUENTA _Recrepcdev");

            llOk = llOk && configurarCuentaContable("47210180", "CUENTA _Pendedsop");
            llOk = llOk && configurarCuentaContable("47210195", "CUENTA _Recsopcdev");

            llOk = llOk && configurarCuentaContable("47200170", "CUENTA _Cta_IVA_Sop_Nodeduc");
            llOk = llOk && configurarCuentaContable("47210171", "CUENTA _Pendedsop_Nodeduc");

            return llOk;
        }

        #endregion Métodos de configuración de los datos para la ejecución del test

        #region Borrado de datos del Test
        private static void eliminarCliente()
        {
            using (sage.ew.cliente.Cliente loCliente = new sage.ew.cliente.Cliente())
            {
                loCliente._Codigo = _cCliente;

                if (loCliente._Existe_Registro())
                {
                    bool llOk = loCliente._Delete();
                }
            }
        }

        private static void eliminarDocumentoVenta()
        {
            using (ewDocVentaTPV loDocVenta = new ewDocVentaTPV())
            {
                bool llOk = loDocVenta._Load(_Empresa, _cAlbaranVenta, _cSerie);

                llOk = llOk && loDocVenta._Delete();
            }
        }

        private static void eliminarSerieDocumento()
        {
            using (Letras loLetras = new Letras())
            {
                loLetras._Codigo = _cSerie;

                if (loLetras._Existe_Registro())
                {
                    bool llOk = loLetras._Delete();
                }
            }
        }

        private static void eliminarTipoIVA()
        {
            using (TipoIVA loTipoIVA = new TipoIVA())
            {
                loTipoIVA._Codigo = _cTipoIVA;

                if (loTipoIVA._Existe_Registro())
                {
                    bool llOK = loTipoIVA._Delete();
                }
            }
        }

        private static void eliminarFamilia()
        {
            using (Familia loFamilia = new Familia())
            {
                loFamilia._Codigo = _cTipoIVA;

                if (loFamilia._Existe_Registro())
                {
                    bool llOK = loFamilia._Delete();
                }
            }
        }

        private static void eliminarArticulos()
        {
            foreach (KeyValuePair<string, ArticuloBeneficio> loArticulo in _dictArticulos)
            {
                ArticuloBeneficio loArticuloBeneficio = loArticulo.Value;

                eliminarArticulo(loArticuloBeneficio._Codigo);
            }
        }

        private static void eliminarArticulo(string tcCodigo)
        {
            using (Articulo loArticulo = new Articulo())
            {
                loArticulo._Codigo = tcCodigo;

                if (loArticulo._Existe_Registro())
                {
                    bool llOK = loArticulo._Delete();
                }
            }
        }

        private static bool eliminarCuentaTipoIVA(string tcCodigo)
        {
            bool llOk = true;

            using (Cuenta loCuenta = new Cuenta())
            {
                loCuenta._Codigo = tcCodigo;
                if (loCuenta._Existe_Registro())
                    loCuenta._Delete();
            }

            return llOk;
        }

        private static void elminarCuentasTipoIVA()
        {
            eliminarCuentaTipoIVA("47700190");
            eliminarCuentaTipoIVA("47200190");

            eliminarCuentaTipoIVA("47700191");
            eliminarCuentaTipoIVA("47200191");

            eliminarCuentaTipoIVA("47710180");
            eliminarCuentaTipoIVA("47710195");

            eliminarCuentaTipoIVA("47210180");
            eliminarCuentaTipoIVA("47210195");

            eliminarCuentaTipoIVA("47200170");
            eliminarCuentaTipoIVA("47210171");
        }

        private static void eliminarCuentasFamilia()
        {
            eliminarCuentaTipoIVA(_cCtaCompraFamilia);
            eliminarCuentaTipoIVA(_cCtaVentaFamilia);
        }
        #endregion Borrado de datos del Test

        #region Clase para poder gestionar con más facilidad la creación de artículo y el flujo del test
        private class ArticuloBeneficio
        {
            public string _Codigo { get; set; }

            public string _Nombre { get; set; }

            public decimal _Peso { get; set; }

            public decimal _Unicaja { get; set; }

            public int _Tipo_PVP { get; set; }

            public decimal _Pvp { get; set; }

            public decimal _UnidadesVenta { get; set; }

            public decimal _CajasVenta { get; set; }

            public decimal _PesoVenta { get; set; }

            public decimal _PrecioVenta { get; set; }

            public decimal _CosteVenta { get; set; }

            public decimal _CosteUnitarioBeneficioExpected { get; set; }

            public decimal _CosteLineaBeneficioExpected { get; set; }

            public decimal _PorcenBeneficioExpected { get; set; }

            public ArticuloBeneficio(string tcArticulo, string tcNombre, decimal tnUnicaja, decimal tnPeso, int tnTipo_PVP, decimal tnPvp,
                decimal tnCajasVenta, decimal tnUnidadesVenta, decimal tnPesoVenta, decimal tnCosteVenta, decimal tnPrecioVenta,
                decimal tnCosteUnitarioBeneficioExpected, decimal tnCosteLineaBeneficioExpected, decimal tnPorcenBeneficioExpected)
            {
                _Codigo = tcArticulo;
                _Nombre = tcNombre;
                _Peso = tnPeso;
                _Unicaja = tnUnicaja;
                _Tipo_PVP = tnTipo_PVP;
                _Pvp = tnPvp;
                _CajasVenta = tnCajasVenta;
                _UnidadesVenta = tnUnidadesVenta;
                _PesoVenta = tnPesoVenta;
                _PrecioVenta = tnPrecioVenta;
                _CosteVenta = tnCosteVenta;
                _CosteUnitarioBeneficioExpected = tnCosteUnitarioBeneficioExpected;
                _CosteLineaBeneficioExpected = tnCosteLineaBeneficioExpected;
                _PorcenBeneficioExpected = tnPorcenBeneficioExpected;
            }
        }

        #endregion Clase para poder gestionar con más facilidad la creación de artículo y el flujo del test
    }
}