clsImpresora.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using sage.ew.ewbase;
using sage.ew.db;
using sage.ew.tpv.Forms;
using System.IO;
using System.Windows.Forms;
using sage.ew.functions;
using System.Management;

namespace sage.ew.tpv
{
    public class Impresora : ewMante
    {

        #region PROPIEDADES PUBLICAS

        public override string _Nombre
        {
            get
            {
                return base._Nombre;
            }
            set
            {
                if (value != base._Nombre) _Fichero._CambiaNombreImpresora(value);
                base._Nombre = value;
            }
        }
        public int _Tipo
        {
            get
            {
                if (_lisCampos.ContainsKey("TIPO"))
                    return Convert.ToInt32(_lisCampos["TIPO"]._NewVal.ToString());
                else
                    return 0;
            }
            set
            {
                if (_lisCampos.ContainsKey("TIPO"))
                {
                    _lisCampos["TIPO"]._NewVal = value;
                    _Exportar_Null();
                }
            }
        }

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

        public int _Longitud_Papel
        {
            get
            {
                if (_lisCampos.ContainsKey("SALT_LIN"))
                    return Convert.ToInt32(_lisCampos["SALT_LIN"]._NewVal.ToString());
                else
                    return 0;
            }
            set
            {
                if (_lisCampos.ContainsKey("SALT_LIN"))
                {
                    _lisCampos["SALT_LIN"]._NewVal = value;
                    _Exportar_Null();
                }
            }
        }

        public bool _Compcajon
        {
            get
            {
                if (_lisCampos.ContainsKey("COMPCAJON"))
                    return Convert.ToBoolean(_lisCampos["COMPCAJON"]._NewVal);
                else
                    return false;
            }
            set
            {
                if (_lisCampos.ContainsKey("COMPCAJON"))
                {
                    _lisCampos["COMPCAJON"]._NewVal = value;
                    _Exportar_Null();
                }
            }
        }

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

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

        //Campo virtual (lo gestiona la clase ewPrinterFile)
        public string _Nombre_Local
        {
            get { return _Fichero._NombreLocal; }
            set { _Fichero._NombreLocal = value; }
        }
        private string _cNombreLocal = string.Empty;
        

        private ewPrinterFile _Fichero
        {
            get
            { 
                if(_oFichero == null)
                    _oFichero = new ewPrinterFile(this);
                return _oFichero; 
            }
            set { _oFichero = value; }
        }
        private ewPrinterFile _oFichero = null;

        #endregion PROPIEDADES PUBLICAS

        #region CONSTRUCTORS

        public Impresora()
        {
            // Asignamos las propiedades para Familias
            this._Clave = "Codigo";
            this._DataBase = "TPV";
            this._Tabla = "IMPRESOR";
            this._TituloMantenimiento = "Mantenimiento de impresoras";
            this._FormManteBaseType = typeof(tpv.Forms.frmImpresoras);

            this._Pantalla = "IMPRESOR"; // PARTE 88419
        }

        #endregion CONSTRUCTORS

        #region Métodos públicos

       
        public override bool _Save()
        {
            bool esperandoCodigo = (_Estado == _EstadosMantenimiento.EsperandoCodigo);
            // PE-92530
            bool llOk = base._Save();

            if (llOk && !esperandoCodigo) //=> esperando código dispara un save para la operación de new
                llOk = _Fichero._WriteFile();

            // PE-103019. Crear los documentos de TPV
            if (llOk)
            {
                // Sigui quin sigui l'estat, comprovem si existeixen els reports per a la impressora.
                _Crear_Reports();
            }

            return llOk;            
        }

        public override void _Load()
        {
            base._Load();

            //Inicializamos fichero
            _Fichero = new ewPrinterFile(this);
        }

