clsClasificacionArticulos.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using sage.ew.ewbase;
using sage.ew.articulo;
using System.Data;
using sage.ew.db;
using System.ComponentModel;
using System.Drawing;
using sage.ew.functions;

namespace sage.ew.tpv
{
    public class ClasificacionArticulos : ewMante
    {
        #region Propiedades

        //public string _Codigo
        public override string _Codigo //= string.Empty;
        {
            get
            {
                return base._Codigo;
            }
            set
            {
                base._Codigo = value; 
                if (_lisCampos.ContainsKey("CODIGO")) //Actualitzo el camp equivalent
                {
                    _lisCampos["CODIGO"]._NewVal = value;
                    _Exportar_Null();
                }

            }
        }

        public Int32 _ColorFondo
        {
            get
            {
                return _lisCampos.ContainsKey("BACKCOLOR") ? _TranslateColor(_lisCampos["BACKCOLOR"]._NewVal.ToString()) : 0;
            }
            set
            {
                if (_lisCampos.ContainsKey("BACKCOLOR"))
                {
                    _lisCampos["BACKCOLOR"]._NewVal = value;
                    _Exportar_Null();
                }
            }
        }

        public Int32 _ColorFuente
        {
            get
            {
                return _lisCampos.ContainsKey("FORECOLOR") ? _TranslateColor(_lisCampos["FORECOLOR"]._NewVal.ToString()) : 0;
            }
            set
            {
                if (_lisCampos.ContainsKey("FORECOLOR"))
                {
                    _lisCampos["FORECOLOR"]._NewVal = value;
                    _Exportar_Null();
                }
            }
        }

        
        public string _Fuente
        {
            get
            {
                if (_lisCampos.ContainsKey("FONTTPV"))
                    return _lisCampos["FONTTPV"]._NewVal.ToString();
                else
                    return "";
            }
            set
            {
                if (_lisCampos.ContainsKey("FONTTPV"))
                {
                    _lisCampos["FONTTPV"]._NewVal = value;
                    _Exportar_Null();
                }
            }
        }

        public string _Foto
        {
            get
            {
                if (_lisCampos.ContainsKey("FOTO"))
                    return _lisCampos["FOTO"]._NewVal.ToString();
                else
                    return "";
            }
            set
            {
                if (_lisCampos.ContainsKey("FOTO"))
                {
                    _lisCampos["FOTO"]._NewVal = value;
                    _Exportar_Null();
                }
            }
        }

        public BindingList<ArticulosClasifica> _Articulos = new BindingList<ArticulosClasifica>();

        private string _cDatabaseDetalle = "COMUNES";
        private string _cTablaDetalle = "ART_CLASIF";

        private List<string> _ArticulosClasif = new List<string>();

        #endregion Propiedades

        #region Constructores


        public ClasificacionArticulos()
        {
            this._Clave = "CODIGO";
            this._DataBase = "COMUNES";
            this._Tabla = "CLASIF";
            this._TituloMantenimiento = "Mantenimiento de clasificaciones"; // PARTE 92701
            this._Pregunta_Borrar = "¿Desea eliminar el registro?";
            this._Pantalla = "CLASIFICA"; // PARTE 88499
            this._FormManteBaseType = typeof(sage.ew.tpv.Forms.frmClasificacionArticulos);
        }

        #endregion Constructores

        public override void _Load()
        {
            string lcSql = string.Empty;
            DataTable loDt;

            //Invoco al método de la base
            base._Load();

            #region Recuperación del detalle
            
            //Limpio el detalle de artículos
            _Articulos.Clear();
            
            loDt = new DataTable();
            if (!string.IsNullOrEmpty(_Codigo))
            {
                lcSql = $"SELECT * FROM {DB.SQLDatabase(_cDatabaseDetalle, _cTablaDetalle) } WHERE CLASIF = { DB.SQLString(_Codigo) }";
                //Si ha ido bien y tengo resultados monto las líneas
                if (DB.SQLExec(lcSql, ref loDt) && loDt.Rows.Count > 0)
                {
                    //Construyo una linea de portes por registro
                    foreach (DataRow ldrArticuloClasificado in loDt.Rows)
                    {
                        _Articulos.Add(new ArticulosClasifica(this, ldrArticuloClasificado));
                    }
                }

                FUNCTIONS._DisposeDatatable(loDt);
            }

            _ArticulosClasif = _Articulos.Select(f => f._Articulo.Trim()).ToList(); 

            #endregion Recuperación del detalle

        }


        protected override void _DescargarDatos()
        {
            base._DescargarDatos();

            _ArticulosClasif.Clear();

            return;
        }

        private int _TranslateColor(string tcColor)
        {
            Int32 lnColor = 0;

            if (!Int32.TryParse(tcColor, out lnColor) && !String.IsNullOrWhiteSpace(tcColor))
            {
                Color loColor = Name_To_Color(tcColor);
                lnColor = System.Drawing.ColorTranslator.ToWin32(loColor);
            }

            return lnColor;
        }


        private Color Name_To_Color(string tcNomColor)
        {
            Color loColor;

            // Primer mirem si és un SystemColor
            if (tcNomColor.Substring(0, 1) == "#")
                loColor = ColorTranslator.FromHtml(tcNomColor);
            else
                loColor = Color.FromName(tcNomColor.Trim());

            return loColor;
        }

