using Exferia_Aplicacion.Modelos_Existencias;
using Exferia_Aplicacion.Modelos_Generales;
using Exferia_Aplicacion.Modelos_Informes;
using Exferia_Aplicacion.Modelos_ListadoSeleccion;
using Exferia_Controles;
using Exferia_EntityFramework;
using Exferia_Formularios;
using Gma.QrCodeNet.Encoding;
using Gma.QrCodeNet.Encoding.Windows.Render;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Mail;
using System.Net.NetworkInformation;
using System.Net.Security;
using System.Reflection;
using System.Security.AccessControl;
using System.Security.Cryptography.X509Certificates;
using System.Security.Principal;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Windows.Forms;
using static Exferia_Aplicacion.General.Enumerados;

namespace Exferia_Aplicacion.General
{
    public static class Funciones
    {
        /// <summary>
        /// Comprobación de si un string es un valor Numérico
        /// </summary>
        /// <param name="_str_Valor"></param>
        /// <returns></returns>
        public static bool IsNumeric(string _str_Valor)
        {
            float output;
            return float.TryParse(_str_Valor, out output);
        }

        /// <summary>
        /// Comprobación de si un string es un valor Long
        /// </summary>
        /// <param name="_str_Valor"></param>
        /// <returns></returns>
        public static bool IsLong(string _str_Valor)
        {
            long output;
            return long.TryParse(_str_Valor, out output);
        }

        public static bool IsDecimal(string _str_Valor)
        {
            decimal output;
            return decimal.TryParse(_str_Valor, out output);
        }

        /// <summary>
        /// Redondear un valor decimal a los decimales que se especifique
        /// </summary>
        /// <param name="_dcm_Valor"></param>
        /// <param name="_int_NumeroDecimales"></param>
        /// <returns></returns>
        public static decimal RedondearDecimal(decimal _dcm_Valor, int _int_NumeroDecimales)
        {
            return decimal.Round(_dcm_Valor, _int_NumeroDecimales, MidpointRounding.AwayFromZero);
        }