        public override bool _Delete() 
        {
            //2. En caso de DELETE se deberá comprobar que no exista en las siguientes tablas: TPV!CAJAS
            // Hay 4 alias Impresora, impresora2, imp_coci e imp_resum

            bool llOk = true;
            List<string> llisListaTablas = new List<string>();

            // Tablas del TPV
            llisListaTablas.Clear();
            llisListaTablas.Add("CAJAS");


            llOk = llOk && !_Existen_Registros("TPV", llisListaTablas, "IMPRESORA");
            llOk = llOk && !_Existen_Registros("TPV", llisListaTablas, "IMPRESORA2");
            llOk = llOk && !_Existen_Registros("TPV", llisListaTablas, "IMP_COCI");
            llOk = llOk && !_Existen_Registros("TPV", llisListaTablas, "IMP_RESUM");

            if (llOk)
                return base._Delete();
            else
                this._Error_Message = "Este código de impresora está siendo utilizado en alguna caja de venta. No se puede borrar.";

            return llOk;
        }

        public bool _Send_Abrir_Cajon()
        {
            string lcErrorMessage = string.Empty;
            string lcImpresora = string.Empty;
            bool llOk = true;

            lcImpresora = this._Nombre_Local; //Asigno el nombre local
            if (string.IsNullOrWhiteSpace(lcImpresora)) lcImpresora = this._Nombre; //Si esta vacio lo cambio por el nombre 
            llOk = (!string.IsNullOrWhiteSpace(lcImpresora)); //Sino tengo ni nombre ni nombre local no hago nada.
            
            lcImpresora = FUNCTIONS._GetPrinterDriver(lcImpresora);

            if(string.IsNullOrWhiteSpace(this._Abrir_Caja)) 
            {
                lcErrorMessage = "No se ha definido el código para abrir el cajón.";
                llOk = false;
            }

            if (llOk && FUNCTIONS.SendStringToPrinter(lcImpresora, this._Abrir_Caja, ref lcErrorMessage)) return true;
            else 
            {
                this._Error_Message = lcErrorMessage;
                return false;
            }
        }

        public bool _Send_Cortar_Papel()
        {
            string lcErrorMessage = string.Empty;
            string lcImpresora = string.Empty;
            bool llOk = true;

            lcImpresora = this._Nombre_Local; //Asigno el nombre local
            if (string.IsNullOrWhiteSpace(lcImpresora)) lcImpresora = this._Nombre; //Si esta vacio lo cambio por el nombre 
            llOk = (!string.IsNullOrWhiteSpace(lcImpresora)); //Sino tengo ni nombre ni nombre local no hago nada.

            lcImpresora = FUNCTIONS._GetPrinterDriver(lcImpresora);

            if(llOk && string.IsNullOrWhiteSpace(this._Cortar_Papel)) 
            {
                lcErrorMessage = "No se ha definido el código para cortar el papel.";
                llOk = false;
            }

            if(llOk && FUNCTIONS.SendStringToPrinter(lcImpresora,this._Cortar_Papel, ref lcErrorMessage)) return true;
            else 
            {
                this._Error_Message = lcErrorMessage;
                return false;
            }
        }
        
        #endregion Métodos públicos


        #region Métodos privados

        // PE-103019. Crear tots el reports
        private bool _Crear_Reports()
        {
            bool lbOk = true;
            
            _Crear_Report("TICKET");
            _Crear_Report("COBRO");
            _Crear_Report("COCINA");
            _Crear_Report("ENTREGA");
            _Crear_Report("IPAGOVAR");
            _Crear_Report("TICKETPV");
            _Crear_Report("IRETIROS");
            _Crear_Report("IREPOSI");
            _Crear_Report("VALE");
            _Crear_Report("COMPROBA");
            _Crear_Report("COMP_EMV");

            return lbOk;
        }