        public override bool _Delete()
        {
            bool llOk = false;

            llOk = base._Delete();

            //Elimino el registro de la tabla principal
            string lcSql = string.Empty;
            lcSql = "DELETE  FROM " + DB.SQLDatabase(_DataBase, _Tabla) + " " +
                    "WHERE CODIGO = " + DB.SQLString(this._Codigo) + " ";
            llOk = DB.SQLExec(lcSql);

            //Elimino el detalle
            lcSql = "DELETE  FROM " + DB.SQLDatabase(_cDatabaseDetalle, _cTablaDetalle ) + " " +
                    "WHERE CLASIF = " + DB.SQLString(this._Codigo) + " ";
            llOk = llOk && DB.SQLExec(lcSql);

            return llOk;
        }

        public override bool _Save()
        {

            ArticulosClasifica loRegBlanco = _Articulos.Where(x => string.IsNullOrWhiteSpace(x._Articulo)).FirstOrDefault();
            if (loRegBlanco != null)
                _Articulos.Remove(loRegBlanco);

            List<ArticulosClasifica> loInvalidos = new List<ArticulosClasifica>();

            foreach(string lcArticulosClasifica in _ArticulosClasif)
            {
                if(!_Articulos.Any(f=>f._Articulo.Trim() == lcArticulosClasifica.Trim()))
                {
                    if (!new ArticulosClasifica(this, lcArticulosClasifica)._Delete()) return false;
                }
            }

            //Grabo el detalle: Invoco al método de grabación lineal (para aquellos no nulos)
            foreach (ArticulosClasifica loArticuloClasificado in _Articulos)
            {
                if (!string.IsNullOrWhiteSpace(loArticuloClasificado._Articulo))
                {
                    // Si no está en la lista que cargué al hacer el _Load() es que han creado el registro.
                    // Si ya está en la lista que cargué al hacer el _Load() y sigue estando quiere decir que no lo han borrado, luego no hay
                    // que hacer nada.
                    //
                    if (!_ArticulosClasif.Contains(loArticuloClasificado._Articulo.Trim()))
                    {
                        if (!loArticuloClasificado._Save())
                            return false;
                    }
                }
            }

            //Grabo el registro principal
            return base._Save();
        }

        public class ArticulosClasifica
        {
            #region Propiedades públicas

            public bool IsNew { get; set; } = true;
            
            public string _Articulo
            {
                get { return _cArticulo; }
                set 
                { 
                    _cArticulo = value;
                    if (!string.IsNullOrWhiteSpace(_cArticulo))
                    {
                        Articulo loArt = new Articulo(_cArticulo);
                        loArt._Load();
                        _cNombre = loArt._Nombre;
                    }
                    else _cNombre = string.Empty; 
                }
            }
            private string _cArticulo = string.Empty;

            public string _Nombre
            {
                get { return _cNombre; }
                //set { _cArticulo = value; }
            }
            private string _cNombre = string.Empty;

            #endregion Propiedades públicas

            #region Propiedades privadas

            private ClasificacionArticulos _oClasificacion = null;

            #endregion Propiedades privadas

            #region Constructores

            public ArticulosClasifica()
            { 
            }

            public ArticulosClasifica(ClasificacionArticulos toClasificacion, string tcArticulo)
            {
                //Asigno la clase relacionada
                _oClasificacion = toClasificacion;

                this._Articulo = tcArticulo;
            }

            public ArticulosClasifica(ClasificacionArticulos toClasificacion, DataRow tdrRow = null)
            {
                //Asigno la clase relacionada
                _oClasificacion = toClasificacion;

                //Recupero el detalle desde el DataRow
                if (tdrRow != null)
                {
                    IsNew = false;
                    _Articulo = Convert.ToString(tdrRow["ARTICULO"]);
                }
            }

            #endregion Constructores

            #region Métodos

            public bool _Save()
            {
                string lcSql = string.Empty;

                if (IsNew)
                {
                    // asignar-lo nLinea
                    lcSql = string.Format("INSERT INTO {0} (ARTICULO, CLASIF, CREATED, MODIFIED) Values({1}, {2}, {3}, {3})", DB.SQLDatabase("COMUNES", "ART_CLASIF"), DB.SQLString(_cArticulo), DB.SQLString(this._oClasificacion._Codigo), DB.SQLString(DateTime.Now));
                }
                else
                {
                    lcSql = $"UPDATE { DB.SQLDatabase("COMUNES", "ART_CLASIF") } SET MODIFIED = {DB.SQLString(DateTime.Now)} WHERE ARTICULO = {DB.SQLString(_cArticulo)} AND CLASIF = {DB.SQLString(this._oClasificacion._Codigo)}";
                }
                
                //Ejecuto el Query 
                return DB.SQLExec(lcSql);
            }

            public bool _Load()
            {
                string lcSql = string.Empty;
                DataTable ldtResult = new DataTable();
                bool llOk = false;

                //Recupero las lineas de la clasificación
                lcSql = "SELECT ARTICULO, CLASIF " +
                        "FROM " + DB.SQLDatabase("COMUNES", "ART_CLASIF") + " " +
                        "WHERE CLASIF = " + DB.SQLString(this._oClasificacion._Codigo) + " ";

                //Ejecuto el Query 
                llOk = DB.SQLExec(lcSql, ref ldtResult);
                if (llOk && ldtResult.Rows.Count > 0)
                {
                    this._Articulo = Convert.ToString(ldtResult.Rows[0]["ARTICULO"]);
                }

                return llOk;
            }

            public bool _Delete()
            {
                string lcSql = string.Empty;

                //Creo la instrucción
                lcSql = "DELETE FROM " + DB.SQLDatabase("COMUNES", "ART_CLASIF") + " " +
                        "WHERE CLASIF = " + DB.SQLString(this._oClasificacion._Codigo) + " " +
                        "AND ARTICULO = " + DB.SQLString(this._Articulo) + " ";
                //Ejecuto el Query 
                return DB.SQLExec(lcSql);
            }

            #endregion Métodos
        }
    }
}