        /// <summary>
        /// Valida si la fecha es correcta o esta vacia, devolviendo un valor diferente // 0-> Correcta // 1-> Vacia // 2-> Error //
        /// </summary>
        /// <param name="_str_Fecha"></param>
        /// <returns></returns>
        public static int Fecha_Validacion(string _str_Fecha)
        {
            try
            {
                if (_str_Fecha.Trim(' ', '/') != "")
                {
                    //Saber si la Fecha de Creacion tiene un formato correcto
                    DateTime dtt_fechaValidada;
                    if (!DateTime.TryParseExact(_str_Fecha, "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out dtt_fechaValidada))
                    {
                        return 2;
                    }
                    else
                    {
                        return 0;
                    }
                }
                else
                {
                    return 1;
                }
            }
            catch
            {
                return 2;
            }
        }

        /// <summary>
        /// Valida si la hora es correcta o esta vacia, devolviendo un valor diferente // 0-> Correcta // 1-> Vacia // 2-> Error //
        /// </summary>
        /// <param name="_str_Hora"></param>
        /// <returns></returns>
        public static int Hora_Validacion(string _str_Hora)
        {
            try
            {
                if (_str_Hora.Trim(' ', ':') != "")
                {
                    //Saber si la Hora  tiene un formato correcto
                    TimeSpan tms_Validada;
                    if (!TimeSpan.TryParseExact(_str_Hora, "hh\\:mm", CultureInfo.InvariantCulture, out tms_Validada))
                    {
                        return 2;
                    }
                    else
                    {
                        return 0;
                    }
                }
                else
                {
                    return 1;
                }
            }
            catch
            {
                return 2;
            }
        }

        public static string Convertir_Fecha_A_FechaJuliana(DateTime _dtt_Fecha)
        {
            int int_Dia = _dtt_Fecha.Day;
            int int_Mes = _dtt_Fecha.Month;
            int int_Anyo = _dtt_Fecha.Year;
            int int_Hora = _dtt_Fecha.Hour;
            int int_Minuto = _dtt_Fecha.Minute;
            int int_Segundo = _dtt_Fecha.Second;
            int int_dia_Calendario_Juliano = 0;
            int int_Fecha_Juliana = 0;

            int_dia_Calendario_Juliano = (1461 * (int_Anyo + 4800 + (int_Mes - 14) / 12)) / 4 + (367 * (int_Mes - 2 - 12 * ((int_Mes - 14) / 12))) / 12 - (3 * ((int_Anyo + 4900 + (int_Mes - 14) / 12) / 100)) / 4 + int_Dia - 32075;

            int_Fecha_Juliana = int_dia_Calendario_Juliano + ((int_Hora - 12) / 24) + (int_Minuto / 1440) + (int_Segundo / 86400);

            return int_Fecha_Juliana.ToString();
        }

        public static bool Email_Validacion(string _str_Email)
        {
            if (string.IsNullOrEmpty(_str_Email))
                return true;

            string str_Expresion = "\\w+([-+.']\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*";
            if (Regex.IsMatch(_str_Email, str_Expresion))
            {
                if (Regex.Replace(_str_Email, str_Expresion, String.Empty).Length == 0)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
        }

        #region Convertir TreviewNodes a List<TreeNodes>
        public static List<TreeNode> Convertir_TreeViewNodes_A_List(TreeNodeCollection _obj_TreeNodeCollection)
        {
            List<TreeNode> lst_TreeNode = new List<TreeNode>();
            foreach (TreeNode node in ToIEnumerable(_obj_TreeNodeCollection))
                lst_TreeNode.Add(node);
            return lst_TreeNode;
        }
        public static IEnumerable<TreeNode> ToIEnumerable(TreeNodeCollection nodes)
        {
            foreach (TreeNode c1 in nodes)
            {
                yield return c1;
                foreach (TreeNode c2 in ToIEnumerable(c1.Nodes))
                {
                    yield return c2;
                }
            }
        }
        #endregion

        #region Enviar Email
        public static INTERNO_ValorDevuelto_Modelo Email_Enviar(INTERNO_EnvioEmail_Modelo _mdl_INTERNO_EnvioEmail_Modelo)
        {
            INTERNO_ValorDevuelto_Modelo mdl_INTERNO_ValorDevuelto_Modelo = new INTERNO_ValorDevuelto_Modelo();
            mdl_INTERNO_ValorDevuelto_Modelo.TodoCorrecto = true;

            try
            {
                if (_mdl_INTERNO_EnvioEmail_Modelo != null)
                {
                   
                    //Configuracion del Mensaje
                    MailMessage obj_MailMessage = new MailMessage();
                    SmtpClient obj_SmtpClient = new SmtpClient(_mdl_INTERNO_EnvioEmail_Modelo.smtp_Servidor);
                    //Especificamos el correo desde el que se enviará el Email y el nombre de la persona que lo envía
                    obj_MailMessage.From = new MailAddress(_mdl_INTERNO_EnvioEmail_Modelo.email, _mdl_INTERNO_EnvioEmail_Modelo.nombreAMostrar, Encoding.UTF8);
                    //Aqui ponemos el asunto del correo
                    obj_MailMessage.Subject = _mdl_INTERNO_EnvioEmail_Modelo.asunto;
                    //Aqui ponemos el mensaje que incluirá el correo
                    obj_MailMessage.Body = _mdl_INTERNO_EnvioEmail_Modelo.cuerpo;

                    //Expecificamos a quien enviar el Email
                    foreach (INTERNO_Email_Modelo mdl_INTERNO_Email_Modelo in _mdl_INTERNO_EnvioEmail_Modelo.emails_destino)
                    {
                        //Comprueba si tiene que enviarse con copia oculta o no(CCo)
                        if (mdl_INTERNO_Email_Modelo.Oculto)
                        {
                            obj_MailMessage.Bcc.Add(mdl_INTERNO_Email_Modelo.Email);
                        }
                        else
                        {
                            //Comprueba si tiene que enviarse con copia(CC)
                            if (mdl_INTERNO_Email_Modelo.Copia)
                            {
                                obj_MailMessage.CC.Add(mdl_INTERNO_Email_Modelo.Email);
                            }
                            else
                            {
                                obj_MailMessage.To.Add(mdl_INTERNO_Email_Modelo.Email);
                            }
                        }
                    }

                    //Si no es nulo es que se envia un PDF adjunto
                    if (_mdl_INTERNO_EnvioEmail_Modelo.ficheros != null && _mdl_INTERNO_EnvioEmail_Modelo.ficheros.Count>0)
                    {
                        foreach (INTERNO_EnvioEmail_Ficheros_Modelo mdl_INTERNO_EnvioEmail_Ficheros_Modelo in _mdl_INTERNO_EnvioEmail_Modelo.ficheros)
                        {
                            //Añadimos el array de bytes en forma de Stream
                            obj_MailMessage.Attachments.Add(new Attachment(new MemoryStream(mdl_INTERNO_EnvioEmail_Ficheros_Modelo.fichero_PDF), mdl_INTERNO_EnvioEmail_Ficheros_Modelo.nombreFichero_A_Enviar));
                        }
                    }

                    //Especificamos el puerto
                    int int_PuertoSmtp = Convert.ToInt32(_mdl_INTERNO_EnvioEmail_Modelo.smtp_Puerto);
                    int int_Puerto = 25;//Por Defecto
                    if (int_PuertoSmtp > 0)
                    {
                        int_Puerto = int_PuertoSmtp;
                    }

                    //Configuracion del SMTP
                    obj_SmtpClient.Port = int_Puerto;///Puerto que utiliza GMAIL para sus servicios

                    //Especificamos las credenciales con las que enviaremos el email
                    obj_SmtpClient.Credentials = new NetworkCredential(_mdl_INTERNO_EnvioEmail_Modelo.smtp_Usuario, _mdl_INTERNO_EnvioEmail_Modelo.smtp_Clave);
                    obj_SmtpClient.EnableSsl = _mdl_INTERNO_EnvioEmail_Modelo.smtp_ConexionSSL != null ? _mdl_INTERNO_EnvioEmail_Modelo.smtp_ConexionSSL.Value : false;


                    ServicePointManager.ServerCertificateValidationCallback =
                    delegate (object s, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
                    {
                        return true;
                    };

                    //Enviamos el Email
                    obj_SmtpClient.Send(obj_MailMessage);
                }
            }
            catch (SmtpException smtpe)
            {
                Control_Errores.Errores_Log("Email salida:" + (_mdl_INTERNO_EnvioEmail_Modelo!=null ? _mdl_INTERNO_EnvioEmail_Modelo.email : ""), smtpe, nameof(Funciones) + "/" + nameof(Email_Enviar));
                mdl_INTERNO_ValorDevuelto_Modelo.TodoCorrecto = false;
                mdl_INTERNO_ValorDevuelto_Modelo.Mensaje = smtpe.Message;
            }

            catch (Exception ex)
            {
                Control_Errores.Errores_Log("Email salida:" + (_mdl_INTERNO_EnvioEmail_Modelo != null ? _mdl_INTERNO_EnvioEmail_Modelo.email : ""), ex, nameof(Funciones) + "/" + nameof(Email_Enviar));
                mdl_INTERNO_ValorDevuelto_Modelo.TodoCorrecto = false;
                mdl_INTERNO_ValorDevuelto_Modelo.Mensaje = ex.Message;
            }

            return mdl_INTERNO_ValorDevuelto_Modelo;
        }
        #endregion

        public static bool URL_Validacion(string _str_URL)
        {
            if (string.IsNullOrEmpty(_str_URL))
                return true;

            try
            {
                return Regex.IsMatch(_str_URL,
                      @"^(ht|f)tp(s?)\:\/\/[0-9a-zA-Z]([-.\w]*[0-9a-zA-Z])*(:(0-9)*)*(\/?)( [a-zA-Z0-9\-\.\?\,\'\/\\\+&%\$#_]*)?$",
                      RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(250));
            }
            catch (RegexMatchTimeoutException)
            {
                return false;
            }
        }

        public static string Obtener_Direccion_Mac()
        {
            string str_DireccionMac = "No Encontro";

            try
            {
                List<string> lst_DireccionesMAC = new List<string>();
                NetworkInterface[] nics = NetworkInterface.GetAllNetworkInterfaces();

                foreach (NetworkInterface adapter in nics)
                {
                    if (!string.IsNullOrEmpty(adapter.GetPhysicalAddress().ToString()) && !adapter.GetPhysicalAddress().ToString().Equals("00000000000000E0", StringComparison.InvariantCultureIgnoreCase))
                    {
                        str_DireccionMac=adapter.GetPhysicalAddress().ToString();
                        break;
                    }
                }
            }
            catch (Exception)
            {}

            return str_DireccionMac.Trim();
        }
        public static string Obtener_NombreEquipo()
        {
            string str_NombreEquipo = "No Encontro";

            try
            {
                str_NombreEquipo = Environment.MachineName;
            }
            catch (Exception)
            { }

            return str_NombreEquipo.Trim();
        }

        /// <summary>
        /// Segun Fecha devuelve el dia de la semana que corresponde, empezando el lunes por el 1
        /// </summary>
        /// <param name="_dtt_Fecha"></param>
        /// <returns></returns>
        public static int Fecha_Delvolver_NumeroDiaSemana(DateTime _dtt_Fecha)
        {
            int int_DiaSemana = 1;

            //Lunes
            if (_dtt_Fecha.DayOfWeek.Equals(DayOfWeek.Monday))
            {
                int_DiaSemana = 1;
            }
            //Martes
            else if (_dtt_Fecha.DayOfWeek.Equals(DayOfWeek.Tuesday))
            {
                int_DiaSemana = 2;
            }
            //Miercoles
            else if (_dtt_Fecha.DayOfWeek.Equals(DayOfWeek.Wednesday))
            {
                int_DiaSemana = 3;
            }
            //Jueves
            else if (_dtt_Fecha.DayOfWeek.Equals(DayOfWeek.Thursday))
            {
                int_DiaSemana = 4;
            }
            //Viernes
            else if (_dtt_Fecha.DayOfWeek.Equals(DayOfWeek.Friday))
            {
                int_DiaSemana = 5;
            }
            //Sabado
            else if (_dtt_Fecha.DayOfWeek.Equals(DayOfWeek.Saturday))
            {
                int_DiaSemana = 6;
            }
            //Domingo
            else if (_dtt_Fecha.DayOfWeek.Equals(DayOfWeek.Sunday))
            {
                int_DiaSemana = 7;
            }

            return int_DiaSemana;
        }

        public static string Fecha_Delvolver_DiaSemana(DateTime _dtt_Fecha)
        {
            string str_DiaSemana = "";

            //Lunes
            if (_dtt_Fecha.DayOfWeek.Equals(DayOfWeek.Monday))
            {
                str_DiaSemana = Variables.G_STR_CALENDARIO_DIASEMANA_INICIAL_LUNES;
            }
            //Martes
            else if (_dtt_Fecha.DayOfWeek.Equals(DayOfWeek.Tuesday))
            {
                str_DiaSemana = Variables.G_STR_CALENDARIO_DIASEMANA_INICIAL_MARTES;
            }
            //Miercoles
            else if (_dtt_Fecha.DayOfWeek.Equals(DayOfWeek.Wednesday))
            {
                str_DiaSemana = Variables.G_STR_CALENDARIO_DIASEMANA_INICIAL_MIERCOLES;
            }
            //Jueves
            else if (_dtt_Fecha.DayOfWeek.Equals(DayOfWeek.Thursday))
            {
                str_DiaSemana = Variables.G_STR_CALENDARIO_DIASEMANA_INICIAL_JUEVES;
            }
            //Viernes
            else if (_dtt_Fecha.DayOfWeek.Equals(DayOfWeek.Friday))
            {
                str_DiaSemana = Variables.G_STR_CALENDARIO_DIASEMANA_INICIAL_VIERNES;
            }
            //Sabado
            else if (_dtt_Fecha.DayOfWeek.Equals(DayOfWeek.Saturday))
            {
                str_DiaSemana = Variables.G_STR_CALENDARIO_DIASEMANA_INICIAL_SABADO;
            }
            //Domingo
            else if (_dtt_Fecha.DayOfWeek.Equals(DayOfWeek.Sunday))
            {
                str_DiaSemana = Variables.G_STR_CALENDARIO_DIASEMANA_INICIAL_DOMINGO;
            }

            return str_DiaSemana;
        }

        public static string Fecha_Delvolver_DiaSemana_Texto(DateTime _dtt_Fecha)
        {
            string str_DiaSemana = "";

            //Lunes
            if (_dtt_Fecha.DayOfWeek.Equals(DayOfWeek.Monday))
            {
                str_DiaSemana = Variables.G_STR_CALENDARIO_DIASEMANA_LUNES;
            }
            //Martes
            else if (_dtt_Fecha.DayOfWeek.Equals(DayOfWeek.Tuesday))
            {
                str_DiaSemana = Variables.G_STR_CALENDARIO_DIASEMANA_MARTES;
            }
            //Miercoles
            else if (_dtt_Fecha.DayOfWeek.Equals(DayOfWeek.Wednesday))
            {
                str_DiaSemana = Variables.G_STR_CALENDARIO_DIASEMANA_MIERCOLES;
            }
            //Jueves
            else if (_dtt_Fecha.DayOfWeek.Equals(DayOfWeek.Thursday))
            {
                str_DiaSemana = Variables.G_STR_CALENDARIO_DIASEMANA_JUEVES;
            }
            //Viernes
            else if (_dtt_Fecha.DayOfWeek.Equals(DayOfWeek.Friday))
            {
                str_DiaSemana = Variables.G_STR_CALENDARIO_DIASEMANA_VIERNES;
            }
            //Sabado
            else if (_dtt_Fecha.DayOfWeek.Equals(DayOfWeek.Saturday))
            {
                str_DiaSemana = Variables.G_STR_CALENDARIO_DIASEMANA_SABADO;
            }
            //Domingo
            else if (_dtt_Fecha.DayOfWeek.Equals(DayOfWeek.Sunday))
            {
                str_DiaSemana = Variables.G_STR_CALENDARIO_DIASEMANA_DOMINGO;
            }

            return str_DiaSemana;
        }

        public static string Fecha_Delvolver_FechaLarga(DateTime _dtt_Fecha)
        {
            return Fecha_Delvolver_DiaSemana_Texto(_dtt_Fecha) + "," + _dtt_Fecha.ToString("dd") + " de " + _dtt_Fecha.ToString("MMMM") + " de " + _dtt_Fecha.ToString("yyyy");
        }

        /// <summary>
        /// Convertir un objeto COLOR en string "Hexadecimal"
        /// </summary>
        /// <param name="_clr_Valor"></param>
        /// <returns></returns>
        public static string Convertir_Color_Hexadecimal(Color _clr_Valor)
        {
            return "#" + _clr_Valor.R.ToString("X2") + _clr_Valor.G.ToString("X2") + _clr_Valor.B.ToString("X2");
        }

        /// <summary>
        /// Convertir un objeto IMAGE en byte[]
        /// </summary>
        /// <param name="_img_Valor"></param>
        /// <returns></returns>
        public static byte[] Convertir_Image_Arraybytes(System.Drawing.Image _img_Valor)
        {
            MemoryStream obj_MemoryStream = new MemoryStream();
            _img_Valor.Save(obj_MemoryStream, System.Drawing.Imaging.ImageFormat.Png);
            return obj_MemoryStream.ToArray();
        }

        /// <summary>
        ///  Convertir un objeto byte[] en IMAGE
        /// </summary>
        /// <param name="_arrbytes"></param>
        /// <returns></returns>
        public static Image Convertir_Arraybytes_Image(byte[] _arr_bytes)
        {
            MemoryStream ms = new MemoryStream(_arr_bytes);
            Image returnImage = Image.FromStream(ms);
            return returnImage;
        }

        /// <summary>
        /// Convertir un Fichero fisicoa un string de Base 64
        /// </summary>
        /// <param name="_str_Ruta"></param>
        /// <returns></returns>
        public static string Convertir_Documento_Base64(string _str_Ruta)
        {
            string base64String = "";
            try
            {
                Byte[] bytes = File.ReadAllBytes(_str_Ruta);
                base64String = Convert.ToBase64String(bytes);
            }
            catch (Exception)
            { }

            return base64String;
        }

        /// <summary>
        /// Convertir un Fichero(string) en Base64 a un fichero fisico, y grbarlo en una ruta
        /// </summary>
        /// <param name="_str_Base64"></param>
        /// <param name="_str_RutaFicherosTemporales"></param>
        /// <returns></returns>
        public static string Convertir_Base64_Documento(string _str_Base64, string _str_RutaFicherosTemporales)
        {
            try
            {
                Conceder_Permisos_Carpeta(Application.StartupPath);

                Byte[] bytes = Convert.FromBase64String(_str_Base64);
                File.WriteAllBytes(_str_RutaFicherosTemporales, bytes);
            }
            catch (Exception)
            { }

            return _str_RutaFicherosTemporales;
        }

        /// <summary>
        /// Cambiar un Color de una Imagen Bitmap
        /// </summary>
        /// <param name="_bmp_ACambiar"></param>
        /// <param name="_clr_Viejo"></param>
        /// <param name="_clr_Nuevo"></param>
        /// <returns></returns>
        public static Bitmap Bitmap_CambiarColor(Bitmap _bmp_ACambiar, Color _clr_Viejo, Color _clr_Nuevo)
        {
            Color clr_Actual;

            //Creamos un bitmap en blanco con el tamaño de _bmp_ACambiar
            Bitmap bmp_nuevo = new Bitmap(_bmp_ACambiar.Width, _bmp_ACambiar.Height);
            for (int i = 0; i < _bmp_ACambiar.Width; i++)
            {
                for (int j = 0; j < _bmp_ACambiar.Height; j++)
                {
                    //obtener los pìxeles desde la image de _bmp_ACambiar
                    clr_Actual = _bmp_ACambiar.GetPixel(i, j);
                    // > 150 because.. Images edges can be of low pixel colr. if we set all pixel color to new then there will be no smoothness left.
                    if (clr_Actual.R == _clr_Viejo.R &&
                        clr_Actual.G == _clr_Viejo.G &&
                        clr_Actual.B == _clr_Viejo.B &&
                         clr_Actual.A > 150)
                        bmp_nuevo.SetPixel(i, j, _clr_Nuevo);
                    else
                        bmp_nuevo.SetPixel(i, j, clr_Actual);
                }
            }
            return bmp_nuevo;
        }

        /// <summary>
        /// Cambiar los colores de un bitmap a escala de grises
        /// </summary>
        /// <param name="_bmp_Original"></param>
        /// <returns></returns>
        public static Bitmap Bitmap_EscalaGrises(Bitmap _bmp_Original)
        {
            //create a blank bitmap the same size as original
            Bitmap bmp_Nueva = new Bitmap(_bmp_Original.Width, _bmp_Original.Height);

            //get a graphics object from the new image
            Graphics obj_Graphics = Graphics.FromImage(bmp_Nueva);

            //create the grayscale ColorMatrix
            ColorMatrix colorMatrix = new ColorMatrix(
                new float[][]
                {
                    new float[] {.3f, .3f, .3f, 0, 0},
                    new float[] {.59f, .59f, .59f, 0, 0},
                    new float[] {.11f, .11f, .11f, 0, 0},
                    new float[] {.1f, .1f, .1f, 1, 0}, //En .1f en vez de 0 para hacerla mas clara ..para oscurecer mas se puede dar valores negativos
				    new float[] {0, 0, 0, 0, 1}
                }
            );

            //create some image attributes
            ImageAttributes attributes = new ImageAttributes();

            //set the color matrix attribute
            attributes.SetColorMatrix(colorMatrix);

            //draw the original image on the new image
            //using the grayscale color matrix
            obj_Graphics.DrawImage(_bmp_Original, new Rectangle(0, 0, _bmp_Original.Width, _bmp_Original.Height), 0, 0, _bmp_Original.Width, _bmp_Original.Height, GraphicsUnit.Pixel, attributes);

            //dispose the Graphics object
            obj_Graphics.Dispose();
            return bmp_Nueva;
        }

        /// <summary>
        /// Poner un Borde a una Imagen bitmap
        /// </summary>
        /// <param name="_bmp_Valor"></param>
        /// <param name="_clr_ColorBorde"></param>
        /// <param name="_flt_AnchoBorde"></param>
        /// <returns></returns>
        public static Bitmap Bitmap_PonerBorde(Bitmap _bmp_Valor, Color _clr_ColorBorde, float _flt_AnchoBorde)
        {
            Image bmp_Original = _bmp_Valor;
            Image bmp_Modificada = _bmp_Valor;

            Bitmap bmPhoto = new Bitmap(bmp_Original.Width, bmp_Original.Height, PixelFormat.Format24bppRgb);
            Graphics grPhoto = Graphics.FromImage(bmPhoto);
            grPhoto.SmoothingMode = SmoothingMode.AntiAlias;
            grPhoto.InterpolationMode = InterpolationMode.HighQualityBicubic;
            grPhoto.PixelOffsetMode = PixelOffsetMode.HighQuality;

            Rectangle rec = new Rectangle(0, 0, bmp_Original.Width, bmp_Original.Height);
            grPhoto.DrawImage(bmp_Modificada, rec);
            Pen pen = new Pen(_clr_ColorBorde, _flt_AnchoBorde);
            grPhoto.DrawRectangle(pen, rec);

            MemoryStream ms_Modificada = new MemoryStream();
            bmPhoto.Save(ms_Modificada, System.Drawing.Imaging.ImageFormat.Png);

            // Cerramos todo lo cerrable
            bmp_Original.Dispose();
            bmp_Modificada.Dispose();
            bmPhoto.Dispose();
            grPhoto.Dispose();

            Bitmap bmp_Final = new Bitmap(ms_Modificada);

            return bmp_Final;
        }

        /// <summary>
        /// Redimencionar una imagen segun el tamaño del picturebox
        /// </summary>
        /// <param name="_pct_Aux"></param>
        /// <param name="_img_Aux"></param>
        public static void PictureBox_RedimencionarImagen(PictureBox _pct_Aux, Image _img_Aux)
        {
            try
            {
                if (_img_Aux != null)
                {
                    //calculate the size of the image
                    Size imgSize = GenerateImageDimensions(_img_Aux.Width, _img_Aux.Height, _pct_Aux.Width, _pct_Aux.Height);

                    //create a new Bitmap with the proper dimensions
                    Bitmap finalImg = new Bitmap(_img_Aux, imgSize.Width, imgSize.Height);

                    //create a new Graphics object from the image
                    Graphics gfx = Graphics.FromImage(_img_Aux);

                    //clean up the image (take care of any image loss from resizing)
                    gfx.InterpolationMode = InterpolationMode.HighQualityBicubic;

                    //empty the PictureBox
                    _pct_Aux.Image = null;

                    //center the new image
                    _pct_Aux.SizeMode = PictureBoxSizeMode.CenterImage;

                    //set the new image
                    _pct_Aux.Image = finalImg;

                    gfx.Dispose();

                }
            }
            catch (Exception )
            { }
        }
        public static Image RedimencionarImagen(Image _img_Aux,int _int_Ancho, int _int_Alto)
        {
            Image img_Final = null;
            try
            {
                if (_img_Aux != null)
                {
                    //calculate the size of the image
                    Size imgSize = GenerateImageDimensions(_img_Aux.Width, _img_Aux.Height, _int_Ancho, _int_Alto);

                    //create a new Bitmap with the proper dimensions
                    img_Final = new Bitmap(_img_Aux, imgSize.Width, imgSize.Height);

                    //create a new Graphics object from the image
                    Graphics gfx = Graphics.FromImage(_img_Aux);

                    //clean up the image (take care of any image loss from resizing)
                    gfx.InterpolationMode = InterpolationMode.HighQualityBicubic;

                    gfx.Dispose();
                }
            }
            catch (Exception)
            {}

            return img_Final;
        }
        private static Size GenerateImageDimensions(int _int_AnchoImagenOriginal, int _int_AltoImagenOriginal, int _int_AnchoFinal, int _int_AltoFinal)
        {
            int int_AnchoCalculado = 0;
            int int_AltoCalculado = 0;

            //Mas Ancha que Alta
            if (_int_AnchoFinal > _int_AltoFinal)
            {
                int_AltoCalculado = (_int_AnchoFinal * _int_AltoImagenOriginal) / _int_AnchoImagenOriginal;

                if (int_AltoCalculado <= _int_AltoFinal)
                {
                    int_AnchoCalculado = _int_AnchoFinal;
                }
                else
                {
                    int_AnchoCalculado = (_int_AltoFinal * _int_AnchoImagenOriginal) / _int_AltoImagenOriginal;
                    int_AltoCalculado = _int_AltoFinal;
                }
            }
            //Mas Alta que Ancha
            else if (_int_AltoFinal > _int_AnchoFinal)
            {
                int_AnchoCalculado = (_int_AltoFinal * _int_AnchoImagenOriginal) / _int_AltoImagenOriginal;

                if (int_AnchoCalculado <= _int_AnchoFinal)
                {
                    int_AltoCalculado = _int_AltoFinal;
                }
                else
                {
                    int_AltoCalculado = (_int_AnchoFinal * _int_AltoImagenOriginal) / _int_AnchoImagenOriginal;
                    int_AnchoCalculado = _int_AnchoFinal;
                }
            }
            //Cuadrada
            else
            {
                int_AnchoCalculado = (_int_AltoFinal * _int_AnchoImagenOriginal) / _int_AltoImagenOriginal;

                if (int_AnchoCalculado <= _int_AnchoFinal)
                {
                    int_AltoCalculado = _int_AltoFinal;
                }
                else
                {
                    int_AltoCalculado = (_int_AnchoFinal * _int_AltoImagenOriginal) / _int_AnchoImagenOriginal;
                    int_AnchoCalculado = _int_AnchoFinal;
                }
            }
            

            //return the new image dimensions
            return new Size(int_AnchoCalculado, int_AltoCalculado);
        }

        /// <summary>
        /// Calcula el Ancho en Pixeles de un texto segun la fuente
        /// </summary>
        /// <param name="_str_Original"></param>
        /// <param name="_obj_Graphics"></param>
        /// <param name="_obj_Fuente"></param>
        /// <returns></returns>
        public static int Calcular_AnchoTexto_EnPixeles(string _str_Original, Graphics _obj_Graphics, Font _obj_Fuente)
        {
            return (int)_obj_Graphics.MeasureString(_str_Original, _obj_Fuente).Width;
        }

        /// <summary>
        /// Conceder permisos a una carpeta especificada
        /// </summary>
        /// <param name="_str_Directorio"></param>
        public static void Conceder_Permisos_Carpeta(string _str_Directorio)
        {
            try
            {

                bool bol_TienePermisos = false;
                WindowsIdentity user = WindowsIdentity.GetCurrent();

                FileSecurity security = File.GetAccessControl(_str_Directorio);
                AuthorizationRuleCollection acl = security.GetAccessRules(true, true, typeof(System.Security.Principal.NTAccount));
                foreach (FileSystemAccessRule ace in acl)
                {
                    if (ace.IdentityReference.Value.Equals(user.Name))
                    {
                        bol_TienePermisos = true;
                        break;
                    }
                }

                if (bol_TienePermisos == false)
                {
                    //Ver si el usuario Tiene permisos de Todo
                    System.Diagnostics.Process process = new System.Diagnostics.Process();
                    System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo();
                    startInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
                    startInfo.Verb = "runas";
                    startInfo.FileName = "cmd.exe";

                    startInfo.Arguments = @"/K takeown /f " + "\"" + _str_Directorio + "\"" + @" && icacls " + "\"" + _str_Directorio + "\"" + @" /T /grant " + user.Name + ":(OI)(CI)(DC,M) && " +
                                          @"   takeown /f " + "\"" + _str_Directorio + "\"" + @" && icacls " + "\"" + _str_Directorio + "\"" + @" /T /grant " + "Usuarios" + ":(OI)(CI)(DC,M) && " +
                                          @"   takeown /f " + "\"" + _str_Directorio + "\"" + @" && icacls " + "\"" + _str_Directorio + "\"" + @" /T /grant " + "Users" + ":(OI)(CI)(DC,M)";

                    process.StartInfo = startInfo;
                    process.Start();
                }
            }
            catch (Exception)
            { }
        }

        /// <summary>
       /// Funcion para clonar variables de tipo List<>
       /// </summary>
       /// <typeparam name="T"></typeparam>
       /// <param name="src"></param>
       /// <returns></returns>
        public static List<T> Clonar<T>(this List<T> src) where T : ICloneable
        {
            List<T> tList = new List<T>();

            foreach (T t in src)
            {
                object c = t.Clone();
                tList.Add((T)c);
            }

            return tList;
        }

        #region Validar IBAN
        /// <summary>
        /// Validar si un Codigo IBAN esta Correcto
        /// </summary>
        /// <param name="_str_IBAN"></param>
        /// <returns></returns>
        public static bool Validar_IBAN(string _str_IBAN)
        {
            string str_Iban = _str_IBAN.Replace(" ", "");

            if (str_Iban.Length > 34 || str_Iban.Length < 5)
            {
                return false;
            }
            else
            {
                string str_CodigoPais = str_Iban.Substring(0, 2).ToUpper();
                string str_SumaDeComprobacion = str_Iban.Substring(2, 2).ToUpper();
                string str_CuentaBLZ = str_Iban.Substring(4).ToUpper();

                if (!IsNumeric(str_SumaDeComprobacion))
                {
                    return false; //Suma de comprobación no es numérico
                }

                if (!Validar_IBAN_CodigoPaisCorrecto(str_CodigoPais))
                {
                    return false;
                }

                string str_IBAN_Ajustado = str_CuentaBLZ + str_CodigoPais + "00";
                string str_Modulo = Validar_IBAN_Limpiador(str_IBAN_Ajustado);

                if (98 - Validar_IBAN_ObtenerModulo(str_Modulo, 97) != int.Parse(str_SumaDeComprobacion))
                {
                    return false;  //Suma de control es defectuosa
                }
            }
            return true;
        }
        private static string Validar_IBAN_Limpiador(string _str_IBAN)
        {
            for (int x = 65; x < 90; x++)
            {
                int int_replacewith = x - 64 + 9;
                string str_Reemplazar = ((char)x).ToString();
                _str_IBAN = _str_IBAN.Replace(str_Reemplazar, int_replacewith.ToString());
            }
            return _str_IBAN;
        }
        private static bool Validar_IBAN_CodigoPaisCorrecto(string _str_Codigo)
        {
            if (_str_Codigo.Length != 2)
                return false;
            else
            {
                _str_Codigo = _str_Codigo.ToUpper();
                string[] arr_codigoPaises = { "AA", "AB", "AC", "AD", "AE", "AF", "AG", "AH", "AI",
            "AJ", "AK", "AL", "AM", "AN", "AO", "AP", "AQ", "AR", "AS", "AT", "AU", "AV",
            "AW", "AX", "AY", "AZ", "BA", "BB", "BC", "BD", "BE", "BF", "BG", "BH", "BI",
            "BJ", "BK", "BL", "BM", "BN", "BO", "BP", "BQ", "BR", "BS", "BT", "BU", "BV",
            "BW", "BX", "BY", "BZ", "CA", "CB", "CC", "CD", "CE", "CF", "CG", "CH", "CI",
            "CJ", "CK", "CL", "CM", "CN", "CO", "CP", "CQ", "CR", "CS", "CT", "CU", "CV",
            "CW", "CX", "CY", "CZ", "DA", "DB", "DC", "DD", "DE", "DF", "DG", "DH", "DI",
            "DJ", "DK", "DL", "DM", "DN", "DO", "DP", "DQ", "DR", "DS", "DT", "DU", "DV",
            "DW", "DX", "DY", "DZ", "EA", "EB", "EC", "ED", "EE", "EF", "EG", "EH", "EI",
            "EJ", "EK", "EL", "EM", "EN", "EO", "EP", "EQ", "ER", "ES", "ET", "EU", "EV",
            "EW", "EX", "EY", "EZ", "FA", "FB", "FC", "FD", "FE", "FF", "FG", "FH", "FI",
            "FJ", "FK", "FL", "FM", "FN", "FO", "FP", "FQ", "FR", "FS", "FT", "FU", "FV",
            "FW", "FX", "FY", "FZ", "GA", "GB", "GC", "GD", "GE", "GF", "GG", "GH", "GI",
            "GJ", "GK", "GL", "GM", "GN", "GO", "GP", "GQ", "GR", "GS", "GT", "GU", "GV",
            "GW", "GX", "GY", "GZ", "HA", "HB", "HC", "HD", "HE", "HF", "HG", "HH", "HI",
            "HJ", "HK", "HL", "HM", "HN", "HO", "HP", "HQ", "HR", "HS", "HT", "HU", "HV",
            "HW", "HX", "HY", "HZ", "IA", "IB", "IC", "ID", "IE", "IF", "IG", "IH", "II",
            "IJ", "IK", "IL", "IM", "IN", "IO", "IP", "IQ", "IR", "IS", "IT", "IU", "IV",
            "IW", "IX", "IY", "IZ", "JA", "JB", "JC", "JD", "JE", "JF", "JG", "JH", "JI",
            "JJ", "JK", "JL", "JM", "JN", "JO", "JP", "JQ", "JR", "JS", "JT", "JU", "JV",
            "JW", "JX", "JY", "JZ", "KA", "KB", "KC", "KD", "KE", "KF", "KG", "KH", "KI",
            "KJ", "KK", "KL", "KM", "KN", "KO", "KP", "KQ", "KR", "KS", "KT", "KU", "KV",
            "KW", "KX", "KY", "KZ", "LA", "LB", "LC", "LD", "LE", "LF", "LG", "LH", "LI",
            "LJ", "LK", "LL", "LM", "LN", "LO", "LP", "LQ", "LR", "LS", "LT", "LU", "LV",
            "LW", "LX", "LY", "LZ", "MA", "MB", "MC", "MD", "ME", "MF", "MG", "MH", "MI",
            "MJ", "MK", "ML", "MM", "MN", "MO", "MP", "MQ", "MR", "MS", "MT", "MU", "MV",
            "MW", "MX", "MY", "MZ", "NA", "NB", "NC", "ND", "NE", "NF", "NG", "NH", "NI",
            "NJ", "NK", "NL", "NM", "NN", "NO", "NP", "NQ", "NR", "NS", "NT", "NU", "NV",
            "NW", "NX", "NY", "NZ", "OA", "OB", "OC", "OD", "OE", "OF", "OG", "OH", "OI",
            "OJ", "OK", "OL", "OM", "ON", "OO", "OP", "OQ", "OR", "OS", "OT", "OU", "OV",
            "OW", "OX", "OY", "OZ", "PA", "PB", "PC", "PD", "PE", "PF", "PG", "PH", "PI",
            "PJ", "PK", "PL", "PM", "PN", "PO", "PP", "PQ", "PR", "PS", "PT", "PU", "PV",
            "PW", "PX", "PY", "PZ", "QA", "QB", "QC", "QD", "QE", "QF", "QG", "QH", "QI",
            "QJ", "QK", "QL", "QM", "QN", "QO", "QP", "QQ", "QR", "QS", "QT", "QU", "QV",
            "QW", "QX", "QY", "QZ", "RA", "RB", "RC", "RD", "RE", "RF", "RG", "RH", "RI",
            "RJ", "RK", "RL", "RM", "RN", "RO", "RP", "RQ", "RR", "RS", "RT", "RU", "RV",
            "RW", "RX", "RY", "RZ", "SA", "SB", "SC", "SD", "SE", "SF", "SG", "SH", "SI",
            "SJ", "SK", "SL", "SM", "SN", "SO", "SP", "SQ", "SR", "SS", "ST", "SU", "SV",
            "SW", "SX", "SY", "SZ", "TA", "TB", "TC", "TD", "TE", "TF", "TG", "TH", "TI",
            "TJ", "TK", "TL", "TM", "TN", "TO", "TP", "TQ", "TR", "TS", "TT", "TU", "TV",
            "TW", "TX", "TY", "TZ", "UA", "UB", "UC", "UD", "UE", "UF", "UG", "UH", "UI",
            "UJ", "UK", "UL", "UM", "UN", "UO", "UP", "UQ", "UR", "US", "UT", "UU", "UV",
            "UW", "UX", "UY", "UZ", "VA", "VB", "VC", "VD", "VE", "VF", "VG", "VH", "VI",
            "VJ", "VK", "VL", "VM", "VN", "VO", "VP", "VQ", "VR", "VS", "VT", "VU", "VV",
            "VW", "VX", "VY", "VZ", "WA", "WB", "WC", "WD", "WE", "WF", "WG", "WH", "WI",
            "WJ", "WK", "WL", "WM", "WN", "WO", "WP", "WQ", "WR", "WS", "WT", "WU", "WV",
            "WW", "WX", "WY", "WZ", "XA", "XB", "XC", "XD", "XE", "XF", "XG", "XH", "XI",
            "XJ", "XK", "XL", "XM", "XN", "XO", "XP", "XQ", "XR", "XS", "XT", "XU", "XV",
            "XW", "XX", "XY", "XZ", "YA", "YB", "YC", "YD", "YE", "YF", "YG", "YH", "YI",
            "YJ", "YK", "YL", "YM", "YN", "YO", "YP", "YQ", "YR", "YS", "YT", "YU", "YV",
            "YW", "YX", "YY", "YZ", "ZA", "ZB", "ZC", "ZD", "ZE", "ZF", "ZG", "ZH", "ZI",
            "ZJ", "ZK", "ZL", "ZM", "ZN", "ZO", "ZP", "ZQ", "ZR", "ZS", "ZT", "ZU", "ZV",
            "ZW", "ZX", "ZY", "ZZ" };

                if (Array.IndexOf(arr_codigoPaises, _str_Codigo) == -1)
                {
                    return false;
                }
                else
                {
                    return true;
                }
            }
        }
        private static int Validar_IBAN_ObtenerModulo(string _str_Modulo, int _int_Divisor)
        {
            int int_Comienzo, int_Final, int_Resultado, int_Resto_Aux, int_Buffer;
            string str_Resto = "", str_Erg = "";

            int_Comienzo = 0;
            int_Final = 0;
            while (int_Final <= _str_Modulo.Length - 1)
            {
                int_Buffer = int.Parse(str_Resto + _str_Modulo.Substring(int_Comienzo, int_Final - int_Comienzo + 1));

                if (int_Buffer >= _int_Divisor)
                {
                    int_Resultado = int_Buffer / _int_Divisor;
                    int_Resto_Aux = int_Buffer - int_Resultado * _int_Divisor;
                    str_Resto = int_Resto_Aux.ToString();

                    str_Erg = str_Erg + int_Resultado.ToString();

                    int_Comienzo = int_Final + 1;
                    int_Final = int_Comienzo;
                }
                else
                {
                    if (str_Erg != "")
                        str_Erg = str_Erg + "0";

                    int_Final = int_Final + 1;
                }
            }
            if (int_Comienzo <= _str_Modulo.Length)
                str_Resto = str_Resto + _str_Modulo.Substring(int_Comienzo);
            return int.Parse(str_Resto);
        }
        #endregion

        #region Validar CIF,NIF,NIE, etc
        public static bool Validar_CIFNIFNIE(string _str_Valor)
        {
            //0-> No se valido
            //1-> Se valido Esta Ok
            //2-> Se valido Esta incorrecto

            //Primero Valido NIF
            int in_ValorDevuelto =Validar_NIF(_str_Valor);


            if (in_ValorDevuelto==0)
            {
                in_ValorDevuelto=Validar_CIF(_str_Valor);
            }

            bool bol_ValorDevuelto = true;
            if (in_ValorDevuelto==2)
            {
                bol_ValorDevuelto = false;
            }

            return bol_ValorDevuelto;
        }
        /// <summary>
        /// Validar si un NIF esta Correcto
        /// </summary>
        /// <param name="_str_Valor"></param>
        /// <returns></returns>
        private static int Validar_NIF(string _str_Valor)
        {
            //0-> No se valido
            //1-> Se valido Esta Ok
            //2-> Se valido Esta incorrecto
            int int_ValorDevuelto = 0;

            string str_Auxiliar = null;
            _str_Valor = _str_Valor.ToUpper();

            //validar NIE
            int int_ValorDevuelto_NIF = Validar_NIE(_str_Valor);

            if ((_str_Valor.Length == 8 || _str_Valor.Length == 9) && int_ValorDevuelto_NIF == 0)
            {
                //Compruebo si empieza por letra
                string str_Letra = _str_Valor.Substring(0, 1);
                char letra;
                bool bol_Resultado = char.TryParse(str_Letra, out letra);
                if (bol_Resultado==false || (bol_Resultado && !char.IsLetter(letra)))
                {
                    // ponemos la letra en mayúscula
                    str_Auxiliar = _str_Valor.Substring(0, _str_Valor.Length - 1);

                    // quitamos la letra del NIF
                    if (str_Auxiliar.Length >= 7 && IsNumeric(str_Auxiliar))
                    {
                        str_Auxiliar = Validar_NIF_CalcularLetra(str_Auxiliar); // calculamos la letra del NIF para comparar con la que tenemos

                        if (_str_Valor == str_Auxiliar)
                        {
                            int_ValorDevuelto = 1;
                        }
                        else
                        {
                            int_ValorDevuelto = 2;
                        }
                    }
                    else
                    {
                        int_ValorDevuelto = 2;
                    }
                }
            }
            else
            {
                int_ValorDevuelto = int_ValorDevuelto_NIF;
            }

            // comparamos las letras
            return int_ValorDevuelto;
        }
        /// <summary>
        /// Validar si un NIE esta Correcto
        /// </summary>
        private static int Validar_NIE(string _str_Valor)
        {
            //0-> No se valido
            //1-> Se valido Esta Ok
            //2-> Se valido Esta incorrecto
            int int_ValorDevuelto =0;

            _str_Valor = _str_Valor.ToUpper();
            string str_CalcularLetra = null;
            string str_Valor_SinLetra = _str_Valor.Substring(1, _str_Valor.Length - 1);

            if (_str_Valor.Length == 9)
            {
                //Compruebo si empieza por letra
                string str_Auxiliar = _str_Valor.Substring(0, 1);

                char letra;
                bool bol_Resultado = char.TryParse(str_Auxiliar, out letra);

                if (bol_Resultado)
                {
                    //Asigno el valor dependiendo de la letra por la que empieze
                    if (letra.Equals('Y'))
                        str_CalcularLetra = "1" + str_Valor_SinLetra;
                    else if (letra.Equals('X'))
                        str_CalcularLetra = "0" + str_Valor_SinLetra;
                    else if (letra.Equals('Z'))
                        str_CalcularLetra = "2" + str_Valor_SinLetra;

                    if (str_CalcularLetra!=null)
                    {
                        //Aprovecho la funcion de DNI para calcular la letra final y comparo sin la primera letra
                        if (str_Valor_SinLetra == Validar_NIF_CalcularLetra(str_CalcularLetra).Substring(1, _str_Valor.Length - 1))
                        {
                            int_ValorDevuelto = 1;
                        }
                        else
                        {
                            int_ValorDevuelto = 2;
                        }
                    }
                }
            }

            return int_ValorDevuelto;
        }

        private static string Validar_NIF_CalcularLetra(string _str_NumeroDNI)
        {
            const string str_CadenaLetra = "TRWAGMYFPDXBNJZSQVHLCKE";
            const string strCadenaNumeros = "0123456789";

            int int_a = 0;
            int int_b = 0;
            int int_c = 0;
            int int_NIF = 0;
            StringBuilder obj_StringBuilder = new StringBuilder();

            _str_NumeroDNI = _str_NumeroDNI.Trim();
            if (_str_NumeroDNI.Length == 0) return "";

            // Dejar sólo los números
            for (int i = 0; i <= _str_NumeroDNI.Length - 1; i++)
                if (strCadenaNumeros.IndexOf(_str_NumeroDNI[i]) > -1) obj_StringBuilder.Append(_str_NumeroDNI[i]);

            _str_NumeroDNI = obj_StringBuilder.ToString();
            int_a = 0;
            int_NIF = Convert.ToInt32(_str_NumeroDNI);
            do
            {
                int_b = Convert.ToInt32((int_NIF / 24));
                int_c = int_NIF - (24 * int_b);
                int_a = int_a + int_c;
                int_NIF = int_b;
            } while (int_b != 0);

            int_b = Convert.ToInt32((int_a / 23));
            int_c = int_a - (23 * int_b);
            return _str_NumeroDNI.ToString() + str_CadenaLetra.Substring(int_c, 1);
        }

        /// <summary>
        /// Validar si un CIF esta Correcto
        /// </summary>
        /// <param name="_str_CIF"></param>
        /// <returns></returns>
        private static int Validar_CIF(string _str_CIF)
        {
            //0-> No se valido
            //1-> Se valido Esta Ok
            //2-> Se valido Esta incorrecto
            int int_ValorDevuelto = 0;

            if (_str_CIF.Length < 3)
            {
                int_ValorDevuelto= 2;
            }

            if (int_ValorDevuelto==0)
            {
                //Valida el cif actual
                string[] letrasCodigo = { "J", "A", "B", "C", "D", "E", "F", "G", "H", "I" };

                string LetraInicial = _str_CIF[0].ToString();
                string DigitoControl = _str_CIF[_str_CIF.Length - 1].ToString();
                string n = _str_CIF.ToString().Substring(1, _str_CIF.Length - 2);
                int sumaPares = 0;
                int sumaImpares = 0;
                int sumaTotal = 0;
                int i = 0;
                bool bol_retVal = false;

                // Recorrido por todos los dígitos del número
                for (i = 0; i < n.Length; i++)
                {
                    int aux;
                    int.TryParse(n[i].ToString(), out aux);

                    if ((i + 1) % 2 == 0)
                    {
                        // Si es una posición par, se suman los dígitos
                        sumaPares += aux;
                    }
                    else
                    {
                        // Si es una posición impar, se multiplican los dígitos por 2
                        aux = aux * 2;

                        // se suman los dígitos de la suma
                        sumaImpares += Validar_CIF_SumaDigitos(aux);
                    }
                }

                // Se suman los resultados de los números pares e impares
                sumaTotal += sumaPares + sumaImpares;

                // Se obtiene el dígito de las unidades
                int unidades = sumaTotal % 10;

                // Si las unidades son distintas de 0, se restan de 10
                if (unidades != 0) unidades = 10 - unidades;

                switch (LetraInicial)
                {
                    // Sólo números
                    case "A":
                    case "B":
                    case "E":
                    case "H":
                        bol_retVal = DigitoControl == unidades.ToString();
                        break;

                    // Sólo letras
                    case "K":
                    case "P":
                    case "Q":
                    case "S":
                        bol_retVal = DigitoControl == letrasCodigo[unidades];
                        break;

                    default:
                        bol_retVal = (DigitoControl == unidades.ToString()) || (DigitoControl == letrasCodigo[unidades]);
                        break;
                }

                if (bol_retVal)
                {
                    int_ValorDevuelto = 1;
                }
                else
                {
                    int_ValorDevuelto = 2;
                }
            }

            return int_ValorDevuelto;

        }
        private static int Validar_CIF_SumaDigitos(int _int_digitos)
        {
            string sNumero = _int_digitos.ToString();
            int suma = 0;

            for (int i = 0; i < sNumero.Length; i++)
            {
                int aux;
                int.TryParse(sNumero[i].ToString(), out aux);
                suma += aux;
            }
            return suma;
        }

        #endregion

        /// <summary>
        /// Copia los valores de un objeto a otro, es decir, sustituye los valores
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="TU"></typeparam>
        /// <param name="_obj_Origen"></param>
        /// <param name="_obj_Destino"></param>
        /// <param name="_bol_CopiarColecciones"></param>
        /// <param name="_bol_CopiarRelaciones"></param>
        public static void CopiarPropiedadesObjetos<T, TU>(T _obj_Origen, TU _obj_Destino, bool _bol_CopiarColecciones, bool _bol_CopiarRelaciones)
        {
            try
            {
                var propiedadesOrigen = typeof(T).GetProperties().Where(x => x.CanRead).ToList();
                var propiedadesDestino = typeof(TU).GetProperties().Where(x => x.CanWrite).ToList();

                foreach (var propiedadOrigen in propiedadesOrigen)
                {
                    bool bool_copiarPropiedad = false;

                    if (propiedadesDestino.Any(x => x.Name == propiedadOrigen.Name))
                    {
                        if (!propiedadOrigen.PropertyType.Namespace.Contains("Collection") && !propiedadOrigen.PropertyType.Namespace.Contains("Exferia_EntityFramework"))
                        {
                            bool_copiarPropiedad = true;
                        }
                        else if (propiedadOrigen.PropertyType.Namespace.Contains("Collection") && _bol_CopiarColecciones)
                        {
                            bool_copiarPropiedad = true;
                        }
                        else if (propiedadOrigen.PropertyType.Namespace.Contains("Exferia_EntityFramework") && _bol_CopiarRelaciones)
                        {
                            bool_copiarPropiedad = true;
                        }

                        if (bool_copiarPropiedad)
                        {
                            var propiedadDestino = propiedadesDestino.Where(x => x.Name == propiedadOrigen.Name).FirstOrDefault();

                            propiedadDestino.SetValue(_obj_Destino, propiedadOrigen.GetValue(_obj_Origen) != null ? propiedadOrigen.GetValue(_obj_Origen) : null, null);
                        }
                    }
                }
            }
            catch (Exception)
            { }
        }

        /// <summary>
        /// Convierte un Booleando a texto
        /// True -> Si
        /// False -> No
        /// Null -> 'vacio'
        /// </summary>
        /// <param name="_bol_ValorAConvertir"></param>
        /// <returns></returns>
        public static string Convertir_Booleano_A_Texto(bool? _bol_ValorAConvertir)
        {
            if (_bol_ValorAConvertir != null)
            {
                if (_bol_ValorAConvertir.Value)
                {
                    return "Si";
                }

                return "No";
            }

            return "";
        }

        /// <summary>
        /// Calcular el Ancho maximo de todoas las columnas para aplicarselo al resto, en un CheckListBox
        /// </summary>
        /// <param name="_chklst_AUX"></param>
        /// <returns></returns>
        public static int Calcular_AnchoMaximoColumna_CheckedListBox(CheckedListBox _chklst_AUX)
        {
            Font fnt = _chklst_AUX.Font;
            int result = 0;

            foreach (INTERNO_CodigoDescripcion_Modelo mdl_INTERNO_CodigoDescripcion_Modelo in _chklst_AUX.Items)
            {
                int width = TextRenderer.MeasureText(mdl_INTERNO_CodigoDescripcion_Modelo.ToString(), fnt).Width + 20;
                if (width > result)
                {
                    result = width;
                }
            }
            return result;
        }

        /// <summary>
        /// Funcion que recibe un decimal y lo formatea a 3 decimales
        /// </summary>
        /// <param name="_dcm_Valor"></param>
        /// <returns></returns>
        public static decimal Formatear_A3Decimales(decimal _dcm_Valor)
        {
            string str_ValorPasadoString = string.Format("{0:0.000}", _dcm_Valor);

            decimal dcm_valorDefecto = 0.000m;

            // you can throw an exception or return a default value here
            if (string.IsNullOrEmpty(str_ValorPasadoString))
                return dcm_valorDefecto;

            decimal d;

            // you could throw an exception or return a default value on failure
            if (!decimal.TryParse(str_ValorPasadoString, out d))
                return dcm_valorDefecto;

            return d;
        }

        /// <summary>
        /// Funcion que recibe un decima y devuelve un string
        /// </summary>
        /// <param name="_dcm_Valor"></param>
        /// <returns></returns>
        public static string Convertir_A_String(decimal _dcm_Valor)
        {
            return _dcm_Valor.ToString();

        }
        public static string Convertir_A_String(long _lng_Valor)
        {
            return _lng_Valor.ToString();

        }
        public static string Convertir_A_String(int _int_Valor)
        {
            return _int_Valor.ToString();

        }
        public static string Convertir_A_String(dynamic _dnm_Valor)
        {
            return _dnm_Valor.ToString();

        }
        public static void Poner_Foco_Objeto(dynamic _dnm_Pantalla,dynamic _dnm_Objeto)
        {
            try
            {
                //Activar Pantalla Primero
                if (_dnm_Pantalla!=null)
                {
                    _dnm_Pantalla.Activate();
                }

                //Se hace con un timer, porque sino el .net se pasa por el forro el foco ############
                System.Windows.Forms.Timer timer_PONERFOCO = new System.Windows.Forms.Timer();
                timer_PONERFOCO.Interval = 50;
                timer_PONERFOCO.Tick += delegate (object s, EventArgs ee)
                {
                    timer_PONERFOCO.Stop();
                    timer_PONERFOCO.Dispose();


                    //Activar el Tab si Fuera Necesario
                    Activar_TAB(_dnm_Objeto, null);

                    //Exferia_TextBox_ConMascara
                    if (_dnm_Objeto.GetType() == typeof(Exferia_TextBox_ConMascara))
                    {
                        _dnm_Objeto.Exferia_TextBox_ConMascara_Focus();
                    }
                    //Exferia_TextBox
                    else if (_dnm_Objeto.GetType() == typeof(Exferia_TextBox))
                    {
                        _dnm_Objeto.Exferia_TextBox_Foco();
                    }
                    //Exferia_TextBox_IBAN
                    else if (_dnm_Objeto.GetType() == typeof(Exferia_TextBox_IBAN))
                    {
                        _dnm_Objeto.Exferia_TextBox_IBAN_Foco();
                    }
                    //Exferia_TextBox_CIFNIF
                    else if (_dnm_Objeto.GetType() == typeof(Exferia_TextBox_CIFNIF))
                    {
                        _dnm_Objeto.Exferia_TextBox_CIFNIF_Foco();
                    }
                    //Exferia_TextBox_Email
                    else if (_dnm_Objeto.GetType() == typeof(Exferia_TextBox_Email))
                    {
                        _dnm_Objeto.Exferia_TextBox_Email_Foco();
                    }
                    //Exferia_TextBox_URL
                    else if (_dnm_Objeto.GetType() == typeof(Exferia_TextBox_URL))
                    {
                        _dnm_Objeto.Exferia_TextBox_URL_Foco();
                    }
                    //Exferia_Button
                    else if (_dnm_Objeto.GetType() == typeof(Exferia_Button))
                    {
                        _dnm_Objeto.Focus();
                    }
                    else
                    {
                        _dnm_Objeto.Focus();
                    }
                    //##################################################################################
                };
                timer_PONERFOCO.Start();
            }
            catch (Exception ex)
            {
                Control_Errores.Errores_Log("", ex, nameof(Funciones) + "/" + nameof(Poner_Foco_Objeto));
            }
        }
        public static void SeleccionarTexto_Objeto(dynamic _dnm_Pantalla, dynamic _dnm_Objeto)
        {
            try
            {
                //Activar Pantalla Primero
                if (_dnm_Pantalla != null)
                {
                    _dnm_Pantalla.Activate();
                }

                //Se hace con un timer, porque sino el .net se pasa por el forro la seleccion ############
                System.Windows.Forms.Timer timer_SELECCIONARTEXTO = new System.Windows.Forms.Timer();
                timer_SELECCIONARTEXTO.Interval = 50;
                timer_SELECCIONARTEXTO.Tick += delegate (object s, EventArgs ee)
                {
                    timer_SELECCIONARTEXTO.Stop();
                    timer_SELECCIONARTEXTO.Dispose();

                    //Activar el Tab si Fuera Necesario
                    Activar_TAB(_dnm_Objeto, null);

                    //Exferia_TextBox_ConMascara
                    if (_dnm_Objeto.GetType() == typeof(Exferia_TextBox_ConMascara))
                    {
                        if (!string.IsNullOrEmpty(_dnm_Objeto.Text))
                        {
                            _dnm_Objeto.Exferia_TextBox_ConMascara_SelectionStart = 0;
                            _dnm_Objeto.Exferia_TextBox_ConMascara_SelectionLength = _dnm_Objeto.Text.Length;
                        }
                    }
                    //Exferia_FechaSeleccion
                    else if (_dnm_Objeto.GetType() == typeof(Exferia_FechaSeleccion))
                    {
                        _dnm_Objeto.Exferia_FechaSeleccion_SeleccionarTexto();
                    }
                    //Exferia_TextBox
                    else if (_dnm_Objeto.GetType() == typeof(Exferia_TextBox))
                    {
                        if (!string.IsNullOrEmpty(_dnm_Objeto.Text))
                        {
                            _dnm_Objeto.Exferia_TextBox_SelectionStart = 0;
                            _dnm_Objeto.Exferia_TextBox_SelectionLength = _dnm_Objeto.Text.Length;
                        }
                    }
                    //##################################################################################
                };
                timer_SELECCIONARTEXTO.Start();
            }
            catch (Exception ex)
            {
                Control_Errores.Errores_Log("", ex, nameof(Funciones) + "/" + nameof(SeleccionarTexto_Objeto));
            }
        }

        public static void Poner_Valor_Objeto(dynamic _dnm_Objeto, dynamic _dnm_Valor)
        {
            try
            {
                //Exferia_Button
                if (_dnm_Objeto.GetType() == typeof(Exferia_Button))
                {
                    
                }
                //Exferia_Button_ConBorde
                else if (_dnm_Objeto.GetType() == typeof(Exferia_Button_ConBorde))
                {

                }
                //Exferia_Button_Vertical
                else if (_dnm_Objeto.GetType() == typeof(Exferia_Button_Vertical))
                {

                }
                //Exferia_CheckBox
                else if (_dnm_Objeto.GetType() == typeof(Exferia_CheckBox))
                {
                    ((Exferia_CheckBox)_dnm_Objeto).Checked = _dnm_Valor;
                }
                //Exferia_CheckListBox
                else if (_dnm_Objeto.GetType() == typeof(Exferia_CheckListBox))
                {
                   
                }
                //Exferia_ComboBox
                else if (_dnm_Objeto.GetType() == typeof(Exferia_ComboBox))
                {
                    
                }
                //Exferia_DataGridView
                else if (_dnm_Objeto.GetType() == typeof(Exferia_DataGridView))
                {

                }
                //Exferia_FechaSeleccion
                else if (_dnm_Objeto.GetType() == typeof(Exferia_FechaSeleccion))
                {
                    ((Exferia_FechaSeleccion)_dnm_Objeto).Exferia_FechaSeleccion_Fecha = _dnm_Valor;
                }
                //Exferia_FechaSeleccion
                else if (_dnm_Objeto.GetType() == typeof(Exferia_FicheroSeleccion))
                {
                    
                }
                //Exferia_F3
                else if (_dnm_Objeto.GetType() == typeof(Exferia_F3))
                {
                    
                }
                //Exferia_F3_Auxiliar
                else if (_dnm_Objeto.GetType() == typeof(Exferia_F3_Auxiliar))
                {
                   
                }
                //Exferia_F3_SoloSeleccion
                else if (_dnm_Objeto.GetType() == typeof(Exferia_F3_SoloSeleccion))
                {
                   
                }
                //Exferia_F3_SoloSeleccion_Simple
                else if (_dnm_Objeto.GetType() == typeof(Exferia_F3_SoloSeleccion_Simple))
                {
                    
                }
                //Exferia_GroupBox
                else if (_dnm_Objeto.GetType() == typeof(Exferia_GroupBox))
                {
                   
                }
                //Exferia_Label
                else if (_dnm_Objeto.GetType() == typeof(Exferia_Label))
                {

                }
                //Exferia_Label_Error
                else if (_dnm_Objeto.GetType() == typeof(Exferia_Label_Error))
                {

                }
                //Exferia_Label_InformacionEmpresa
                else if (_dnm_Objeto.GetType() == typeof(Exferia_Label_InformacionEmpresa))
                {

                }
                //Exferia_Label_Vertical
                else if (_dnm_Objeto.GetType() == typeof(Exferia_Label_Vertical))
                {

                }
                //Panel
                else if (_dnm_Objeto.GetType() == typeof(Panel))
                {
                   
                }
                //Exferia_Paginador
                else if (_dnm_Objeto.GetType() == typeof(Exferia_Paginador))
                {

                }
                //Exferia_Panel_Degradado
                else if (_dnm_Objeto.GetType() == typeof(Exferia_Panel_Degradado))
                {
                   
                }
                //Exferia_RadioButton
                else if (_dnm_Objeto.GetType() == typeof(Exferia_RadioButton))
                {
                    ((Exferia_RadioButton)_dnm_Objeto).Checked = _dnm_Valor;
                }
                //Exferia_TabControl
                else if (_dnm_Objeto.GetType() == typeof(Exferia_TabControl))
                {
                   
                }
                //TabPage
                else if (_dnm_Objeto.GetType() == typeof(TabPage))
                {
                    
                }
                //Exferia_TextBox
                else if (_dnm_Objeto.GetType() == typeof(Exferia_TextBox))
                {
                    ((Exferia_TextBox)_dnm_Objeto).Text = _dnm_Valor;
                }
                //Exferia_TextBox_Busqueda
                else if (_dnm_Objeto.GetType() == typeof(Exferia_TextBox_Busqueda))
                {
                    ((Exferia_TextBox)_dnm_Objeto).Text = _dnm_Valor;
                }
                //Exferia_TextBox_CIFNIF
                else if (_dnm_Objeto.GetType() == typeof(Exferia_TextBox_CIFNIF))
                {
                    ((Exferia_TextBox)_dnm_Objeto).Text = _dnm_Valor;
                }
                //Exferia_TextBox_ConMascara
                else if (_dnm_Objeto.GetType() == typeof(Exferia_TextBox_ConMascara))
                {
                    ((Exferia_TextBox)_dnm_Objeto).Text = _dnm_Valor;
                }
                //Exferia_TextBox_Email
                else if (_dnm_Objeto.GetType() == typeof(Exferia_TextBox_Email))
                {
                    ((Exferia_TextBox)_dnm_Objeto).Text = _dnm_Valor;
                }
                //Exferia_TextBox_IBAN
                else if (_dnm_Objeto.GetType() == typeof(Exferia_TextBox_IBAN))
                {
                    ((Exferia_TextBox)_dnm_Objeto).Text = _dnm_Valor;
                }
                //Exferia_TextBox_URL
                else if (_dnm_Objeto.GetType() == typeof(Exferia_TextBox_URL))
                {
                    ((Exferia_TextBox)_dnm_Objeto).Text = _dnm_Valor;
                }
            }
            catch (Exception ex)
            {
                Control_Errores.Errores_Log("", ex, nameof(Funciones) + "/" + nameof(Poner_Valor_Objeto));
            }
        }

        private static void Activar_TAB(dynamic _dnm_Objeto, TabPage _tbp_Seleccionar)
        {
            try
            {
                if (_dnm_Objeto.Parent!=null)
                {
                    if (_dnm_Objeto.GetType() == typeof(TabPage))
                    {
                        Activar_TAB(_dnm_Objeto.Parent, ((TabPage)_dnm_Objeto));
                    }
                    else
                    {
                        if (_tbp_Seleccionar!=null)
                        {
                            if (_dnm_Objeto.GetType() == typeof(Exferia_TabControl))
                            {
                                ((Exferia_TabControl)_dnm_Objeto).SelectedTab=_tbp_Seleccionar;


                                Activar_TAB(_dnm_Objeto.Parent, _tbp_Seleccionar);
                            }
                        }
                        else
                        {
                            Activar_TAB(_dnm_Objeto.Parent, _tbp_Seleccionar);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Control_Errores.Errores_Log("", ex, nameof(Funciones) + "/" + nameof(Activar_TAB));
            }
        }

        #region Calculo fechas segun FormasPago
        public static List<INTERNO_FechasSegunFormasPago_Modelo> Calcular_Fechas_SegunFormarPago(MAE_FormasPago _mdl_MAE_FormasPago,
                                                                                                 DateTime _dtt_FechaIntroduccion,
                                                                                                 DateTime _dtt_FechaSistema,
                                                                                                 DateTime _dtt_FechaDocumento,
                                                                                                 decimal _dcm_Importe_Total_BaseImponible,
                                                                                                 decimal _dcm_Importe_Total_Final,
                                                                                                 decimal _dcm_Importe_TotalCobros_Albaranes)
        {
            List<INTERNO_FechasSegunFormasPago_Modelo> lst_INTERNO_FechasSegunFormasPago_Modelo = new List<INTERNO_FechasSegunFormasPago_Modelo>();
            List<MAE_FormasPago_Detalle> lst_MAE_FormasPago_Detalle = null;
            DateTime dtt_FechaParaCalculo = new DateTime();
            try
            {
                #region Elegir Fecha Para Calculo
                if (_mdl_MAE_FormasPago.campoFechaParaCalculo != null)
                {
                    //Primero Miramos cual va a ser la fecha para el calculo
                    if (_mdl_MAE_FormasPago.campoFechaParaCalculo.Equals(Variables.G_MDL_CAMPOFECHAPARACALCULO_INTRODUCCION.Codigo))
                    {
                        dtt_FechaParaCalculo = _dtt_FechaIntroduccion;
                    }
                    else if (_mdl_MAE_FormasPago.campoFechaParaCalculo.Equals(Variables.G_MDL_CAMPOFECHAPARACALCULO_SISTEMA.Codigo))
                    {
                        dtt_FechaParaCalculo = _dtt_FechaSistema;
                    }
                    else if (_mdl_MAE_FormasPago.campoFechaParaCalculo.Equals(Variables.G_MDL_CAMPOFECHAPARACALCULO_DOCUMENTO.Codigo))
                    {
                        dtt_FechaParaCalculo = _dtt_FechaDocumento;
                    }
                }
                else
                {
                    dtt_FechaParaCalculo = _dtt_FechaSistema;
                }
                #endregion

                #region Calcular Fecha Primer Vencimiento
                //Calcular el dia de exacto, segun los dias que se tiene que poner
                lst_INTERNO_FechasSegunFormasPago_Modelo.Add(Calcular_SegunFormaPago_Fecha(ref dtt_FechaParaCalculo,
                                                                                           _mdl_MAE_FormasPago,
                                                                                           _mdl_MAE_FormasPago.mesesDesplazamientoInicial,
                                                                                           _mdl_MAE_FormasPago.diasDesplazamientoInicial));
                #endregion

                //El resto de las fechas
                if (_mdl_MAE_FormasPago.MAE_FormasPago_Detalle != null)
                {
                    lst_MAE_FormasPago_Detalle = _mdl_MAE_FormasPago.MAE_FormasPago_Detalle.ToList();
                }

                if (lst_MAE_FormasPago_Detalle != null && lst_MAE_FormasPago_Detalle.Count>0)
                {
                    #region Calcular Fecha Vencimientos Siguientes
                    if (_mdl_MAE_FormasPago.numeroVencimientos > 1)
                    {
                        //Recorro las lineas en este caso el detalle
                        foreach (MAE_FormasPago_Detalle mdl_MAE_FormasPago_Detalle in lst_MAE_FormasPago_Detalle.Where(x => x.orden > 1))
                        {
                            //Calcular el dia de exacto, segun los dias que se tiene que poner
                            lst_INTERNO_FechasSegunFormasPago_Modelo.Add(Calcular_SegunFormaPago_Fecha(ref dtt_FechaParaCalculo,
                                                                                                       _mdl_MAE_FormasPago,
                                                                                                       _mdl_MAE_FormasPago.mesesEntreGiros,
                                                                                                       _mdl_MAE_FormasPago.diasEntreGiros));
                        }

                    }
                    #endregion

                    #region Calcular Importe

                    //Solo hay un registro
                    if (lst_INTERNO_FechasSegunFormasPago_Modelo.Count == 1)
                    {
                        lst_INTERNO_FechasSegunFormasPago_Modelo[0].Importe = Calcular_SegunFormaPago_Importe_Porcentaje(_dcm_Importe_Total_BaseImponible, 
                                                                                                                         _dcm_Importe_Total_Final,
                                                                                                                         _dcm_Importe_TotalCobros_Albaranes,
                                                                                                                         lst_MAE_FormasPago_Detalle[0].porcentaje, 
                                                                                                                         Variables.G_INT_TIPOAPLICACIONIMPUESTO_ACTUALIZARPROPORCIONALMENTE,
                                                                                                                         true);
                    }
                    //Haya mas de uno
                    else
                    {
                        //Variables
                        decimal dcm_Importe_PorFecha = 0;
                        decimal dcm_Importe_PorFecha_Total=0;

                        //Tipo de aplicacion de impuesto
                        int int_TipoAplicacionImpuesto = Variables.G_INT_TIPOAPLICACIONIMPUESTO_ACTUALIZARPROPORCIONALMENTE;
                        if (_mdl_MAE_FormasPago.tipoAplicacionImpuesto != null)
                        {
                            int_TipoAplicacionImpuesto = _mdl_MAE_FormasPago.tipoAplicacionImpuesto.Value;
                        }

                        //Recorro las lineas en este caso el detalle
                        for (int int_Contador = 0; int_Contador < lst_INTERNO_FechasSegunFormasPago_Modelo.Count; int_Contador++)
                        {
                            //Final
                            if (int_Contador + 1 == lst_INTERNO_FechasSegunFormasPago_Modelo.Count)
                            {
                                lst_INTERNO_FechasSegunFormasPago_Modelo[int_Contador].Importe = (_dcm_Importe_Total_Final - _dcm_Importe_TotalCobros_Albaranes) - dcm_Importe_PorFecha_Total;
                            }
                            //Resto
                            else
                            {
                                dcm_Importe_PorFecha = Calcular_SegunFormaPago_Importe_Porcentaje(  _dcm_Importe_Total_BaseImponible, 
                                                                                                    _dcm_Importe_Total_Final,
                                                                                                    _dcm_Importe_TotalCobros_Albaranes,
                                                                                                    lst_MAE_FormasPago_Detalle[int_Contador].porcentaje, 
                                                                                                    int_TipoAplicacionImpuesto,int_Contador==0);

                                lst_INTERNO_FechasSegunFormasPago_Modelo[int_Contador].Importe = dcm_Importe_PorFecha;

                                dcm_Importe_PorFecha_Total += dcm_Importe_PorFecha;
                            }
                        }
                    }
                    #endregion
                }
            }
            catch (Exception ex)
            {
                Control_Errores.Errores_Log("", ex, nameof(Funciones) + "/" + nameof(Calcular_Fechas_SegunFormarPago));
            }

            return lst_INTERNO_FechasSegunFormasPago_Modelo;
        }

        /// <summary>
        /// Funcion que mira si tiene dias por defecto de cobro, y segun la fecha ponemos el mas cerca que este, siempre mirnado hacia delante
        /// </summary>
        /// <param name="_dtt_Fecha"></param>
        /// <param name="_int_Dia1"></param>
        /// <returns></returns>
        private static DateTime Calcular_DiaExacto(DateTime _dtt_Fecha,int _int_Dia1)
        {
            int int_Dia_Fecha_INICIAL = _dtt_Fecha.Day;
            int int_Mes_Fecha_INICIAL = _dtt_Fecha.Month;
            int int_Anyo_Fecha_INICIAL = _dtt_Fecha.Year;

            int int_Dia_Fecha_FINAL = _dtt_Fecha.Day;
            int int_Mes_Fecha_FINAL = _dtt_Fecha.Month;
            int int_Anyo_Fecha_FINAL = _dtt_Fecha.Year;

            //Solo tiene Dia 1
            if (_int_Dia1 > 0)
            {
                //Si el dia de la fecha es menor o igual al Dia1
                if (int_Dia_Fecha_INICIAL <= _int_Dia1)
                {
                    int_Dia_Fecha_FINAL = _int_Dia1;
                }
                //El dia de la fecha es mayor que el Dia1, se pone el Dia1 y se suma un mes a la fecha, y un año si fuera mes de diciembre
                else 
                {
                    int_Dia_Fecha_FINAL = _int_Dia1;

                    //Si estamos en diciembre, pongo el mes 1 y le sumo un año
                    if (int_Mes_Fecha_FINAL == 12)
                    {
                        int_Mes_Fecha_FINAL = 1;
                        int_Anyo_Fecha_FINAL += 1;
                    }
                    else
                    {
                        int_Mes_Fecha_FINAL += 1;
                    }
                }
            }

            return new DateTime(int_Anyo_Fecha_FINAL, int_Mes_Fecha_FINAL, int_Dia_Fecha_FINAL);
        }

        private static INTERNO_FechasSegunFormasPago_Modelo Calcular_SegunFormaPago_Fecha(ref DateTime _dtt_FechaParaCalculo,
                                                                                          MAE_FormasPago _mdl_MAE_FormasPago,
                                                                                          int _int_Meses,
                                                                                          int int_Dias)
        {
            INTERNO_FechasSegunFormasPago_Modelo mdl_INTERNO_FechasSegunFormasPago_Modelo = null;

            try
            {
                //Primera Fecha a Calcular (Quitar Horas y minutos) ........................................................................
                _dtt_FechaParaCalculo = new DateTime(_dtt_FechaParaCalculo.Year, _dtt_FechaParaCalculo.Month, _dtt_FechaParaCalculo.Day);
                //Primero se añaden los meses de desplazamiento Inical
                if (_int_Meses > 0)
                {
                    _dtt_FechaParaCalculo = _dtt_FechaParaCalculo.AddMonths(_int_Meses);
                }

                //y luego se añaden los dias de desplazamiento Inical
                if (int_Dias > 0)
                {
                    _dtt_FechaParaCalculo = _dtt_FechaParaCalculo.AddDays(int_Dias);
                }

                int int_DiaDelMes = 0;

                //ULTIMO DIA
                if (_mdl_MAE_FormasPago==null || _mdl_MAE_FormasPago.tipoInicio==null)
                {
                    int_DiaDelMes = _dtt_FechaParaCalculo.Day;
                }
                else
                {
                    if (_mdl_MAE_FormasPago.tipoInicio.Equals(Variables.G_MDL_TIPOINICIO_ULTIMODIA.Codigo))
                    {
                        //Creo un datetime con el mes empezando en 1
                        DateTime dtt_UlitmoDiaMes = new DateTime(_dtt_FechaParaCalculo.Year, _dtt_FechaParaCalculo.Month, 1);

                        //Le añado un mes y le resto un dia y obtengo el ultimo dia del mes
                        int_DiaDelMes = dtt_UlitmoDiaMes.AddMonths(1).AddDays(-1).Day;
                    }
                    //DIA DEL MES
                    else if (_mdl_MAE_FormasPago.tipoInicio.Equals(Variables.G_MDL_TIPOINICIO_DIA.Codigo))
                    {
                        int int_Dia = _mdl_MAE_FormasPago.tipoInicio_Dia != null ? _mdl_MAE_FormasPago.tipoInicio_Dia.Value : 0;

                        //Si el mes es febrero 0 el dia es 31 cogemos el ultimo del mes por si se trata de un mes con menos de 31 dias
                        if ((int_Dia > 28 && _dtt_FechaParaCalculo.Month.Equals(2)) ||
                                int_Dia >= 31)
                        {
                            //Creo un datetime con el mes empezando en 1
                            DateTime dtt_UlitmoDiaMes = new DateTime(_dtt_FechaParaCalculo.Year, _dtt_FechaParaCalculo.Month, 1);

                            //Le añado un mes y le resto un dia y obtengo el ultimo dia del mes
                            int_DiaDelMes = dtt_UlitmoDiaMes.AddMonths(1).AddDays(-1).Day;
                        }

                        int_DiaDelMes = int_Dia;
                    }
                }

                _dtt_FechaParaCalculo = Calcular_DiaExacto(_dtt_FechaParaCalculo, int_DiaDelMes);
                mdl_INTERNO_FechasSegunFormasPago_Modelo = new INTERNO_FechasSegunFormasPago_Modelo(_dtt_FechaParaCalculo);
            }
            catch (Exception ex)
            {
                Control_Errores.Errores_Log("", ex, nameof(Funciones) + "/" + nameof(Calcular_SegunFormaPago_Fecha));
            }

            return mdl_INTERNO_FechasSegunFormasPago_Modelo;
        }

        private static decimal Calcular_SegunFormaPago_Importe_Porcentaje(decimal _dcm_Importe_Total_BaseImponible,
                                                                          decimal _dcm_Importe_Total_Final,
                                                                          decimal _dcm_Importe_TotalCobros_Albaranes,
                                                                          decimal _dcm_Porcentaje,
                                                                          int _int_tipoAplicacionImpuesto,
                                                                          bool _bol_Primero)
        {
            decimal dcm_Importe_Final = 0;
            decimal dcm_Importe_ConPorcentaje = 0;
            try
            {
                //Aplicar los impuesto al prmero
                if (_int_tipoAplicacionImpuesto == Variables.G_INT_TIPOAPLICACIONIMPUESTO_APLICARPRIMERVENCIMIENTO)
                {

                    if ((_dcm_Importe_Total_BaseImponible - _dcm_Importe_TotalCobros_Albaranes) <=0)
                    {
                        dcm_Importe_ConPorcentaje = (_dcm_Importe_Total_Final- _dcm_Importe_TotalCobros_Albaranes) * _dcm_Porcentaje;
                    }
                    else
                    {
                        dcm_Importe_ConPorcentaje = (_dcm_Importe_Total_BaseImponible - _dcm_Importe_TotalCobros_Albaranes ) * _dcm_Porcentaje;
                    }
                    dcm_Importe_Final = Funciones.RedondearDecimal(dcm_Importe_ConPorcentaje / 100, 2);

                    //Aplicar los impuestos
                    if (_bol_Primero)
                    {
                        dcm_Importe_Final += (_dcm_Importe_Total_Final - _dcm_Importe_Total_BaseImponible);
                    }

                    //resultado Final
                    dcm_Importe_Final = Funciones.RedondearDecimal(dcm_Importe_Final, 2);
                }
                //aplicar los impuesto al ultimo
                else if (_int_tipoAplicacionImpuesto == Variables.G_INT_TIPOAPLICACIONIMPUESTO_APLICARULTIMOVENCIMIENTO)
                {
                    if ((_dcm_Importe_Total_BaseImponible - _dcm_Importe_TotalCobros_Albaranes) <= 0)
                    {
                        dcm_Importe_ConPorcentaje = (_dcm_Importe_Total_Final - _dcm_Importe_TotalCobros_Albaranes) * _dcm_Porcentaje;
                    }
                    else
                    {
                        dcm_Importe_ConPorcentaje = (_dcm_Importe_Total_BaseImponible - _dcm_Importe_TotalCobros_Albaranes) * _dcm_Porcentaje;
                    }
                    dcm_Importe_Final = Funciones.RedondearDecimal(dcm_Importe_ConPorcentaje / 100, 2);
                }
                //proporcional
                else 
                {

                    dcm_Importe_ConPorcentaje = (_dcm_Importe_Total_Final - _dcm_Importe_TotalCobros_Albaranes) * _dcm_Porcentaje;
                    //resultado Final
                    dcm_Importe_Final = Funciones.RedondearDecimal(dcm_Importe_ConPorcentaje / 100, 2);
                }

               
            }
            catch (Exception ex)
            {
                Control_Errores.Errores_Log("", ex, nameof(Funciones) + "/" + nameof(Calcular_SegunFormaPago_Importe_Porcentaje));
            }

            return dcm_Importe_Final;
        }
        #endregion

        #region Ficheros
        public static string Transformar_Ruta(string _str_Fichero_Ruta, string _str_Fichero_Nombre,string _str_Extension,List<INTERNO_CodigoDescripcion_Modelo> _lst_INTERNO_CodigoDescripcion_Modelo)
        {
            return Transformar_Ruta(_str_Fichero_Ruta, _str_Fichero_Nombre,_str_Extension,_lst_INTERNO_CodigoDescripcion_Modelo,true);
        }
        public static string Transformar_Ruta(string _str_Fichero_Ruta, string _str_Fichero_Nombre, string _str_Extension, List<INTERNO_CodigoDescripcion_Modelo> _lst_INTERNO_CodigoDescripcion_Modelo,bool _bol_ValidarNOmbreFichero)
        {
            string str_Ruta_Final = "";

            try
            {
                if (_lst_INTERNO_CodigoDescripcion_Modelo != null)
                {
                    foreach (INTERNO_CodigoDescripcion_Modelo mdl_INTERNO_CodigoDescripcion_Modelo in _lst_INTERNO_CodigoDescripcion_Modelo)
                    {
                        _str_Fichero_Ruta = _str_Fichero_Ruta.Replace(mdl_INTERNO_CodigoDescripcion_Modelo.Codigo, mdl_INTERNO_CodigoDescripcion_Modelo.Descripcion);
                        _str_Fichero_Nombre = _str_Fichero_Nombre.Replace(mdl_INTERNO_CodigoDescripcion_Modelo.Codigo, mdl_INTERNO_CodigoDescripcion_Modelo.Descripcion);
                    }
                }

                //Ver si existe el Directorio
                string str_Nombre_Fichero_Final = "";
                if (_bol_ValidarNOmbreFichero)
                {
                    str_Nombre_Fichero_Final = Validar_NombreFichero(_str_Fichero_Ruta, _str_Fichero_Nombre, _str_Extension);
                }
                else
                {
                    str_Nombre_Fichero_Final = NombreFichero(_str_Fichero_Ruta, _str_Fichero_Nombre);
                }

                str_Ruta_Final = _str_Fichero_Ruta + @"\" + str_Nombre_Fichero_Final + _str_Extension;

            }
            catch (Exception ex)
            {
                throw new Control_Errores("", ex, nameof(Funciones) + "/" + nameof(Transformar_Ruta), true);
            }

            return str_Ruta_Final;
        }
        public static string NombreFichero(string _str_Fichero_Ruta, string _str_Fichero_Nombre)
        {
            string str_NombreFichero_Final = "";

            try
            {
                //Ver si existe el Directorio
                Existe_Directorio(_str_Fichero_Ruta, _str_Fichero_Nombre);

                str_NombreFichero_Final = _str_Fichero_Nombre;
                    
            }
            catch (Exception ex)
            {
                throw new Control_Errores("", ex, nameof(Funciones) + "/" + nameof(NombreFichero), true);
            }

            return str_NombreFichero_Final;
        }
        public static string Validar_NombreFichero(string _str_Fichero_Ruta, string _str_Fichero_Nombre, string _str_Extension)
        {
            string str_NombreFichero_Final = "";

            try
            {
                //Ver si existe el Directorio
                Existe_Directorio(_str_Fichero_Ruta, _str_Fichero_Nombre);

                int int_Contador = 0;
                string str_NumeroDocumento_Repetido = "";
                while (str_NombreFichero_Final == "")
                {
                    int_Contador += 1;

                    if (!File.Exists(_str_Fichero_Ruta + @"\" + _str_Fichero_Nombre + str_NumeroDocumento_Repetido + _str_Extension))
                    {
                        str_NombreFichero_Final = _str_Fichero_Nombre + str_NumeroDocumento_Repetido;
                    }
                    else
                    {
                        str_NumeroDocumento_Repetido = "(" + int_Contador + ")";
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Control_Errores("", ex, nameof(Funciones) + "/" + nameof(Validar_NombreFichero), true);
            }

            return str_NombreFichero_Final;
        }

        public static void Existe_Directorio(string _str_Fichero_Ruta, string _str_Fichero_Nombre)
        {
            try
            {
                if (!Directory.Exists(_str_Fichero_Ruta))
                {
                    Directory.CreateDirectory(_str_Fichero_Ruta);
                }
            }
            catch (Exception ex)
            {
               throw new Control_Errores("", ex, nameof(Funciones) + "/" + nameof(Existe_Directorio),true);
            }
        }
        #endregion

        public static string RellenarConCeros(string _str_Cadena, int _int_AnchoCadena, int _int_TipoPosicion)
        {
            string str_Resultado = "";

            if (_str_Cadena==null)
            {
                _str_Cadena = "";
            }

            //Se comprueba si es mayor 
            if (_str_Cadena.Length > _int_AnchoCadena)
            {
                str_Resultado = _str_Cadena.Substring(0, _int_AnchoCadena);
            }
            else
            {
                string str_Ceros = "0";
                int int_numeroceros = _int_AnchoCadena - _str_Cadena.Length;

                if (int_numeroceros != 0)
                {
                    for (int int_Contador = 1; int_Contador < int_numeroceros; int_Contador++)
                    {
                        str_Ceros += "0";
                    }
                }
                else
                {
                    str_Ceros = "";
                }

                //Se mira donde van los ceros si delante "1" o detras "2"
                if (_int_TipoPosicion == 1)
                {
                    str_Resultado = str_Ceros + _str_Cadena;
                }
                else if (_int_TipoPosicion == 2)
                {
                    str_Resultado = _str_Cadena + str_Ceros;
                }
            }
            return str_Resultado;
        }

        public static string RellenarConEspacios(string _str_Cadena, int _int_AnchoCadena, int _int_TipoPosicion)
        {
            string str_Resultado = "";
            string str_Ceros = " ";

            for (int int_Contador = 1; int_Contador < _int_AnchoCadena; int_Contador++)
            {
                str_Ceros += " ";
            }


            //Se mira donde van los ceros si delante "1" o detras "2"
            if (_int_TipoPosicion == 1)
            {
                str_Resultado = str_Ceros + _str_Cadena;
            }
            else if (_int_TipoPosicion == 2)
            {
                str_Resultado = _str_Cadena + str_Ceros;
            }

            return str_Resultado;
        }

        public static string Formatear_Importe(string _str_Importe)
        {
            string str_Resultado = "";

            if (_str_Importe.IndexOf(",") != -1)
            {
                _str_Importe = _str_Importe.Replace(",", ".");
            }

            if (_str_Importe.IndexOf(".") != -1)
            {
                string str_ParteDecimal = _str_Importe.Split('.')[1];
                if (str_ParteDecimal.Length > 2)
                {
                    str_ParteDecimal = str_ParteDecimal.Substring(0, 2);
                }
                else if (str_ParteDecimal.Length == 1)
                {
                    str_ParteDecimal += "0";
                }

                str_Resultado = _str_Importe.Substring(0, _str_Importe.IndexOf(".")) + "." + str_ParteDecimal;
            }
            else
            {
                str_Resultado = _str_Importe + ".00";
            }

            return str_Resultado;
        }

        public static string Calcular_ClaveEmisora(string _str_NRBE_INE)
        {
            _str_NRBE_INE = Funciones.RellenarConCeros(_str_NRBE_INE, 5, 1);

            _str_NRBE_INE += (((Convert.ToInt32(_str_NRBE_INE.Substring(0, 1)) * 6) +
                             (Convert.ToInt32(_str_NRBE_INE.Substring(1, 1)) * 5) +
                             (Convert.ToInt32(_str_NRBE_INE.Substring(2, 1)) * 4) +
                             (Convert.ToInt32(_str_NRBE_INE.Substring(3, 1)) * 3) +
                             (Convert.ToInt32(_str_NRBE_INE.Substring(4, 1)) * 2)) % 11);
            _str_NRBE_INE = _str_NRBE_INE.Substring(0, 2) + " " + _str_NRBE_INE.Substring(2, 3) + " " + _str_NRBE_INE.Substring(5, 1);

            return _str_NRBE_INE;
        }

        public static string Calcular_Referencia_Vencimiento(string _str_ClaveEmisora, string _str_Identificador,long _lng_NumeroFactura, long _lng_CodigoVencimiento, string _str_Importe)
        {

            string str_ReferenciaSinDigitos = RellenarConCeros(_lng_NumeroFactura.ToString(), 7, 1) + RellenarConCeros(_lng_CodigoVencimiento.ToString(), 3, 1);

            //variables
            decimal dcm_Emisora = Convert.ToDecimal(_str_ClaveEmisora.Replace(" ", ""));
            decimal dcm_Factura_Vencimiento = Convert.ToDecimal(str_ReferenciaSinDigitos);
            decimal dcm_Identificador = Convert.ToDecimal(_str_Identificador.Replace(" ", ""));
            decimal dcm_Importe = Convert.ToDecimal(_str_Importe.Replace(".",",")) * 100;

            //variables auxiales
            decimal dcm_Aux = 0;
            decimal dcm_Decimales;
            decimal dcm_Digito_control;
            string str_Digito_control;
            string str_Resultado = "0";

            dcm_Emisora = dcm_Emisora * 76;
            dcm_Factura_Vencimiento = dcm_Factura_Vencimiento * 9;
            dcm_Aux = ((dcm_Identificador + dcm_Importe) - 1) * 55;

            dcm_Aux = Funciones.RedondearDecimal(((dcm_Aux + dcm_Factura_Vencimiento + dcm_Emisora) / 97),5);

            //Si tiene decimales cogemos los dos primeros
            if (dcm_Aux.ToString().IndexOf(",") > 0)
            {
                dcm_Decimales = Convert.ToInt32(dcm_Aux.ToString().Substring(dcm_Aux.ToString().IndexOf(",") + 1, 2));
            }
            else
            {
                dcm_Decimales = 0;
            }

            dcm_Digito_control = 99 - dcm_Decimales;

            if (dcm_Digito_control==0)
            {
                dcm_Digito_control = 99;
            }

            str_Digito_control = dcm_Digito_control.ToString();

            if (str_Digito_control.Length == 1)
            {
                str_Digito_control = "0" + str_Digito_control;
            }

            str_Resultado = str_ReferenciaSinDigitos + str_Digito_control;

            //En la posicion 10 pongo un espacio en blanco
            return str_Resultado.Insert(10, " ");
        }

        public static bool Comprobar_Parametros_Dentro_Parametros(string _str_Texto,int _int_Posicion_DentroTexto)
        {
            bool bol_ValorDevuelto = false;

            if (_int_Posicion_DentroTexto > 0)
            {
                string str_ValorTexto_HastaPosicion = _str_Texto.Substring(0, _int_Posicion_DentroTexto);

                int int_Posicion_Corchete_Abierto = str_ValorTexto_HastaPosicion.LastIndexOf("[");
                int int_Posicion_Corchete_Cerrado = str_ValorTexto_HastaPosicion.LastIndexOf("]");

                //Si no encontro ningun corchete ni cerrado ni abierto, no hay variables
                if (int_Posicion_Corchete_Abierto == -1 && int_Posicion_Corchete_Cerrado == -1)
                {
                    bol_ValorDevuelto = false;
                }
                //Si encontro un corchete abierto y ninguno cerrado, estoy dentro varibles
                else if (int_Posicion_Corchete_Abierto > -1 && int_Posicion_Corchete_Cerrado == -1)
                {
                    bol_ValorDevuelto = true;
                }
                //Si hay antes un corchete abierto que un cerrado, estoy dentro de una variable
                else if (int_Posicion_Corchete_Abierto > -1 && int_Posicion_Corchete_Cerrado > -1)
                {
                    int int_CorcheteCerrado = str_ValorTexto_HastaPosicion.Length - (str_ValorTexto_HastaPosicion.LastIndexOf("]") + 1);
                    int int_CorcheteAbierto = str_ValorTexto_HastaPosicion.Length - (str_ValorTexto_HastaPosicion.LastIndexOf("[") + 1);

                    if (int_CorcheteAbierto < int_CorcheteCerrado)
                    {
                        bol_ValorDevuelto = true;
                    }
                }
                else
                {
                    bol_ValorDevuelto = false;
                }
            }
            
            return bol_ValorDevuelto;
        }

        public static string Transformar_Texto_Con_Parametros(string _str_Texto, List<INTERNO_CodigoDescripcion_Modelo> _lst_INTERNO_CodigoDescripcion_Modelo)
        {
            try
            {
                if (_lst_INTERNO_CodigoDescripcion_Modelo != null)
                {
                    foreach (INTERNO_CodigoDescripcion_Modelo mdl_INTERNO_CodigoDescripcion_Modelo in _lst_INTERNO_CodigoDescripcion_Modelo)
                    {
                        _str_Texto = _str_Texto.Replace(mdl_INTERNO_CodigoDescripcion_Modelo.Codigo, mdl_INTERNO_CodigoDescripcion_Modelo.Descripcion);
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Control_Errores("", ex, nameof(Funciones) + "/" + nameof(Transformar_Texto_Con_Parametros), true);
            }

            return _str_Texto;
        }

        // Denominaciones
        public static void Rellenar_Denominaciones()
        {
            //Limpiamos los listados por si se llamara mas de una vez al metodo
            Variables.G_LST_DENOMINACIONES.Clear();

            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("001", "IMPUESTO SOBRE BIENES INMUEBLES (URBANA)"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("002", "IMPUESTO SOBRE BIENES INMUEBLES (RÚSTICA)"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("003", "IMPUESTO SOBRE VEHÍCULOS DE TRACCIÓN MECÁNICA"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("004", "IMPUESTO SOBRE INCREMENTO DEL VALOR DE LOS TERRENOS"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("005", "IMPUESTO SOBRE CONSTRUCCIONES, INSTALACIONES Y OBRAS"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("010", "IMPUESTO SOBRE ACTIVIDADES ECONÓMICAS"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("011", "TASA BASURAS DOMICILIARIAS"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("012", "TASA BASURAS COMERCIALES"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("013", "TASA BASURAS INDUSTRIALES"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("014", "TASA DE ELIMINACIÓN RESIDUOS SÓLIDOS"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("015", "TASA ALCANTARILLADO"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("016", "TASA DE CEMENTERIO MUNICIPAL"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("017", "TASA DE INSPECCIÓN"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("018", "TASA POR EXPEDICIÓN DE DOCUMENTOS"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("019", "TASA POR LICENCIA AUTO-TAXI, VEHÍCULOS ALQUILER"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("020", "TASA POR LICENCIAS URBANÍSTICAS"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("021", "TASA POR LICENCIA APERTURA ESTABLECIMIENTOS"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("022", "TASA POR RETIRADA VEHÍCULOS VÍA PÚBLICA"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("023", "TASA DE SANEAMIENTO"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("024", "TASA POR SEVICIOS ESPECTÁCULOS PÚBLICOS"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("025", "TASA DE BASURAS DE MERCADOS MUNICIPALES"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("041", "PRECIO PÚBLICO POR ENTRADA VEHÍCULOS (VADOS)"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("042", "PRECIO PÚBLICO POR SUMINISTRO DE AGUAS"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("043", "PRECIO PÚBLICO POR OCUPACIÓN SUELO, SUBSUELO Y VUELO DE LA VÍA PÚBLICA"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("044", "PRECIO PÚBLICO POR OCUPACIÓN VÍA PÚBLICA"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("045", "PRECIO PÚBLICO POR PARADAS MERCADO MUNICIPAL"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("046", "PRECIO PÚBLICO POR GUARDERÍA"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("047", "PRECIO PÚBLICO POR INSTALCIONES DEPORTIVAS"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("048", "PRECIO PÚBLICO POR MATADERO MUNICIPAL"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("049", "PRECIO PÚBLICO POR PRESTACIONES PERSONALES"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("050", "PRECIO PÚBLICO POR VIGILANCIA"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("051", "PRECIO PÚBLICO POR COMEDORES ESCOLARES"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("052", "PRECIO PÚBLICO CENTROS DOCENTES ESCOLARES"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("053", "PRECIO PÚBLICO SOBRE RODAJE Y ARRASTRE DE VEHÍCULOS"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("054", "PRECIO PÚBLICO LUCHA CONTRA LA PIEDRA"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("055", "PRECIO PÚLICO POR EXHIBICIÓN DE RÓTULOS"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("056", "PRECIO PÚBLICO SOBRE RIELES, CABLES, PALOS, ETC."));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("057", "PRECIO PÚBLICO POR APROVECHAMIETOS ESPECIALES"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("058", "PRECIO PÚBLICO INSTALACIÓN DE APARADORES Y VITRINAS"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("059", "SERVICIOS SANITARIAS"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("060", "PRECIO PÚBLICO SOBRE INSTALACIONES EN TERRENOS DE USO PÚBLICO"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("061", "CONTRIBUCIONES ESPECIALES"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("062", "I.V.A. REDUCIDO"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("063", "I.V.A. ORDINARIO"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("064", "MULTAS"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("065", "ALQUILER SEPULTURAS"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("066", "TENENCIA DE PERROS"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("067", "INTERESES DE DEMORA"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("068", "RECARGO DE APREMIO"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("069", "MÁQUINAS RECREATIVAS"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("070", "ALTA VEHÍCULOS TRACCIÓN MECÁNICA"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("071", "INGRESOS DIRECTOS"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("072", "BICICLETAS"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("073", "OTROS INGRESOS TRIBUTARIOS"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("074", "TASA GARANTÍA SUMINISTRO"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("091", "AGRUPACIÓN DE TRIBUTOS SOBRE INDUSTRIA-COMERCIO"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("092", "AGRUPACIÓN DE TRIBUTOS SOBRE INMUEBLES"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("096", "AGRUPACIÓN CONCEPTOS EN LIQUIDACIONES POR INGRESO DIRECTO"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("097", "CÁMARA PROPIEDAD URBANA"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("098", "CÁMARA DE COMERCIO"));
            Variables.G_LST_DENOMINACIONES.Add(new INTERNO_CodigoDescripcion_Modelo("099", "CÁMARA DE COMERCIO. COMPLEMENTO"));
        }

        // Rellenar Opcion tabla campo codigo para poder cambiar el tipo de datos de alfanumerico a numerico
        public static void Rellenar_OpcionTablaCampoCodigo()
        {
            //Limpiamos los listados por si se llamara mas de una vez al metodo
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Clear();

            //AGD
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_AGD_CITAS, new INTERNO_TablaCampoCodigo_Modelo(nameof(AGD_Citas), nameof(AGD_Citas.codigo)));

            //CTA
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_CTA_CLAVEANALITICA, new INTERNO_TablaCampoCodigo_Modelo(nameof(CTA_ClavesAnaliticas), nameof(CTA_ClavesAnaliticas.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_CTA_CONCEPTO, new INTERNO_TablaCampoCodigo_Modelo(nameof(CTA_Conceptos), nameof(CTA_Conceptos.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_CTA_DEPARTAMENTO, new INTERNO_TablaCampoCodigo_Modelo(nameof(CTA_Departamentos), nameof(CTA_Departamentos.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_CTA_MAYORAUXILIAR, new INTERNO_TablaCampoCodigo_Modelo(nameof(CTA_MayorAuxiliar), nameof(CTA_MayorAuxiliar.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_CTA_PREDEFINIDOAUXILIAR, new INTERNO_TablaCampoCodigo_Modelo(nameof(CTA_PredefinidosAuxiliares), nameof(CTA_PredefinidosAuxiliares.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_CTA_PREDEFINIDOCABECERA, new INTERNO_TablaCampoCodigo_Modelo(nameof(CTA_PredefinidosCabeceras), nameof(CTA_PredefinidosCabeceras.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_CTA_PREDEFINIDOCONCEPTO, new INTERNO_TablaCampoCodigo_Modelo(nameof(CTA_PredefinidosConceptos), nameof(CTA_PredefinidosConceptos.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_CTA_PREDEFINIDOCUENTA, new INTERNO_TablaCampoCodigo_Modelo(nameof(CTA_PredefinidosCuentas), nameof(CTA_PredefinidosCuentas.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_CTA_PREDEFINIDOENTIDAD, new INTERNO_TablaCampoCodigo_Modelo(nameof(CTA_PredefinidosEntidades), nameof(CTA_PredefinidosEntidades.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_CTA_PREDEFINIDOFECHA, new INTERNO_TablaCampoCodigo_Modelo(nameof(CTA_PredefinidosFechas), nameof(CTA_PredefinidosFechas.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_CTA_PREDEFINIDOFICHERO, new INTERNO_TablaCampoCodigo_Modelo(nameof(CTA_PredefinidosFicheros), nameof(CTA_PredefinidosFicheros.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_CTA_PREDEFINIDOIMPORTE, new INTERNO_TablaCampoCodigo_Modelo(nameof(CTA_PredefinidosImportes), nameof(CTA_PredefinidosImportes.codigo)));

            //CTG
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_CTG_CONCEPTO, new INTERNO_TablaCampoCodigo_Modelo(nameof(CTG_Conceptos), nameof(CTG_Conceptos.codigo)));

            //COM
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_COM_FACTURACABECERA_AUX, new INTERNO_TablaCampoCodigo_Modelo(nameof(COM_FacturasCabecera), nameof(COM_FacturasCabecera.numeroFactura)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_COM_FACTURACABECERA_AUX_2, new INTERNO_TablaCampoCodigo_Modelo(nameof(COM_FacturasCabecera), nameof(COM_FacturasCabecera.numeroFactura)));

            //EPD
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_EPD_ASESORES, new INTERNO_TablaCampoCodigo_Modelo(nameof(EPD_Asesores), nameof(EPD_Asesores.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_EPD_ACTORES, new INTERNO_TablaCampoCodigo_Modelo(nameof(EPD_Actores), nameof(EPD_Actores.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_EPD_CITACIONES, new INTERNO_TablaCampoCodigo_Modelo(nameof(EPD_Citaciones), nameof(EPD_Citaciones.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_EPD_MATERIAS, new INTERNO_TablaCampoCodigo_Modelo(nameof(EPD_Materias), nameof(EPD_Materias.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_EPD_JUZGADOS, new INTERNO_TablaCampoCodigo_Modelo(nameof(EPD_Juzgados), nameof(EPD_Juzgados.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_EPD_DEMANDADOS, new INTERNO_TablaCampoCodigo_Modelo(nameof(EPD_Demandados), nameof(EPD_Demandados.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_EPD_EXPEDIENTES, new INTERNO_TablaCampoCodigo_Modelo(nameof(EPD_Expedientes), nameof(EPD_Expedientes.codigo)));
            
          

            //GEN
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_GEN_ADMINISTRACIONES, new INTERNO_TablaCampoCodigo_Modelo(nameof(GEN_Administraciones), nameof(GEN_Administraciones.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_GEN_ALMACEN,new INTERNO_TablaCampoCodigo_Modelo(nameof(GEN_Almacenes), nameof(GEN_Almacenes.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_GEN_DELEGACION,new INTERNO_TablaCampoCodigo_Modelo(nameof(GEN_Delegaciones), nameof(GEN_Delegaciones.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_GEN_EMPRESA,new INTERNO_TablaCampoCodigo_Modelo(nameof(GEN_Empresas), nameof(GEN_Empresas.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_GEN_ENTIDADBANCARIA,new INTERNO_TablaCampoCodigo_Modelo(nameof(GEN_EntidadesBancarias), nameof(GEN_EntidadesBancarias.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_GEN_IMPUESTOCABECERA,new INTERNO_TablaCampoCodigo_Modelo(nameof(GEN_ImpuestosCabecera), nameof(GEN_ImpuestosCabecera.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_GEN_IMPUESTOTIPO,new INTERNO_TablaCampoCodigo_Modelo(nameof(GEN_ImpuestosTipos), nameof(GEN_ImpuestosTipos.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_GEN_MONEDA, new INTERNO_TablaCampoCodigo_Modelo(nameof(GEN_Monedas), nameof(GEN_Monedas.moneda)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_GEN_PROVINCIA,new INTERNO_TablaCampoCodigo_Modelo(nameof(GEN_Provincias), nameof(GEN_Provincias.codigo)));

            //GTT
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_GTT_CONCEPTO,new INTERNO_TablaCampoCodigo_Modelo(nameof(GTT_Conceptos), nameof(GTT_Conceptos.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_GTT_SOCIO,new INTERNO_TablaCampoCodigo_Modelo(nameof(GTT_Socios), nameof(GTT_Socios.codigo)));

            //INF
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_INF_CONFIGURACIONVENCIMIENTO_SOCIO,new INTERNO_TablaCampoCodigo_Modelo(nameof(INF_ConfiguracionVencimientos_Socios), nameof(INF_ConfiguracionVencimientos_Socios.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_INF_IMPRESORAS,new INTERNO_TablaCampoCodigo_Modelo(nameof(INF_Impresoras), nameof(INF_Impresoras.codigo)));

            //MAE
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_MAE_ABONOTIPO,new INTERNO_TablaCampoCodigo_Modelo(nameof(MAE_AbonosTipos), nameof(MAE_AbonosTipos.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_MAE_ARTICULO,new INTERNO_TablaCampoCodigo_Modelo(nameof(MAE_Articulos), nameof(MAE_Articulos.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_MAE_CATEGORIAPROFESIONAL,new INTERNO_TablaCampoCodigo_Modelo(nameof(MAE_CategoriasProfesionales), nameof(MAE_CategoriasProfesionales.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_MAE_CLIENTE,new INTERNO_TablaCampoCodigo_Modelo(nameof(MAE_Clientes), nameof(MAE_Clientes.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_MAE_DEPARTAMENTOSEXTERNOS,new INTERNO_TablaCampoCodigo_Modelo(nameof(MAE_DepartamentosExternos), nameof(MAE_DepartamentosExternos.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_MAE_EMBALAJE,new INTERNO_TablaCampoCodigo_Modelo(nameof(MAE_Embalajes), nameof(MAE_Embalajes.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_MAE_EMPLEADO,new INTERNO_TablaCampoCodigo_Modelo(nameof(MAE_Empleados), nameof(MAE_Empleados.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_MAE_FORMADEPAGO,new INTERNO_TablaCampoCodigo_Modelo(nameof(MAE_FormasPago), nameof(MAE_FormasPago.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_MAE_MEDIDA,new INTERNO_TablaCampoCodigo_Modelo(nameof(MAE_Medidas), nameof(MAE_Medidas.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_MAE_MOTIVOALTABAJA,new INTERNO_TablaCampoCodigo_Modelo(nameof(MAE_MotivosAltaBaja), nameof(MAE_MotivosAltaBaja.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_MAE_NOMENCLATURAPRECIO,new INTERNO_TablaCampoCodigo_Modelo(nameof(MAE_NomenclaturasPrecios), nameof(MAE_NomenclaturasPrecios.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_MAE_PROVEEDOR,new INTERNO_TablaCampoCodigo_Modelo(nameof(MAE_Proveedores), nameof(MAE_Proveedores.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_MAE_TASA,new INTERNO_TablaCampoCodigo_Modelo(nameof(MAE_Tasas), nameof(MAE_Tasas.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_MAE_TELEFONOTIPO,new INTERNO_TablaCampoCodigo_Modelo(nameof(MAE_TelefonosTipos), nameof(MAE_TelefonosTipos.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_MAE_TESORERIA,new INTERNO_TablaCampoCodigo_Modelo(nameof(MAE_Tesorerias), nameof(MAE_Tesorerias.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_MAE_TIPOPAGO,new INTERNO_TablaCampoCodigo_Modelo(nameof(MAE_TiposPagos), nameof(MAE_TiposPagos.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_MAE_TIPOPRODUCTO,new INTERNO_TablaCampoCodigo_Modelo(nameof(MAE_TiposProductos), nameof(MAE_TiposProductos.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_MAE_TIPOTRANSPORTE,new INTERNO_TablaCampoCodigo_Modelo(nameof(MAE_TiposTransportes), nameof(MAE_TiposTransportes.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_MAE_UBICACION,new INTERNO_TablaCampoCodigo_Modelo(nameof(MAE_Ubicaciones), nameof(MAE_Ubicaciones.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_MAE_UBICACIONPERFIL,new INTERNO_TablaCampoCodigo_Modelo(nameof(MAE_UbicacionesPerfiles), nameof(MAE_UbicacionesPerfiles.codigo)));
            Variables.G_DCT_CONFIGURACIONCAMPOCODIGO_OPCIONTABLACAMPOCODIGO.Add(Variables.G_STR_OPCION_MAE_VENDEDOR, new INTERNO_TablaCampoCodigo_Modelo(nameof(MAE_Vendedores), nameof(MAE_Vendedores.codigo)));

        }

        public static void Cambiar_Icono_Impresora_PantallaPrincipal(int _int_ValorAsignacion)
        {
            try
            {
                //No tiene ninguna impresora local asignada
                if (_int_ValorAsignacion == 0)
                {
                    Variables.G_EX_BTN_IMPRESORASLOCALES_PANTALLAPRINCIPAL.Exferia_Button_ConBorde_Imagen = Imagenes.G_ENUM_IMAGENES.G_IMG_IMPRESORASLOCAL_NOHAY;
                }
                //Tiene alguna impresora local asignada
                else if (_int_ValorAsignacion == 1)
                {
                    Variables.G_EX_BTN_IMPRESORASLOCALES_PANTALLAPRINCIPAL.Exferia_Button_ConBorde_Imagen = Imagenes.G_ENUM_IMAGENES.G_IMG_IMPRESORASLOCAL_HAYALGUNAS;
                }
                else
                {
                    Variables.G_EX_BTN_IMPRESORASLOCALES_PANTALLAPRINCIPAL.Exferia_Button_ConBorde_Imagen = Imagenes.G_ENUM_IMAGENES.G_IMG_IMPRESORASLOCAL;
                }

                Imagenes.Asignar_Imagen(Variables.G_EX_BTN_IMPRESORASLOCALES_PANTALLAPRINCIPAL);
            }
            catch (Exception ex)
            {
                Control_Errores.Errores_Log("", ex, nameof(Funciones) + "/" + nameof(Cambiar_Icono_Impresora_PantallaPrincipal));
            }
        }

        public static string Quitar_CaracteresEspeciales(string _str_Texto)
        {
            string str_ValorDevuelto = _str_Texto;
            try
            {
                str_ValorDevuelto = Regex.Replace(_str_Texto, @"[^0-9A-Za-z]", "", RegexOptions.None);
            }
            catch (Exception ex)
            {
                Control_Errores.Errores_Log("", ex, nameof(Funciones) + "/" + nameof(Quitar_CaracteresEspeciales));
            }

            return str_ValorDevuelto;
        }

        public static byte[] Generar_CodigoQR(string _str_QR)
        {
            byte[] arr_QR = null;
            try
            {
                QrEncoder encoder = new QrEncoder(ErrorCorrectionLevel.H);
                QrCode qrCode;
                encoder.TryEncode(_str_QR, out qrCode);

                GraphicsRenderer gRenderer = new GraphicsRenderer(new FixedModuleSize(50, QuietZoneModules.Two), System.Drawing.Brushes.Black, System.Drawing.Brushes.White);

                MemoryStream ms = new MemoryStream();
                gRenderer.WriteToStream(qrCode.Matrix, ImageFormat.Bmp, ms);
                Image img_QR = Image.FromStream(ms);

                //Rotar Imagen
                img_QR.RotateFlip(System.Drawing.RotateFlipType.Rotate90FlipNone);

                arr_QR = Convertir_Image_Arraybytes(img_QR);
            }
            catch (Exception ex)
            {
                Control_Errores.Errores_Log("", ex, nameof(Funciones) + "/" + nameof(Generar_CodigoQR));
            }

            return arr_QR;
        }

        #region Formar ContenidoIN
        public static string Formar_ContenidoIN_ParaConsultaWhere(string _str_NombreTabla,
                                                                  string _str_NombreCampo,
                                                                  G_ENUM_FORMARCONTENIDOIN_CONDICIONANTES _ENUM_Poner_AND_OR_Nada,
                                                                  List<long> _lst_Valores)
        {


            string str_ValorDevuelto_Final = "";
            try
            {
                if (_lst_Valores!=null && _lst_Valores.Count>0)
                {
                    string str_ValoresIN = "";
                    for (int int_Contador = 0; int_Contador < _lst_Valores.Count; int_Contador++)
                    {
                        str_ValoresIN += _lst_Valores[int_Contador].ToString() + ",";
                    }
                    str_ValoresIN = str_ValoresIN.Substring(0, str_ValoresIN.Length - 1);

                    str_ValorDevuelto_Final = " ( " +
                                                    _str_NombreTabla + "." + _str_NombreCampo + " in " +
                                                        " ( " + str_ValoresIN + " ) " +
                                              " ) ";

                    if (_ENUM_Poner_AND_OR_Nada == G_ENUM_FORMARCONTENIDOIN_CONDICIONANTES.AND_FIN)
                    {
                        str_ValorDevuelto_Final = str_ValorDevuelto_Final +" AND ";
                    }
                    else if (_ENUM_Poner_AND_OR_Nada == G_ENUM_FORMARCONTENIDOIN_CONDICIONANTES.OR_FIN)
                    {
                        str_ValorDevuelto_Final = str_ValorDevuelto_Final +" OR " ;
                    }
                    else if (_ENUM_Poner_AND_OR_Nada == G_ENUM_FORMARCONTENIDOIN_CONDICIONANTES.AND_INICIO)
                    {
                        str_ValorDevuelto_Final = " AND "  + str_ValorDevuelto_Final ;
                    }
                    else if (_ENUM_Poner_AND_OR_Nada == G_ENUM_FORMARCONTENIDOIN_CONDICIONANTES.OR_INICIO)
                    {
                        str_ValorDevuelto_Final = " OR "  + str_ValorDevuelto_Final;
                    }
                }
            }
            catch (Exception ex)
            {
                Control_Errores.Errores_Log("", ex, nameof(Funciones) + "/" + nameof(Formar_ContenidoIN_ParaConsultaWhere));
            }

            return str_ValorDevuelto_Final;
        }
        public static string Formar_ContenidoIN_ParaConsultaWhere(string _str_NombreTabla,
                                                                  string _str_NombreCampo,
                                                                  G_ENUM_FORMARCONTENIDOIN_CONDICIONANTES _ENUM_Poner_AND_OR_Nada,
                                                                  List<string> _lst_Valores)
        {


            string str_ValorDevuelto_Final = "";
            try
            {
                if (_lst_Valores != null && _lst_Valores.Count > 0)
                {
                    string str_ValoresIN = "";
                    for (int int_Contador = 0; int_Contador < _lst_Valores.Count; int_Contador++)
                    {
                        str_ValoresIN += "'" + _lst_Valores[int_Contador] + "',";
                    }
                    str_ValoresIN = str_ValoresIN.Substring(0, str_ValoresIN.Length - 1);

                    str_ValorDevuelto_Final = " ( " +
                                                    _str_NombreTabla + "." + _str_NombreCampo + " in " +
                                                        " ( " + str_ValoresIN + " ) " +
                                              " ) ";

                    if (_ENUM_Poner_AND_OR_Nada == G_ENUM_FORMARCONTENIDOIN_CONDICIONANTES.AND_FIN)
                    {
                        str_ValorDevuelto_Final = str_ValorDevuelto_Final + " AND ";
                    }
                    else if (_ENUM_Poner_AND_OR_Nada == G_ENUM_FORMARCONTENIDOIN_CONDICIONANTES.OR_FIN)
                    {
                        str_ValorDevuelto_Final = str_ValorDevuelto_Final + " OR ";
                    }
                    else if (_ENUM_Poner_AND_OR_Nada == G_ENUM_FORMARCONTENIDOIN_CONDICIONANTES.AND_INICIO)
                    {
                        str_ValorDevuelto_Final = " AND " + str_ValorDevuelto_Final;
                    }
                    else if (_ENUM_Poner_AND_OR_Nada == G_ENUM_FORMARCONTENIDOIN_CONDICIONANTES.OR_INICIO)
                    {
                        str_ValorDevuelto_Final = " OR " + str_ValorDevuelto_Final;
                    }
                }
            }
            catch (Exception ex)
            {
                Control_Errores.Errores_Log("", ex, nameof(Funciones) + "/" + nameof(Formar_ContenidoIN_ParaConsultaWhere));
            }

            return str_ValorDevuelto_Final;
        }

        public static string Formar_ContenidoIN_ParaConsultaWhere(List<long> _lst_Valores)
        {


            string str_ValorDevuelto_Final = "";
            try
            {
                if (_lst_Valores != null && _lst_Valores.Count > 0)
                {
                    string str_ValoresIN = "";
                    for (int int_Contador = 0; int_Contador < _lst_Valores.Count; int_Contador++)
                    {
                        str_ValoresIN += _lst_Valores[int_Contador].ToString() + ",";
                    }
                    str_ValorDevuelto_Final = str_ValoresIN.Substring(0, str_ValoresIN.Length - 1);
                }
            }
            catch (Exception ex)
            {
                Control_Errores.Errores_Log("", ex, nameof(Funciones) + "/" + nameof(Formar_ContenidoIN_ParaConsultaWhere));
            }

            return str_ValorDevuelto_Final;
        }
        public static string Formar_ContenidoIN_ParaConsultaWhere(List<int> _lst_Valores)
        {


            string str_ValorDevuelto_Final = "";
            try
            {
                if (_lst_Valores != null && _lst_Valores.Count > 0)
                {
                    string str_ValoresIN = "";
                    for (int int_Contador = 0; int_Contador < _lst_Valores.Count; int_Contador++)
                    {
                        str_ValoresIN += _lst_Valores[int_Contador].ToString() + ",";
                    }
                    str_ValorDevuelto_Final = str_ValoresIN.Substring(0, str_ValoresIN.Length - 1);
                }
            }
            catch (Exception ex)
            {
                Control_Errores.Errores_Log("", ex, nameof(Funciones) + "/" + nameof(Formar_ContenidoIN_ParaConsultaWhere));
            }

            return str_ValorDevuelto_Final;
        }
        public static string Formar_ContenidoIN_ParaConsultaWhere(List<string> _lst_Valores)
        {


            string str_ValorDevuelto_Final = "";
            try
            {
                if (_lst_Valores != null && _lst_Valores.Count > 0)
                {
                    string str_ValoresIN = "";
                    for (int int_Contador = 0; int_Contador < _lst_Valores.Count; int_Contador++)
                    {
                        str_ValoresIN += "'" + _lst_Valores[int_Contador].ToString() + "',";
                    }
                    str_ValorDevuelto_Final = str_ValoresIN.Substring(0, str_ValoresIN.Length - 1);
                }
            }
            catch (Exception ex)
            {
                Control_Errores.Errores_Log("", ex, nameof(Funciones) + "/" + nameof(Formar_ContenidoIN_ParaConsultaWhere));
            }

            return str_ValorDevuelto_Final;
        }
        #endregion

        #region Botones de Ordenar
        public static void Cambiar_Imagen_Boton_Orden(int _int_Tipo, Exferia_Button _ex_btn_Orden)
        {
            try
            {


                if (_int_Tipo.Equals(1))
                {
                    //Se pone Ascedente
                    _ex_btn_Orden.Tag = "0";
                    _ex_btn_Orden.Exferia_Button_Imagen = Imagenes.G_ENUM_IMAGENES.G_IMG_ORDEN_ASC;

                }
                //Esta Ascendente
                else
                {
                    //Se pone Descedente
                    _ex_btn_Orden.Tag = "1";
                    _ex_btn_Orden.Exferia_Button_Imagen = Imagenes.G_ENUM_IMAGENES.G_IMG_ORDEN_DESC;
                }

                Imagenes.Asignar_Imagen(_ex_btn_Orden);
            }
            catch (Exception ex)
            {
                Control_Errores.Errores_Log("", ex, nameof(Funciones) + "/" + nameof(Cambiar_Imagen_Boton_Orden));
            }
        }
        public static void Poner_Imagen_Boton_Orden_Inicial(Exferia_Button _ex_btn_Orden)
        {
            try
            {
                //Se pone Ascedente
                if (_ex_btn_Orden.Tag.ToString().Equals("0"))
                {
                    _ex_btn_Orden.Exferia_Button_Imagen = Imagenes.G_ENUM_IMAGENES.G_IMG_ORDEN_ASC;
                }
                //Se pone Descedente
                else
                {
                    _ex_btn_Orden.Exferia_Button_Imagen = Imagenes.G_ENUM_IMAGENES.G_IMG_ORDEN_DESC;
                }

                Imagenes.Asignar_Imagen(_ex_btn_Orden);
            }
            catch (Exception ex)
            {
                Control_Errores.Errores_Log("", ex, nameof(Funciones) + "/" + nameof(Poner_Imagen_Boton_Orden_Inicial));
            }
        }
        #endregion

        #region Existencias
        public static List<INTERNO_Existencias_Modelo> Existencias_Calcular(long _lng_idArticulo, DateTime _dtt_FechaDesde, DateTime _dtt_FechaHasta)
        {
            List<INTERNO_Existencias_Modelo> lst_INTERNO_Existencias_Modelo = new List<INTERNO_Existencias_Modelo>();

            try
            {
                #region OBTENCION DE DATOS

                List<INTERNO_Existencias_Busqueda_Modelo> lst_INTERNO_Existencias_Busqueda_Modelo = new List<INTERNO_Existencias_Busqueda_Modelo>();

                #region MOVIMIENTOS DE ARTICULOS
                //Cargamos el ensamblado 
                Assembly m_assembly_MOVIMIENTOSARTICULOS = Assembly.LoadFrom(Variables.G_STR_LIBRERIA_RUTAINICIAL + @"\" + Variables.G_STR_LIBRERIA_MAESTROS + ".dll");
                //Obtenemos el tipo de la clase
                Type m_type_MOVIMIENTOSARTICULOS = m_assembly_MOVIMIENTOSARTICULOS.GetType("" + Variables.G_STR_LIBRERIA_MAESTROS + "." + Variables.G_STR_LIBRERIA_DATOSMAESTROS);
                //creamos la instancia
                var obj_Clase_MOVIMIENTOSARTICULOS = Activator.CreateInstance(m_type_MOVIMIENTOSARTICULOS);
                //Cargamos el metodo solicitado
                MethodInfo obj_MethodInfo_MOVIMIENTOSARTICULOS = obj_Clase_MOVIMIENTOSARTICULOS.GetType().GetMethod(Variables.G_STR_LIBRERIA_DATOSMAESTROS_PROCEDIMIENTO_MAEARTICULOSMOVIMIENTOSDIARIOS_OBTENER_LISTADO_PORFECHAS, BindingFlags.Instance | BindingFlags.NonPublic);

                //Obtener valores
                object[] arr_Parametros_MOVIMIENTOSARTICULOS = { _lng_idArticulo, _dtt_FechaDesde, _dtt_FechaHasta };

                //Pasamos los parametros al metodo y lo ejecutamos
                List<INTERNO_Existencias_MovimientosArticulos_Modelo> lst_INTERNO_Existencias_MovimientosArticulos_Modelo = (List<INTERNO_Existencias_MovimientosArticulos_Modelo>)obj_MethodInfo_MOVIMIENTOSARTICULOS.Invoke(obj_Clase_MOVIMIENTOSARTICULOS, arr_Parametros_MOVIMIENTOSARTICULOS);
                #endregion
                #endregion

                #region CALCULAR
                if (lst_INTERNO_Existencias_MovimientosArticulos_Modelo != null && lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Count > 0)
                {
                    //CREAR LISTADO DE AGRUPADOS
                    List<INTERNO_Existencias_Agrupado_Modelo> lst_Agrupados= lst_INTERNO_Existencias_MovimientosArticulos_Modelo.GroupBy(p => new { p.IdDelegacion, p.IdAlmacen, p.IdUbicacion })
                                                                                                                                .Select(g => new INTERNO_Existencias_Agrupado_Modelo  {   IdDelegacion= g.Key.IdDelegacion,
                                                                                                                                                                                        IdAlmacen = g.Key.IdAlmacen,
                                                                                                                                                                                        IdUbicacion = g.Key.IdUbicacion,
                                                                                                                                                                                    })
                                                                                                                                .ToList();

                 
                    foreach (INTERNO_Existencias_Agrupado_Modelo mdl_INTERNO_Existencias_Agrupado_Modelo in lst_Agrupados)
                    {
                        DateTime dtt_Fecha_Desde = _dtt_FechaDesde;
                        DateTime? dtt_Fecha_Inventario = null;

                        #region Buscar el ultimo inventario para saber la fecha desde que se tiene que coger los datos
                        List<INTERNO_Existencias_MovimientosArticulos_Modelo> lst_Inventarios=lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Where(m => m.Inventario_Cantidad>0m &&
                                                                                                                                                             m.IdDelegacion == mdl_INTERNO_Existencias_Agrupado_Modelo.IdDelegacion &&
                                                                                                                                                             m.IdAlmacen == mdl_INTERNO_Existencias_Agrupado_Modelo.IdAlmacen &&
                                                                                                                                                             (mdl_INTERNO_Existencias_Agrupado_Modelo.IdUbicacion != null
                                                                                                                                                                ? (m.IdUbicacion != null && m.IdUbicacion.Value == mdl_INTERNO_Existencias_Agrupado_Modelo.IdUbicacion.Value)
                                                                                                                                                                : m.IdUbicacion == null)
                                                                                                                                                            ).ToList();
                        if (lst_Inventarios != null && lst_Inventarios.Count>0)
                        {
                            dtt_Fecha_Desde= lst_Inventarios.OrderByDescending(m => m.Fecha).FirstOrDefault().Fecha;
                            dtt_Fecha_Inventario = dtt_Fecha_Desde;
                        }
                        #endregion

                        List<INTERNO_Existencias_MovimientosArticulos_Modelo> lst_Registros = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Where(m => m.Fecha>= dtt_Fecha_Desde &&
                                                                                                                                                               m.IdDelegacion == mdl_INTERNO_Existencias_Agrupado_Modelo.IdDelegacion &&
                                                                                                                                                               m.IdAlmacen == mdl_INTERNO_Existencias_Agrupado_Modelo.IdAlmacen &&
                                                                                                                                                               (mdl_INTERNO_Existencias_Agrupado_Modelo.IdUbicacion != null
                                                                                                                                                                  ? (m.IdUbicacion != null && m.IdUbicacion.Value == mdl_INTERNO_Existencias_Agrupado_Modelo.IdUbicacion.Value)
                                                                                                                                                                  : m.IdUbicacion == null)
                                                                                                                                                            ).ToList();
                        if (lst_Registros != null && lst_Registros.Count > 0)
                        {
                            string str_Ubicacion = "";
                            foreach (INTERNO_Existencias_MovimientosArticulos_Modelo mdl_INTERNO_Existencias_MovimientosArticulos_Modelo in lst_Registros)
                            {
                                str_Ubicacion = "";
                                if (mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.Ubicacion_TipoFuncion != null)
                                {
                                    if (Variables.G_MDL_TIPOFUNCION_MUELLEENTRADA.Codigo == mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.Ubicacion_TipoFuncion)
                                    {
                                        str_Ubicacion = "(" + Variables.G_MDL_TIPOFUNCION_MUELLEENTRADA.Descripcion.ToUpper() + ") ";
                                    }
                                    else if (Variables.G_MDL_TIPOFUNCION_PLAYAPICKING.Codigo == mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.Ubicacion_TipoFuncion)
                                    {
                                        str_Ubicacion = "(" + Variables.G_MDL_TIPOFUNCION_PLAYAPICKING.Descripcion.ToUpper() + ") ";
                                    }
                                    else if (Variables.G_MDL_TIPOFUNCION_RESERVA.Codigo == mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.Ubicacion_TipoFuncion)
                                    {
                                        str_Ubicacion = "(" + Variables.G_MDL_TIPOFUNCION_RESERVA.Descripcion.ToUpper() + ") ";
                                    }
                                    else
                                    {
                                        str_Ubicacion = "(" + Variables.G_MDL_TIPOFUNCION_PICKING.Descripcion.ToUpper() + ") ";
                                    }
                                }


                                if (mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.Ubicacion != null)
                                {
                                    str_Ubicacion += mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.Ubicacion;
                                }
                                else
                                {
                                    str_Ubicacion += "Sin Ubicación";
                                }

                                INTERNO_Existencias_Modelo mdl_INTERNO_Existencias_Modelo = new INTERNO_Existencias_Modelo();
                                mdl_INTERNO_Existencias_Modelo.IdDelegacion = mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.IdDelegacion;
                                mdl_INTERNO_Existencias_Modelo.Delegacion = mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.Delegacion;
                                mdl_INTERNO_Existencias_Modelo.IdAlmacen = mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.IdAlmacen;
                                mdl_INTERNO_Existencias_Modelo.Almacen = mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.Almacen;
                                mdl_INTERNO_Existencias_Modelo.IdUbicacion = mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.IdUbicacion;
                                mdl_INTERNO_Existencias_Modelo.Ubicacion = str_Ubicacion;
                                mdl_INTERNO_Existencias_Modelo.Inventario_Fecha = dtt_Fecha_Inventario;
                                mdl_INTERNO_Existencias_Modelo.Inventario_Cantidad = mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.Inventario_Cantidad;
                                mdl_INTERNO_Existencias_Modelo.Inventario_Cantidad_SegundaUnidad = mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.Inventario_Cantidad_SegundaUnidad;
                                mdl_INTERNO_Existencias_Modelo.VariacionExistencias_Cantidad = mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.VariacionExistencias_Cantidad;
                                mdl_INTERNO_Existencias_Modelo.VariacionExistencias_Cantidad_SegundaUnidad = mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.VariacionExistencias_Cantidad_SegundaUnidad;
                                mdl_INTERNO_Existencias_Modelo.EntradasMercancia_Cantidad = mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.EntradasMercancia_Cantidad;
                                mdl_INTERNO_Existencias_Modelo.EntradasMercancia_Cantidad_SegundaUnidad = mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.EntradasMercancia_Cantidad_SegundaUnidad;
                                mdl_INTERNO_Existencias_Modelo.Ventas_Cantidad = mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.Ventas_Cantidad;
                                mdl_INTERNO_Existencias_Modelo.Ventas_Cantidad_SegundaUnidad = mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.Ventas_Cantidad_SegundaUnidad;
                                mdl_INTERNO_Existencias_Modelo.EntradasFabricacion_Cantidad = mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.EntradasFabricacion_Cantidad;
                                mdl_INTERNO_Existencias_Modelo.EntradasFabricacion_Cantidad_SegundaUnidad = mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.EntradasFabricacion_Cantidad_SegundaUnidad;
                                mdl_INTERNO_Existencias_Modelo.SalidasFabricacion_Cantidad = mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.SalidasFabricacion_Cantidad;
                                mdl_INTERNO_Existencias_Modelo.SalidasFabricacion_Cantidad_SegundaUnidad = mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.SalidasFabricacion_Cantidad_SegundaUnidad;
                                mdl_INTERNO_Existencias_Modelo.Cargas_Cantidad = mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.Cargas_Cantidad;
                                mdl_INTERNO_Existencias_Modelo.Cargas_Cantidad_SegundaUnidad = mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.Cargas_Cantidad_SegundaUnidad;
                                mdl_INTERNO_Existencias_Modelo.Descargas_Cantidad = mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.Descargas_Cantidad;
                                mdl_INTERNO_Existencias_Modelo.Descargas_Cantidad_SegundaUnidad = mdl_INTERNO_Existencias_MovimientosArticulos_Modelo.Descargas_Cantidad_SegundaUnidad;

                                //Agregar al listado final
                                lst_INTERNO_Existencias_Modelo.Add(mdl_INTERNO_Existencias_Modelo);
                            }
                        }
                    }
                }
                #endregion

            }
            catch (Exception ex)
            {
                Control_Errores.Errores_Log("", ex, nameof(Funciones) + "/" + nameof(Existencias_Calcular));
                lst_INTERNO_Existencias_Modelo = null;
            }

            return lst_INTERNO_Existencias_Modelo;
        }

        public static INTERNO_Existencias_Cantidades_Modelo Existencias_Calcular_Picking(long _lng_idArticulo,long _lng_idUbicacion)
        {
            INTERNO_Existencias_Cantidades_Modelo mdl_INTERNO_Existencias_Cantidades_Modelo = new INTERNO_Existencias_Cantidades_Modelo();
            mdl_INTERNO_Existencias_Cantidades_Modelo.Cantidad = 0;
            mdl_INTERNO_Existencias_Cantidades_Modelo.Cantidad_SegundaUnidad = 0;

            try
            {
                #region OBTENCION DE DATOS

                List<INTERNO_Existencias_Busqueda_Modelo> lst_INTERNO_Existencias_Busqueda_Modelo = new List<INTERNO_Existencias_Busqueda_Modelo>();

                #region OBTENER MOVIMIENTOS DE ARTICULOS DESDE EL ULTIMO INVENTARIO
                //Cargamos el ensamblado 
                Assembly m_assembly_MOVIMIENTOSARTICULOS = Assembly.LoadFrom(Variables.G_STR_LIBRERIA_RUTAINICIAL + @"\" + Variables.G_STR_LIBRERIA_MAESTROS + ".dll");
                //Obtenemos el tipo de la clase
                Type m_type_MOVIMIENTOSARTICULOS = m_assembly_MOVIMIENTOSARTICULOS.GetType("" + Variables.G_STR_LIBRERIA_MAESTROS + "." + Variables.G_STR_LIBRERIA_DATOSMAESTROS);
                //creamos la instancia
                var obj_Clase_MOVIMIENTOSARTICULOS = Activator.CreateInstance(m_type_MOVIMIENTOSARTICULOS);
                //Cargamos el metodo solicitado
                MethodInfo obj_MethodInfo_MOVIMIENTOSARTICULOS = obj_Clase_MOVIMIENTOSARTICULOS.GetType().GetMethod(Variables.G_STR_LIBRERIA_DATOSMAESTROS_PROCEDIMIENTO_MAEARTICULOSMOVIMIENTOSDIARIOS_OBTENER_LISTADO_PICKING, BindingFlags.Instance | BindingFlags.NonPublic);

                //Obtener valores
                object[] arr_Parametros_MOVIMIENTOSARTICULOS = { _lng_idArticulo, _lng_idUbicacion };

                //Pasamos los parametros al metodo y lo ejecutamos
                List<INTERNO_Existencias_MovimientosArticulos_Modelo> lst_INTERNO_Existencias_MovimientosArticulos_Modelo = (List<INTERNO_Existencias_MovimientosArticulos_Modelo>)obj_MethodInfo_MOVIMIENTOSARTICULOS.Invoke(obj_Clase_MOVIMIENTOSARTICULOS, arr_Parametros_MOVIMIENTOSARTICULOS);
                #endregion
                #endregion

                #region CALCULAR
                if (lst_INTERNO_Existencias_MovimientosArticulos_Modelo != null && lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Count > 0)
                {

                    decimal dcm_Inventario_Cantidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m=>m.Inventario_Cantidad);
                    decimal dcm_Inventario_Cantidad_SegundaUnidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.Inventario_Cantidad_SegundaUnidad);
                    decimal dcm_VariacionExistencias_Cantidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.VariacionExistencias_Cantidad);
                    decimal dcm_VariacionExistencias_Cantidad_SegundaUnidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.VariacionExistencias_Cantidad_SegundaUnidad);
                    decimal dcm_EntradasMercancia_Cantidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.EntradasMercancia_Cantidad);
                    decimal dcm_EntradasMercancia_Cantidad_SegundaUnidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.EntradasMercancia_Cantidad_SegundaUnidad);
                    decimal dcm_Ventas_Cantidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.Ventas_Cantidad);
                    decimal dcm_Ventas_Cantidad_SegundaUnidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.Ventas_Cantidad_SegundaUnidad);
                    decimal dcm_EntradasFabricacion_Cantidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.EntradasFabricacion_Cantidad);
                    decimal dcm_EntradasFabricacion_Cantidad_SegundaUnidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.EntradasFabricacion_Cantidad_SegundaUnidad);
                    decimal dcm_SalidasFabricacion_Cantidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.SalidasFabricacion_Cantidad);
                    decimal dcm_SalidasFabricacion_Cantidad_SegundaUnidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.SalidasFabricacion_Cantidad_SegundaUnidad);
                    decimal dcm_Cargas_Cantidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.Cargas_Cantidad);
                    decimal dcm_Cargas_Cantidad_SegundaUnidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.Cargas_Cantidad_SegundaUnidad);
                    decimal dcm_Descargas_Cantidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.Descargas_Cantidad);
                    decimal dcm_Descargas_Cantidad_SegundaUnidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.Descargas_Cantidad_SegundaUnidad);

                    //Existencias
                    mdl_INTERNO_Existencias_Cantidades_Modelo.Cantidad = (dcm_EntradasMercancia_Cantidad + dcm_Inventario_Cantidad + dcm_Cargas_Cantidad) - (dcm_Ventas_Cantidad + dcm_VariacionExistencias_Cantidad + dcm_Descargas_Cantidad);
                    mdl_INTERNO_Existencias_Cantidades_Modelo.Cantidad_SegundaUnidad = (dcm_EntradasMercancia_Cantidad_SegundaUnidad + dcm_Inventario_Cantidad_SegundaUnidad + dcm_Cargas_Cantidad_SegundaUnidad) - (dcm_Ventas_Cantidad_SegundaUnidad + dcm_VariacionExistencias_Cantidad_SegundaUnidad + dcm_Descargas_Cantidad_SegundaUnidad);
                }
                #endregion
            }
            catch (Exception ex)
            {
                Control_Errores.Errores_Log("", ex, nameof(Funciones) + "/" + nameof(Existencias_Calcular_Picking));
                mdl_INTERNO_Existencias_Cantidades_Modelo = null;
            }

            return mdl_INTERNO_Existencias_Cantidades_Modelo;
        }

        public static INTERNO_Existencias_Cantidades_Modelo Existencias_Calcular_Reserva(long _lng_idArticulo)
        {
            INTERNO_Existencias_Cantidades_Modelo mdl_INTERNO_Existencias_Cantidades_Modelo = new INTERNO_Existencias_Cantidades_Modelo();
            mdl_INTERNO_Existencias_Cantidades_Modelo.Cantidad = 0;
            mdl_INTERNO_Existencias_Cantidades_Modelo.Cantidad_SegundaUnidad = 0;

            try
            {
                #region OBTENCION DE DATOS

                List<INTERNO_Existencias_Busqueda_Modelo> lst_INTERNO_Existencias_Busqueda_Modelo = new List<INTERNO_Existencias_Busqueda_Modelo>();

                #region OBTENER MOVIMIENTOS DE ARTICULOS DESDE EL ULTIMO INVENTARIO
                //Cargamos el ensamblado 
                Assembly m_assembly_MOVIMIENTOSARTICULOS = Assembly.LoadFrom(Variables.G_STR_LIBRERIA_RUTAINICIAL + @"\" + Variables.G_STR_LIBRERIA_MAESTROS + ".dll");
                //Obtenemos el tipo de la clase
                Type m_type_MOVIMIENTOSARTICULOS = m_assembly_MOVIMIENTOSARTICULOS.GetType("" + Variables.G_STR_LIBRERIA_MAESTROS + "." + Variables.G_STR_LIBRERIA_DATOSMAESTROS);
                //creamos la instancia
                var obj_Clase_MOVIMIENTOSARTICULOS = Activator.CreateInstance(m_type_MOVIMIENTOSARTICULOS);
                //Cargamos el metodo solicitado
                MethodInfo obj_MethodInfo_MOVIMIENTOSARTICULOS = obj_Clase_MOVIMIENTOSARTICULOS.GetType().GetMethod(Variables.G_STR_LIBRERIA_DATOSMAESTROS_PROCEDIMIENTO_MAEARTICULOSMOVIMIENTOSDIARIOS_OBTENER_LISTADO_RESERVA, BindingFlags.Instance | BindingFlags.NonPublic);

                //Obtener valores
                object[] arr_Parametros_MOVIMIENTOSARTICULOS = { _lng_idArticulo };

                //Pasamos los parametros al metodo y lo ejecutamos
                List<INTERNO_Existencias_MovimientosArticulos_Modelo> lst_INTERNO_Existencias_MovimientosArticulos_Modelo = (List<INTERNO_Existencias_MovimientosArticulos_Modelo>)obj_MethodInfo_MOVIMIENTOSARTICULOS.Invoke(obj_Clase_MOVIMIENTOSARTICULOS, arr_Parametros_MOVIMIENTOSARTICULOS);
                #endregion
                #endregion

                #region CALCULAR
                if (lst_INTERNO_Existencias_MovimientosArticulos_Modelo != null && lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Count > 0)
                {

                    decimal dcm_Inventario_Cantidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.Inventario_Cantidad);
                    decimal dcm_Inventario_Cantidad_SegundaUnidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.Inventario_Cantidad_SegundaUnidad);
                    decimal dcm_VariacionExistencias_Cantidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.VariacionExistencias_Cantidad);
                    decimal dcm_VariacionExistencias_Cantidad_SegundaUnidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.VariacionExistencias_Cantidad_SegundaUnidad);
                    decimal dcm_EntradasMercancia_Cantidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.EntradasMercancia_Cantidad);
                    decimal dcm_EntradasMercancia_Cantidad_SegundaUnidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.EntradasMercancia_Cantidad_SegundaUnidad);
                    decimal dcm_Ventas_Cantidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.Ventas_Cantidad);
                    decimal dcm_Ventas_Cantidad_SegundaUnidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.Ventas_Cantidad_SegundaUnidad);
                    decimal dcm_EntradasFabricacion_Cantidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.EntradasFabricacion_Cantidad);
                    decimal dcm_EntradasFabricacion_Cantidad_SegundaUnidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.EntradasFabricacion_Cantidad_SegundaUnidad);
                    decimal dcm_SalidasFabricacion_Cantidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.SalidasFabricacion_Cantidad);
                    decimal dcm_SalidasFabricacion_Cantidad_SegundaUnidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.SalidasFabricacion_Cantidad_SegundaUnidad);
                    decimal dcm_Cargas_Cantidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.Cargas_Cantidad);
                    decimal dcm_Cargas_Cantidad_SegundaUnidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.Cargas_Cantidad_SegundaUnidad);
                    decimal dcm_Descargas_Cantidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.Descargas_Cantidad);
                    decimal dcm_Descargas_Cantidad_SegundaUnidad = lst_INTERNO_Existencias_MovimientosArticulos_Modelo.Sum(m => m.Descargas_Cantidad_SegundaUnidad);

                    //Existencias
                    mdl_INTERNO_Existencias_Cantidades_Modelo.Cantidad = (dcm_EntradasMercancia_Cantidad + dcm_Inventario_Cantidad + dcm_Cargas_Cantidad) - (dcm_Ventas_Cantidad + dcm_VariacionExistencias_Cantidad + dcm_Descargas_Cantidad);
                    mdl_INTERNO_Existencias_Cantidades_Modelo.Cantidad_SegundaUnidad = (dcm_EntradasMercancia_Cantidad_SegundaUnidad + dcm_Inventario_Cantidad_SegundaUnidad + dcm_Cargas_Cantidad_SegundaUnidad) - (dcm_Ventas_Cantidad_SegundaUnidad + dcm_VariacionExistencias_Cantidad_SegundaUnidad + dcm_Descargas_Cantidad_SegundaUnidad);
                }
                #endregion
            }
            catch (Exception ex)
            {
                Control_Errores.Errores_Log("", ex, nameof(Funciones) + "/" + nameof(Existencias_Calcular_Reserva));
                mdl_INTERNO_Existencias_Cantidades_Modelo = null;
            }

            return mdl_INTERNO_Existencias_Cantidades_Modelo;
        }

        #endregion

        #region Trazabilidad
        public static List<INTERNO_Trazabilidad_Modelo> Trazabilidad_Calcular(long _lng_idArticulo, DateTime _dtt_FechaDesde, DateTime _dtt_FechaHasta)
        {
            List<INTERNO_Trazabilidad_Modelo> lst_INTERNO_Trazabilidad_Modelo = new List<INTERNO_Trazabilidad_Modelo>();

            try
            {
                #region OBTENCION DE DATOS

                List<INTERNO_Trazabilidad_Busqueda_Modelo> lst_INTERNO_Trazabilidad_Busqueda_Modelo = new List<INTERNO_Trazabilidad_Busqueda_Modelo>();

                #region MOVIMIENTOS DE ARTICULOS
                //Cargamos el ensamblado 
                Assembly m_assembly_MOVIMIENTOSARTICULOS = Assembly.LoadFrom(Variables.G_STR_LIBRERIA_RUTAINICIAL + @"\" + Variables.G_STR_LIBRERIA_MAESTROS + ".dll");
                //Obtenemos el tipo de la clase
                Type m_type_MOVIMIENTOSARTICULOS = m_assembly_MOVIMIENTOSARTICULOS.GetType("" + Variables.G_STR_LIBRERIA_MAESTROS + "." + Variables.G_STR_LIBRERIA_DATOSMAESTROS);
                //creamos la instancia
                var obj_Clase_MOVIMIENTOSARTICULOS = Activator.CreateInstance(m_type_MOVIMIENTOSARTICULOS);
                //Cargamos el metodo solicitado
                MethodInfo obj_MethodInfo_MOVIMIENTOSARTICULOS = obj_Clase_MOVIMIENTOSARTICULOS.GetType().GetMethod(Variables.G_STR_LIBRERIA_DATOSMAESTROS_PROCEDIMIENTO_MAEARTICULOSTRAZABILIDADMOVIMIENTOSDIARIOS_OBTENER_LISTADO_PORFECHAS, BindingFlags.Instance | BindingFlags.NonPublic);

                //Obtener valores
                object[] arr_Parametros_MOVIMIENTOSARTICULOS = { _lng_idArticulo, _dtt_FechaDesde, _dtt_FechaHasta };

                //Pasamos los parametros al metodo y lo ejecutamos
                List<INTERNO_Trazabilidad_MovimientosArticulos_Modelo> lst_INTERNO_Trazabilidad_MovimientosArticulos_Modelo = (List<INTERNO_Trazabilidad_MovimientosArticulos_Modelo>)obj_MethodInfo_MOVIMIENTOSARTICULOS.Invoke(obj_Clase_MOVIMIENTOSARTICULOS, arr_Parametros_MOVIMIENTOSARTICULOS);
                #endregion
                #endregion

                #region CALCULAR
                if (lst_INTERNO_Trazabilidad_MovimientosArticulos_Modelo != null && lst_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.Count > 0)
                {
                    //CREAR LISTADO DE AGRUPADOS
                    List<INTERNO_Trazabilidad_Agrupado_Modelo> lst_Agrupados = lst_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.GroupBy(p => new { p.IdDelegacion, p.IdAlmacen, p.IdUbicacion })
                                                                                                                                .Select(g => new INTERNO_Trazabilidad_Agrupado_Modelo
                                                                                                                                {
                                                                                                                                    IdDelegacion = g.Key.IdDelegacion,
                                                                                                                                    IdAlmacen = g.Key.IdAlmacen,
                                                                                                                                    IdUbicacion = g.Key.IdUbicacion,
                                                                                                                                })
                                                                                                                                .ToList();


                    foreach (INTERNO_Trazabilidad_Agrupado_Modelo mdl_INTERNO_Trazabilidad_Agrupado_Modelo in lst_Agrupados)
                    {
                        DateTime dtt_Fecha_Desde = _dtt_FechaDesde;
                        DateTime? dtt_Fecha_Inventario = null;

                        #region Buscar el ultimo inventario para saber la fecha desde que se tiene que coger los datos
                        List<INTERNO_Trazabilidad_MovimientosArticulos_Modelo> lst_Inventarios = lst_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.Where(m => m.Inventario_Cantidad > 0m &&
                                                                                                                                                               m.IdDelegacion == mdl_INTERNO_Trazabilidad_Agrupado_Modelo.IdDelegacion &&
                                                                                                                                                               m.IdAlmacen == mdl_INTERNO_Trazabilidad_Agrupado_Modelo.IdAlmacen &&
                                                                                                                                                               (mdl_INTERNO_Trazabilidad_Agrupado_Modelo.IdUbicacion != null
                                                                                                                                                                  ? (m.IdUbicacion != null && m.IdUbicacion.Value == mdl_INTERNO_Trazabilidad_Agrupado_Modelo.IdUbicacion.Value)
                                                                                                                                                                  : m.IdUbicacion == null)
                                                                                                                                                            ).ToList();
                        if (lst_Inventarios != null && lst_Inventarios.Count > 0)
                        {
                            dtt_Fecha_Desde = lst_Inventarios.OrderByDescending(m => m.Fecha).FirstOrDefault().Fecha;
                            dtt_Fecha_Inventario = dtt_Fecha_Desde;
                        }
                        #endregion

                        List<INTERNO_Trazabilidad_MovimientosArticulos_Modelo> lst_Registros = lst_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.Where(m => m.Fecha >= dtt_Fecha_Desde &&
                                                                                                                                                               m.IdDelegacion == mdl_INTERNO_Trazabilidad_Agrupado_Modelo.IdDelegacion &&
                                                                                                                                                               m.IdAlmacen == mdl_INTERNO_Trazabilidad_Agrupado_Modelo.IdAlmacen &&
                                                                                                                                                               (mdl_INTERNO_Trazabilidad_Agrupado_Modelo.IdUbicacion != null
                                                                                                                                                                  ? (m.IdUbicacion != null && m.IdUbicacion.Value == mdl_INTERNO_Trazabilidad_Agrupado_Modelo.IdUbicacion.Value)
                                                                                                                                                                  : m.IdUbicacion == null)
                                                                                                                                                            ).ToList();
                        if (lst_Registros != null && lst_Registros.Count > 0)
                        {
                            string str_Ubicacion = "";

                            foreach (INTERNO_Trazabilidad_MovimientosArticulos_Modelo mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo in lst_Registros)
                            {
                                str_Ubicacion = "";
                                if (mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.Ubicacion_TipoFuncion != null)
                                {
                                    if (Variables.G_MDL_TIPOFUNCION_MUELLEENTRADA.Codigo == mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.Ubicacion_TipoFuncion)
                                    {
                                        str_Ubicacion = "(" + Variables.G_MDL_TIPOFUNCION_MUELLEENTRADA.Descripcion.ToUpper() + ") ";
                                    }
                                    else if (Variables.G_MDL_TIPOFUNCION_PLAYAPICKING.Codigo == mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.Ubicacion_TipoFuncion)
                                    {
                                        str_Ubicacion = "(" + Variables.G_MDL_TIPOFUNCION_PLAYAPICKING.Descripcion.ToUpper() + ") ";
                                    }
                                    else if (Variables.G_MDL_TIPOFUNCION_RESERVA.Codigo == mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.Ubicacion_TipoFuncion)
                                    {
                                        str_Ubicacion = "(" + Variables.G_MDL_TIPOFUNCION_RESERVA.Descripcion.ToUpper() + ") ";
                                    }
                                    else
                                    {
                                        str_Ubicacion = "(" + Variables.G_MDL_TIPOFUNCION_PICKING.Descripcion.ToUpper() + ") ";
                                    }
                                }


                                if(mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.Ubicacion != null)
                                {
                                    str_Ubicacion += mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.Ubicacion;
                                }
                                else 
                                {
                                    str_Ubicacion += "Sin Ubicación";
                                }

                                INTERNO_Trazabilidad_Modelo mdl_INTERNO_Trazabilidad_Modelo = new INTERNO_Trazabilidad_Modelo();
                                mdl_INTERNO_Trazabilidad_Modelo.IdArticulo_Trazabilidad = mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.IdArticulo_Trazabilidad;
                                mdl_INTERNO_Trazabilidad_Modelo.Lote = mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.Lote;
                                mdl_INTERNO_Trazabilidad_Modelo.IdDelegacion = mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.IdDelegacion;
                                mdl_INTERNO_Trazabilidad_Modelo.Delegacion = mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.Delegacion;
                                mdl_INTERNO_Trazabilidad_Modelo.IdAlmacen = mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.IdAlmacen;
                                mdl_INTERNO_Trazabilidad_Modelo.Almacen = mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.Almacen;
                                mdl_INTERNO_Trazabilidad_Modelo.IdUbicacion = mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.IdUbicacion;
                                mdl_INTERNO_Trazabilidad_Modelo.Ubicacion = str_Ubicacion;
                                mdl_INTERNO_Trazabilidad_Modelo.Inventario_Fecha = dtt_Fecha_Inventario;
                                mdl_INTERNO_Trazabilidad_Modelo.Inventario_Cantidad = mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.Inventario_Cantidad;
                                mdl_INTERNO_Trazabilidad_Modelo.Inventario_Cantidad_SegundaUnidad = mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.Inventario_Cantidad_SegundaUnidad;
                                mdl_INTERNO_Trazabilidad_Modelo.VariacionExistencias_Cantidad = mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.VariacionExistencias_Cantidad;
                                mdl_INTERNO_Trazabilidad_Modelo.VariacionExistencias_Cantidad_SegundaUnidad = mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.VariacionExistencias_Cantidad_SegundaUnidad;
                                mdl_INTERNO_Trazabilidad_Modelo.EntradasMercancia_Cantidad = mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.EntradasMercancia_Cantidad;
                                mdl_INTERNO_Trazabilidad_Modelo.EntradasMercancia_Cantidad_SegundaUnidad = mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.EntradasMercancia_Cantidad_SegundaUnidad;
                                mdl_INTERNO_Trazabilidad_Modelo.Ventas_Cantidad = mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.Ventas_Cantidad;
                                mdl_INTERNO_Trazabilidad_Modelo.Ventas_Cantidad_SegundaUnidad = mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.Ventas_Cantidad_SegundaUnidad;
                                mdl_INTERNO_Trazabilidad_Modelo.EntradasFabricacion_Cantidad = mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.EntradasFabricacion_Cantidad;
                                mdl_INTERNO_Trazabilidad_Modelo.EntradasFabricacion_Cantidad_SegundaUnidad = mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.EntradasFabricacion_Cantidad_SegundaUnidad;
                                mdl_INTERNO_Trazabilidad_Modelo.SalidasFabricacion_Cantidad = mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.SalidasFabricacion_Cantidad;
                                mdl_INTERNO_Trazabilidad_Modelo.SalidasFabricacion_Cantidad_SegundaUnidad = mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.SalidasFabricacion_Cantidad_SegundaUnidad;
                                mdl_INTERNO_Trazabilidad_Modelo.Cargas_Cantidad = mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.Cargas_Cantidad;
                                mdl_INTERNO_Trazabilidad_Modelo.Cargas_Cantidad_SegundaUnidad = mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.Cargas_Cantidad_SegundaUnidad;
                                mdl_INTERNO_Trazabilidad_Modelo.Descargas_Cantidad = mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.Descargas_Cantidad;
                                mdl_INTERNO_Trazabilidad_Modelo.Descargas_Cantidad_SegundaUnidad = mdl_INTERNO_Trazabilidad_MovimientosArticulos_Modelo.Descargas_Cantidad_SegundaUnidad;

                                //Agregar al listado final
                                lst_INTERNO_Trazabilidad_Modelo.Add(mdl_INTERNO_Trazabilidad_Modelo);
                            }
                        }
                    }
                }
                #endregion

            }
            catch (Exception ex)
            {
                Control_Errores.Errores_Log("", ex, nameof(Funciones) + "/" + nameof(Trazabilidad_Calcular));
                lst_INTERNO_Trazabilidad_Modelo = null;
            }

            return lst_INTERNO_Trazabilidad_Modelo;
        }
        #endregion


    }
}

