TraspasoSiguienteEjercicioBase.cs

using Microsoft.VisualStudio.TestTools.UnitTesting;
using sage.ew.articulo;
using sage.ew.db;
using sage.ew.ewbase;
using sage.ew.functions;
using sage.ew.global;
using Sage.ES.S50.UnitTest.Tools;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using sage.ew.cliente.Clases;
using static sage.ew.cliente.Cliente.Vacaciones;
using sage.ew.cliente;
using Sage.ES.S50.Addons;

namespace Sage.ES.S50.UnitTest
{

    public abstract class TraspasoSiguienteEjercicioBase
    {
        private TestContext testContextInstance;

        protected static string AnyOriginal { get; set; }

        protected static string AnyActual { get; set; }

        protected static string AnySiguiente { get; set; }

        protected List<Tuple<string, string>> CodigosMante = new List<Tuple<string, string>>();

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

        [ClassInitialize(), DoNotParallelize()]
        public static void MyClassInitialize(TestContext testContext)
        {
            //Conexion a Base de Datos
            testContext.__Test_LoadRandomConfig();
            //Guardamos el ejercicio original
            AnyOriginal = DB.Ejercicio_EW;
        }

        [TestInitialize(), DoNotParallelize()]
        public void MyTestInitialize()
        {
            CodigosMante.Clear();

            if (!EstablecePenultimoEjercicio()) Assert.Fail("No se puede estableer el penultimo ejercicio");
        }


        [TestCleanup(), DoNotParallelize()]
        public virtual void MyTestCleanup()
        {
            EstablecePenultimoEjercicio();

            //Eliminamos los clientes del ejercicio penultimo
            CleanMantes(CodigosMante);
            CleanPersonalize(DB.Ejercicio_EW);

            FUNCTIONS.CambiarEjercicio(DB.Ejercicio_EW, AnySiguiente);

            //Eliminamos los clientes del último ejercicio 
            CleanMantes(CodigosMante);
            CleanPersonalize(DB.Ejercicio_EW);

            CodigosMante.Clear();
        }

        protected virtual void CleanPersonalize(string ejercicio_EW)
        {

        }

        private void CleanMantes(List<Tuple<string, string>> toCodigosMante)
        {
            ewMante loMante;

            toCodigosMante.ForEach(f =>
            {
                loMante = GetMante(f.Item1);

                if (loMante is ewMante)
                {
                    loMante._Codigo = f.Item2;
                    loMante._Load();
                    loMante._Delete();
                }
            });
        }

        protected virtual ewMante GetMante(string tcTabla)
        {
            return null;
        }

        [ClassCleanup(), DoNotParallelize()]
        public static void Clean()
        {
            //Dejamos como estaba el ejercicio
            FUNCTIONS.CambiarEjercicio(DB.Ejercicio_EW, AnyOriginal);
        }

        protected void CheckCodigo(string tcAnySiguiente, string tcTabla, string tcCodigo, string tcNombre)
        {
            CheckCodigo(tcAnySiguiente, new List<string>() { tcTabla }, tcCodigo, tcNombre);
        }

        protected void CheckCodigo(string tcAny, List<string> toTabla, string tcCodigo, string tcNombre)
        {
            DataTable loDt;
            loDt = GetDataCheckCodigo(tcAny, toTabla, tcCodigo, tcNombre);

            Assert.IsTrue(loDt.Rows.Count == toTabla.Count, $"El codigo {tcCodigo} no existe en alguna de las tablas ({string.Join(", ", toTabla)}) del ejercicio siguiente.");
        }

        protected void CheckNoCodigo(string tcAny, List<string> toTabla, string tcCodigo, string tcNombre)
        {
            DataTable loDt;
            loDt = GetDataCheckCodigo(tcAny, toTabla, tcCodigo, tcNombre);

            Assert.IsTrue(loDt.Rows.Count == 0, $"El codigo {tcCodigo} existe en alguna de las tablas ({string.Join(", ", toTabla)}) del ejercicio siguiente.");
        }

        private DataTable GetDataCheckCodigo(string tcAny, List<string> toTabla, string tcCodigo, string tcNombre)
        {
            DataTable loDt = new DataTable();
            List<string> loSql = new List<string>();

            toTabla.ForEach(f =>
            {
                loSql.Add($"SELECT '{f}' as TABLA, CODIGO FROM {DB.SQLDatabase(tcAny, f)} WHERE CODIGO = {DB.SQLString(tcCodigo)} AND RTRIM(NOMBRE) = {DB.SQLString(tcNombre)} ");
            });

            DB.SQLExec(string.Join(" UNION ", loSql), ref loDt);

            return loDt;
        }

        protected string _GetCodigoNoExisteDosEjercicios(string tcTabla, string tcCodigoInicial, int tnIncremento)
        {
            string lcSQL, lcCodigo = "";
            DataTable loDt = new DataTable();

            while (string.IsNullOrEmpty(lcCodigo) || loDt.Rows.Count > 0)
            {
                lcCodigo = string.IsNullOrEmpty(lcCodigo) ? tcCodigoInicial : Convert.ToString(Convert.ToInt32(lcCodigo) + tnIncremento);

                lcSQL = $@"SELECT CODIGO FROM {DB.SQLDatabase(AnyActual, tcTabla)} WHERE CODIGO = {DB.SQLString(lcCodigo)} " +
                        $@"UNION " +
                        $@"SELECT CODIGO FROM {DB.SQLDatabase(AnySiguiente, tcTabla)} WHERE CODIGO = {DB.SQLString(lcCodigo)} ";

                if (!DB.SQLExec(lcSQL, ref loDt)) Assert.Fail($"Error al ejecutar SQL {DB.Error_Message}");
            }

            if (!CodigosMante.Any(f => f.Item1 == tcTabla && f.Item2 == lcCodigo)) CodigosMante.Add(new Tuple<string, string>(tcTabla, lcCodigo));

            return lcCodigo;
        }

        protected string _GetCodigoExisteDosEjercicios(string tcTabla)
        {
            string lcSQL;
            DataTable loDt = new DataTable();

            lcSQL = $@"SELECT TOP 1 t.CODIGO FROM {DB.SQLDatabase(AnyActual, tcTabla)} t " +
                    $@"INNER JOIN {DB.SQLDatabase(AnySiguiente, tcTabla)} i ON t.CODIGO = i.CODIGO ";

            return DB.SQLExec(lcSQL, ref loDt) && loDt.Rows.Count > 0 ? Convert.ToString(loDt.Rows[0]["CODIGO"]) : string.Empty;

        }

        protected static bool EstablecePenultimoEjercicio()
        {
            List<string> loList;

            if (DB._oAliasDBEjer.Count > 1)
            {
                AnyActual = DB.Ejercicio_EW;
                AnySiguiente = Convert.ToString(Convert.ToInt32(DB.Ejercicio_EW) + 1);

                //Estamos en el último ejercicio
                if (!DB._EsPenultimoEjercicio())
                {
                    loList = DB._oAliasDBEjer.ToList().Select(f => f.Key).OrderByDescending(f => Convert.ToInt32(f)).ToList();

                    AnyActual = loList.Skip(1).First();
                    AnySiguiente = loList.First();

                    FUNCTIONS.CambiarEjercicio(DB.Ejercicio_EW, AnyActual);

                }
            }

            return DB._EsPenultimoEjercicio();
        }

    }
}