        // PE-103019. Crear tots el reports
        private bool _Crear_Report(string tcTipoDoc)
        {
            bool lbOk = true;

            string lcDefaultReport = "";
            string lcReport = "";
            string lcRutaReports = Path.Combine(global.EW_GLOBAL._GetVariable("wc_iniservidor").ToString(), @"MODULOS\TPV\REPORTS\DOCS_TPV\");

            // Tickets
            lcReport = lcRutaReports + tcTipoDoc + _Codigo + ".FRX";

            if (!Directory.Exists(lcRutaReports)) Directory.CreateDirectory(lcRutaReports);

            if (!File.Exists(lcReport))
            {
                lcDefaultReport = lcRutaReports + tcTipoDoc + ".FRX";
                if (File.Exists(lcDefaultReport))
                {
                    File.Copy(lcDefaultReport, lcReport);

                    lcDefaultReport = lcRutaReports + tcTipoDoc + ".FRT";
                    lcReport = lcRutaReports + tcTipoDoc + _Codigo + ".FRT";
                    if (File.Exists(lcDefaultReport))
                    {
                        File.Copy(lcDefaultReport, lcReport);
                    }
                    else
                    {
                        lbOk = false;
                    }
                }
                else
                {
                    lbOk = false;
                }

                if (!lbOk)
                {
                    String[] lcFiles = Directory.GetFiles(lcRutaReports, tcTipoDoc + _Codigo + ".*");

                    foreach(String lcFile in lcFiles)
                    {
                        try
                        {
                            // Esborro els reports a mitjes
                            File.Delete(lcFile);
                        }
                        catch
                        {

                        }
                    }
                    
                }
            }

            return lbOk;
        }

        #endregion Métodos privados


        public class ewPrinterFile
        {
            private readonly Impresora _oImpresora = null;

            public ewPrinterFile(Impresora toImpresora)
            {
                _oImpresora = toImpresora;
            }

            public string _NombreLocal
            {
                get { return _Get_NombreLocal(); }
                set { _Set_NombreLocal(value); }
            }
            private string _cNombreLocal = string.Empty;

            #region fichero

            public string _NombreFichero
            {
                get { return (Path.Combine(_cPathFichero, _cSafeFileName)).Trim(); }
            }

            protected string _cPathFichero = Convert.ToString(sage.ew.global.EW_GLOBAL._GetVariable("wc_PathInicio"));

            protected string _cSafeFileName = "EWPRNSET.INF";

            #endregion fichero

            private string _cTextoFichero = string.Empty;

            private string _cTextoFijo = string.Empty;

            private bool _lFicheroCargado = false;

            private Dictionary<string, string> _dicEquivalenciasImpresoras = new Dictionary<string, string>();

            private string _cEtiqueta = "[Printers]";

            private string _Get_NombreLocal()
            {
                if (!_lFicheroCargado) _ReadFile();

                if (_dicEquivalenciasImpresoras.ContainsKey(_oImpresora._Nombre.TrimEnd())) return _dicEquivalenciasImpresoras[_oImpresora._Nombre.TrimEnd()];
                else return "";
            }

            public void _CambiaNombreImpresora(string tcValor)
            {
                String lcClave;
               
                if (!_lFicheroCargado) _ReadFile();

                if (string.IsNullOrWhiteSpace(tcValor) || string.IsNullOrWhiteSpace(tcValor)) return;

                lcClave = _oImpresora._Nombre.TrimEnd();

                //Si tengo la clave, actualizo el valor
                if (_dicEquivalenciasImpresoras.ContainsKey(lcClave))
                {
                    _dicEquivalenciasImpresoras.Add(tcValor, _NombreLocal);
                    _dicEquivalenciasImpresoras.Remove(lcClave);
                }                
            }

            private void _Set_NombreLocal(string tcValor)
            {
                if (!_lFicheroCargado) _ReadFile();

                if (string.IsNullOrWhiteSpace(_oImpresora._Nombre) || string.IsNullOrWhiteSpace(tcValor)) return;

                string lcClave = _oImpresora._Nombre.TrimEnd();

                //Si tengo la clave, actualizo el valor
                if (_dicEquivalenciasImpresoras.ContainsKey(lcClave))
                {
                    _dicEquivalenciasImpresoras[lcClave] = tcValor;
                }
                else //Sino la inserto
                    _dicEquivalenciasImpresoras.Add(lcClave, tcValor);
            }

            public bool _WriteFile()
            {
                _lFicheroCargado = false; //Marco que trato de modificar el fichero

                if (!_Existe_Fichero()) return false;

                try
                {
                    StreamWriter loStrmWrtr = new StreamWriter(_NombreFichero);
                    
                    //Monto el contenido que voy a grabar a fichero
                    _cTextoFichero = _cTextoFijo;

                    //Por cada elemento del diccionario
                    foreach (KeyValuePair<string,string> loDicItem in _dicEquivalenciasImpresoras)
                    {
                        //lo concateno
                        _cTextoFichero += (loDicItem.Key + "=" + loDicItem.Value + Environment.NewLine);     
                    }
                    
                    loStrmWrtr.WriteLine(_cTextoFichero);
                    loStrmWrtr.Close();
                    return true;
                }
                catch (Exception loEx)
                {
                    functions.FUNCTIONS._MessageBox(loEx.Message, "Error grabando el fichero",
                    MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
                    return false;
                }
            }

            public void _ReadFile()
            {
                _lFicheroCargado = false;

                if (!_Existe_Fichero()) return;

                try
                {
                    //Volco el contenido del fichero a un string
                    leerFichero();

                    //Proceso el string 
                    string lcImpresoras = string.Empty;

                    //Si tengo la etiqueta
                    if (_cTextoFichero.Contains(_cEtiqueta))
                    {
                        //Vacio lo que pueda haber en el diccionario
                        _dicEquivalenciasImpresoras = new Dictionary<string, string>();

                        //Parte fija: Grabo la parte fija la etiqueta y un salto de línea
                        _cTextoFijo = _cTextoFichero.Substring(0,(_cTextoFichero.IndexOf(_cEtiqueta) + _cEtiqueta.Length)) +Environment.NewLine;

                        //Parte variable
                        lcImpresoras = _cTextoFichero.Substring((_cTextoFichero.IndexOf(_cEtiqueta) + _cEtiqueta.Length));

                        if (!string.IsNullOrWhiteSpace(lcImpresoras))
                        {
                            string[] lcSeparador = new string[] { "\r\n" };  // Environment.NewLine
                            string[] laLineasImpresoras = lcImpresoras.Split(lcSeparador, StringSplitOptions.RemoveEmptyEntries); //Splito el bloque de impresoras en lineas

                            if (laLineasImpresoras.Count() > 0)
                            {
                                //Monto un diccionario de impresoras
                                foreach (string lcImpresora in laLineasImpresoras)
                                {
                                    string[] laDetalleImpresora = lcImpresora.Split('=');
                                    if (laDetalleImpresora.Count() > 1)
                                    {
                                        if (_dicEquivalenciasImpresoras.ContainsKey(laDetalleImpresora[0])) //Si ya tengo la clave (no debería pasar nunca)
                                        {
                                            _dicEquivalenciasImpresoras[laDetalleImpresora[0]] = laDetalleImpresora[1]; //Actualizo el valor
                                        }
                                        else _dicEquivalenciasImpresoras.Add(laDetalleImpresora[0], laDetalleImpresora[1]); //Inserto la clave
                                    }
                                }
                            }
                        }

                        _lFicheroCargado = true;
                    }

                    

                }
                catch (Exception loEx)
                {
                    functions.FUNCTIONS._MessageBox(loEx.Message, "Error leyendo el fichero",
                    MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
                }
            }

            private bool _Existe_Fichero()
            {
                bool llOk = false;

                try
                {
                    //Verifico la existencia del directorio
                    if (!Directory.Exists(_cPathFichero) && (string.IsNullOrWhiteSpace(_cPathFichero) == false)) Directory.CreateDirectory(_cPathFichero); // PARTE 92408. Cuando creamos una impresora siempre sale error

                    //Verifico la existencia del fichero 
                    if (!File.Exists(_NombreFichero))
                    {
                        crearFichero();
                    }
                    else //El fichero existe, verifico que sea bueno
                    {
                        leerFichero();

                        //Sino tengo la etiqueta => Fichero malo
                        if (!_cTextoFichero.Contains(_cEtiqueta))
                        {
                            reemplazarFichero();
                        }
                    }

                    llOk = true;
                }
                catch (Exception loEx)
                {
                    functions.FUNCTIONS._MessageBox(loEx.Message, "Operaciones previas con ficheros",
                    MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
                    
                    return false;
                }

                return llOk;
            }

            private void leerFichero()
            {
                //Volco el contenido del fichero a un string
                StreamReader loStrmRdr = new StreamReader(_NombreFichero);
                _cTextoFichero = loStrmRdr.ReadToEnd();
                loStrmRdr.Close();
            }

            private void reemplazarFichero()
            {
                File.Delete(_NombreFichero); //Borro el fichero que no tiene la etiqueta
                crearFichero(); //Vuelvo a crear el fichero
            }

            private void crearFichero()
            {
                //Sino existe trato de crearlo
                using (FileStream loFS = File.Create(_NombreFichero))
                {
                    //Monto las líneas 
                    // --- Fox legacy text ---
                    List<Byte[]> llisLineas = new List<byte[]>();
                    llisLineas.Add(new UTF8Encoding(true).GetBytes(";" + Environment.NewLine));
                    llisLineas.Add(new UTF8Encoding(true).GetBytes(";        EWPRNSET.INF -- NO CANVIAR" + Environment.NewLine));
                    llisLineas.Add(new UTF8Encoding(true).GetBytes(";" + Environment.NewLine));
                    llisLineas.Add(new UTF8Encoding(true).GetBytes("; En aquest fitxer es guarden les equivalencies d'impressores de TPV." + Environment.NewLine));
                    llisLineas.Add(new UTF8Encoding(true).GetBytes("; Des de la pantalla d'impressores de TPV es pot seleccionar la impressora" + Environment.NewLine));
                    llisLineas.Add(new UTF8Encoding(true).GetBytes("; local que correspondria a la impressora de TPV." + Environment.NewLine));
                    llisLineas.Add(new UTF8Encoding(true).GetBytes("; Amb això se soluciona el problema de que el terminal que te endollada la" + Environment.NewLine));
                    llisLineas.Add(new UTF8Encoding(true).GetBytes("; impressora no imprimeixi amb el registre de Impressores de TPV que utilitzen" + Environment.NewLine));
                    llisLineas.Add(new UTF8Encoding(true).GetBytes("; els altres terminals." + Environment.NewLine));
                    llisLineas.Add(new UTF8Encoding(true).GetBytes(";" + Environment.NewLine));
                    llisLineas.Add(new UTF8Encoding(true).GetBytes("[Printers]" + Environment.NewLine));

                    //Escribo las líneas en el fichero
                    foreach (Byte[] loLinea in llisLineas)
                    {
                        loFS.Write(loLinea, 0, loLinea.Length);
                    }

                    //Cierro el fichero
                    loFS.Close();
                }
            }
        }

        public static string _ObtenerPuerto(String lcPrinter)
        {

            String lcQuery, lcPrinterName, lcPort = ""; ;

            lcPrinterName = lcPrinter.Contains(@"\") ? lcPrinter.Substring(lcPrinter.LastIndexOf(@"\") + 1) : lcPrinter;
            lcQuery = string.Format("SELECT * from Win32_Printer WHERE Name LIKE '%{0}'", lcPrinterName);

            using (ManagementObjectSearcher loSearcher = new ManagementObjectSearcher(lcQuery))
            using (ManagementObjectCollection loCol = loSearcher.Get())
            {
                try
                {
                    foreach (ManagementObject printer in loCol)
                    {
                        lcPrinterName = Convert.ToString(printer.GetPropertyValue("Name"));
                        if (lcPrinterName == lcPrinter) lcPort = Convert.ToString(printer.GetPropertyValue("PortName"));
                    }
                }
                catch 
                {

                }
            }

            return lcPort;
        }
    }
}