Cash.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Xml;
using System.Xml.Linq;

using sage.ew.interficies;
using sage.ew.db;
using sage.ew.global;
using sage.ew.docsven;
using System.Net.Sockets;
using System.ComponentModel;
using System.Collections;
using sage.ew.tpv.Clases;
using sage.ew.ewbase;
using sage.ew.global.Diccionarios;

namespace sage.ew.tpv
{
    public class Cash : ICash, INotifyPropertyChanged
    {
        protected internal ewMascara _oMascaraPrecio = new ewMascara(EW_GLOBAL._GetMascara(KeyDiccionarioMascara.wc_total));

        protected internal string _cMoneda = EW_GLOBAL._GetVariable("wc_moneda").ToString();

        #region Custom Events

        public event UserNotifyerEvent _NotificarUsuario;

        public void LanzarEvento_MostrarMensajeUsuario(bool tlMostrar = true, bool tlOk = true)
        {
            var handler = _NotificarUsuario; //Copia del evento para garantizar ThreadSafe
            if (handler != null)
            {
                handler(this, new EwCashNotifyEventArgs(tlMostrar, tlOk));
            }
        }

        #endregion Custom Events

        #region INotifyPropertyChanged

        public event PropertyChangedEventHandler PropertyChanged;

        private void NotifyPropertyChanged(String tcNombrePropidad)
        {
            var handler = PropertyChanged; //Copia del evento para garantizar ThreadSafe
            if (handler != null)
            {
                handler(this, new PropertyChangedEventArgs(tcNombrePropidad));
            }
        }

        #endregion INotifyPropertyChanged

        #region PROPIEDADES

        public string _CodigoFormaCobro
        {
            get { return _cCodigoFormaCobro; }
            set 
            {
                if (_cCodigoFormaCobro != value)
                {
                    _cCodigoFormaCobro = value;
                    NotifyPropertyChanged("_CodigoFormaCobro");
                }
            }
        }
        private string _cCodigoFormaCobro;

        public decimal _Entrega
        {
            get { return _nEntrega; }
            set 
            {
                if (_nEntrega != value)
                {
                    _nEntrega = value;
                    NotifyPropertyChanged("_Entrega");
                }
            }
        }
        private decimal _nEntrega;

        public decimal _Cambio 
        {
            get { return _nCambio; }
            set  
            {
                if (_nCambio != value)
                {
                    _nCambio = value;
                    NotifyPropertyChanged("_Cambio");
                }
            }
        }
        private decimal _nCambio;

        public bool _Activo
        {
            get { return _lActivo; }
            set  
            {
                if (_lActivo != value)
                {
                    _lActivo = value;
                    NotifyPropertyChanged("_Activo");
                }
            }
        }
        private bool _lActivo;

        public bool _PermitirEntregasParciales
        {
            get { return _nPermitirEntregasParciales; }
            set  
            {
                if (_nPermitirEntregasParciales != value)
                {
                    _nPermitirEntregasParciales = value;
                    NotifyPropertyChanged("_PermitirEntregasParciales");
                }
            }
        }
        private bool _nPermitirEntregasParciales;

        public string _Terminal 
        {
            get { return _cTerminal; }
            set  
            {
                if (_cTerminal != value)
                {
                    _cTerminal = value;
                    NotifyPropertyChanged("_Terminal");
                }
            }
        }
        private string _cTerminal = Convert.ToString(EW_GLOBAL._GetVariable("wc_terminal"));

        public string _Error_Message 
        {
            get { return _cError_Message; }
            set  
            {
                if (_cError_Message != value)
                {
                    _cError_Message = value;
                    NotifyPropertyChanged("_Error_Message");
                }
            }
        }
        private string _cError_Message;

        public string _Warning_Message
        {
            get { return _cWarning_Message; }
            set
            {
                if (_cWarning_Message != value)
                {
                    _cWarning_Message = value;
                    NotifyPropertyChanged("_Warning_Message");
                }
            }
        }
        private string _cWarning_Message;

        public string _Wait_Conection_Message
        {
            get { return _cWait_Conection_Message; }
            set
            {
                if (_cWait_Conection_Message != value)
                {
                    _cWait_Conection_Message = value;
                    NotifyPropertyChanged("_Wait_Conection_Message");
                }
            }
        }
        private string _cWait_Conection_Message = "Operando con el cajón inteligente.";


        public Dictionary<string, object> _Propiedades 
        {
            get { return _oPropiedades; }
            set
            {
                if (_oPropiedades != value)
                {
                    _oPropiedades = value;
                    NotifyPropertyChanged("_Propiedades");
                }
            }
        }
        private Dictionary<string, object> _oPropiedades = new Dictionary<string, object>();

        public eCash_OrdenImpresion _ImprimirDocumento
        {
            get { return _oImprimirDocumento; }
            set 
            {
                if (_oImprimirDocumento != value)
                {
                    _oImprimirDocumento = value;
                    NotifyPropertyChanged("_ImprimirDocumento");
                }
            }
        }
        private eCash_OrdenImpresion _oImprimirDocumento = eCash_OrdenImpresion.DespuesCash;

        #region Cobros Caja
        public bool _Visible_CobrosCaja
        {
            get { return _lVisible_CobrosCaja; }
            set
            {
                if (_lVisible_CobrosCaja != value)
                {
                    _lVisible_CobrosCaja = value;
                    NotifyPropertyChanged("_Visible_CobrosCaja");
                }
            }
        }
        private bool _lVisible_CobrosCaja = true;

        public bool _Permitir_CobrosCaja
        {
            get { return _lPermitir_CobrosCaja; }
            set
            {
                if (_lPermitir_CobrosCaja != value)
                {
                    _lPermitir_CobrosCaja = value;
                    NotifyPropertyChanged("_Permitir_CobrosCaja");
                }
            }
        }
        private bool _lPermitir_CobrosCaja = true; 
        #endregion

        #region Cobros Facturas
        public bool _Visible_CobrosFacturas
        {
            get { return _lVisible_CobrosFacturas; }
            set
            {
                if (_lVisible_CobrosFacturas != value)
                {
                    _lVisible_CobrosFacturas = value;
                    NotifyPropertyChanged("_Visible_CobrosFacturas");
                }
            }
        }
        private bool _lVisible_CobrosFacturas = true;

        public bool _Permitir_CobrosFacturas
        {
            get { return _lPermitir_CobrosFacturas; }
            set
            {
                if (_lPermitir_CobrosFacturas != value)
                {
                    _lPermitir_CobrosFacturas = value;
                    NotifyPropertyChanged("_Permitir_CobrosFacturas");
                }
            }
        }
        private bool _lPermitir_CobrosFacturas = false; 
        #endregion

        #region Cobros Varios
        public bool _Visible_CobrosVarios
        {
            get { return _lVisible_CobrosVarios; }
            set
            {
                if (_lVisible_CobrosVarios != value)
                {
                    _lVisible_CobrosVarios = value;
                    NotifyPropertyChanged("_Visible_CobrosVarios");
                }
            }
        }
        private bool _lVisible_CobrosVarios = true;

        public bool _Permitir_CobrosVarios
        {
            get { return _lPermitir_CobrosVarios; }
            set
            {
                if (_lPermitir_CobrosVarios != value)
                {
                    _lPermitir_CobrosVarios = value;
                    NotifyPropertyChanged("_Permitir_CobrosVarios");
                }
            }
        }
        private bool _lPermitir_CobrosVarios = false; 
        #endregion

        #region Pagos Varios
        public bool _Visible_PagosVarios
        {
            get { return _lVisible_PagosVarios; }
            set
            {
                if (_lVisible_PagosVarios != value)
                {
                    _lVisible_PagosVarios = value;
                    NotifyPropertyChanged("_Visible_PagosVarios");
                }
            }
        }
        private bool _lVisible_PagosVarios = true;

        public bool _Permitir_PagosVarios
        {
            get { return _lPermitir_PagosVarios; }
            set
            {
                if (_lPermitir_PagosVarios != value)
                {
                    _lPermitir_PagosVarios = value;
                    NotifyPropertyChanged("_Permitir_PagosVarios");
                }
            }
        }
        private bool _lPermitir_PagosVarios = false; 
        #endregion

        #region Reposiciones
        public bool _Visible_Reposiciones
        {
            get { return _lVisible_Reposiciones; }
            set
            {
                if (_lVisible_Reposiciones != value)
                {
                    _lVisible_Reposiciones = value;
                    NotifyPropertyChanged("_Visible_Reposiciones");
                }
            }
        }
        private bool _lVisible_Reposiciones = true;

        public bool _Permitir_Reposiciones
        {
            get { return _lPermitir_Reposiciones; }
            set
            {
                if (_lPermitir_Reposiciones != value)
                {
                    _lPermitir_Reposiciones = value;
                    NotifyPropertyChanged("_Permitir_Reposiciones");
                }
            }
        }
        private bool _lPermitir_Reposiciones = false; 
        #endregion

        #region Retiros
        public bool _Visible_Retiros
        {
            get { return _lVisible_Retiros; }
            set
            {
                if (_lVisible_Retiros != value)
                {
                    _lVisible_Retiros = value;
                    NotifyPropertyChanged("_Visible_Retiros");
                }
            }
        }
        private bool _lVisible_Retiros = true;

        public bool _Permitir_Retiros
        {
            get { return _lPermitir_Retiros; }
            set
            {
                if (_lPermitir_Retiros != value)
                {
                    _lPermitir_Retiros = value;
                    NotifyPropertyChanged("_Permitir_Retiros");
                }
            }
        }
        private bool _lPermitir_Retiros = false; 
        #endregion

        #region Arqueos
        public bool _Visible_Arqueos
        {
            get { return _lVisible_Arqueos; }
            set
            {
                if (_lVisible_Arqueos != value)
                {
                    _lVisible_Arqueos = value;
                    NotifyPropertyChanged("_Visible_Arqueos");
                }
            }
        }
        private bool _lVisible_Arqueos = false;

        public bool _Permitir_Arqueos
        {
            get { return _lPermitir_Arqueos; }
            set
            {
                if (_lPermitir_Arqueos != value)
                {
                    _lPermitir_Arqueos = value;
                    NotifyPropertyChanged("_Permitir_Arqueos");
                }
            }
        }
        private bool _lPermitir_Arqueos = false;
        #endregion

        #endregion PROPIEDADES

        #region CONSTRUCTOR

        public Cash()
        {
            // Carrega els valors
            this._Load();
        }

        #endregion CONSTRUCTOR

        #region METODOS
        public virtual bool _Load()
        {
            bool llOk = false;

            //Si no tenemos el codigo del terminal que ha entrado, salimos
            if (this._Terminal == null)
            {
                this._Error_Message = "Para cargar la configuración del cash es necesario el terminal.";
                return false;
            }
            
            //Contendra el registro "cash" de la Base de datos
            DataTable dtResult = new DataTable();

            //Recogemos la configuración de la bascula
            string sql = "select CASHXML from " + DB.SQLDatabase("COMUNES", "TERMINAL") + " WHERE codigo=" + DB.SQLString(this._Terminal);
            if (DB.SQLExec(sql, ref dtResult))
            {
                if (dtResult != null && dtResult.Rows.Count > 0)
                {
                    //Carga el contenido del XML de la Base de datos
                    XmlDocument doc = new XmlDocument();
                    DataRow drRow = dtResult.Rows[0];
                    if (!String.IsNullOrEmpty(drRow[0].ToString()))
                    {
                        doc.LoadXml(drRow[0].ToString());

                        //Cogemos todas las variables, en un diccionario
                        foreach (XmlNode node in doc.SelectSingleNode("//curCash"))
                        {
                            if (node.LastChild != null)
                            {
                                if (this._oPropiedades.ContainsKey(node.Name))
                                {
                                    this._oPropiedades[node.Name] = node.LastChild.Value; //Modificamos
                                }
                                else
                                {
                                    this._oPropiedades.Add(node.Name, node.LastChild.Value); //Añadimos
                                }

                                //Convierto el nombre del nodo al enumerable de propiedades
                                eCash_NombrePropiedad lePropiedad = _GetEnum_NombrePropiedad(node.Name);

                                switch (lePropiedad)
                                {
                                    case eCash_NombrePropiedad.Permitir_CobrosCaja:
                                        _lPermitir_CobrosCaja = Convert.ToBoolean(node.LastChild.Value); 
                                        break;

                                    case eCash_NombrePropiedad.Permitir_CobrosFacturas:
                                        _lPermitir_CobrosFacturas = Convert.ToBoolean(node.LastChild.Value); 
                                        break;
                                    case eCash_NombrePropiedad.Permitir_CobrosVarios:
                                        _lPermitir_CobrosVarios = Convert.ToBoolean(node.LastChild.Value);  
                                        break;
                                    case eCash_NombrePropiedad.Permitir_PagosVarios:
                                        _lPermitir_PagosVarios = Convert.ToBoolean(node.LastChild.Value); 
                                        break;
                                    case eCash_NombrePropiedad.Permitir_Reposiciones:
                                        _lPermitir_Reposiciones = Convert.ToBoolean(node.LastChild.Value); 
                                        break;

                                    case eCash_NombrePropiedad.Permitir_Retiros:
                                        _lPermitir_Retiros = Convert.ToBoolean(node.LastChild.Value); 
                                        break;
                                    case eCash_NombrePropiedad.Visible_CobrosCaja:
                                        _lVisible_CobrosCaja = Convert.ToBoolean(node.LastChild.Value); 
                                        break;
                                    
                                    case eCash_NombrePropiedad.Visible_CobrosFacturas:
                                        _lVisible_CobrosFacturas = Convert.ToBoolean(node.LastChild.Value); 
                                        break;
                                    
                                    case eCash_NombrePropiedad.Visible_CobrosVarios:
                                        _lVisible_CobrosVarios = Convert.ToBoolean(node.LastChild.Value); 
                                        break;
                                    
                                    case eCash_NombrePropiedad.Visible_PagosVarios:
                                        _lVisible_PagosVarios = Convert.ToBoolean(node.LastChild.Value); 
                                        break;

                                    case eCash_NombrePropiedad.Visible_Reposiciones:
                                        _lVisible_Reposiciones = Convert.ToBoolean(node.LastChild.Value); 
                                        break;
                                    case eCash_NombrePropiedad.Visible_Retiros:
                                        _lVisible_Retiros = Convert.ToBoolean(node.LastChild.Value); 
                                        break;
                            
                                    case eCash_NombrePropiedad.formacobro:
                                        this._cCodigoFormaCobro = node.LastChild.Value;    
                                        break;
                                    
                                    case eCash_NombrePropiedad.imprimirdocumento:
                                        switch (node.LastChild.Value)
                                        {
                                            case "0":
                                                this._oImprimirDocumento = eCash_OrdenImpresion.AntesCash;
                                                break;

                                            case "1":
                                                this._oImprimirDocumento = eCash_OrdenImpresion.DespuesCash;
                                                break;

                                            case "2":
                                                this._oImprimirDocumento = eCash_OrdenImpresion.NoImprimir;
                                                break;
                                        }
                                        break;
                                    
                                    default:
                                    break;
                                }
                            }
                        }
                        llOk = true;
                    }
                }
            }

            //Inicio un notificador
            _Obtener_Notificador();

            return llOk;
        }
 
        public virtual bool _Save()
        {
            //Si no tenemos el codigo del usuario que ha entrado, salimos
            if (this._Terminal == null)
            {
                this._Error_Message = "Para guardar la configuración del cash es necesario el terminal.";
                return false;
            }

            //Si no tenemos la forma de cobro asignada, salimos
            if (this._CodigoFormaCobro == null)
            {
                this._Error_Message = "Para guardar la configuración del cash es necesario definir la forma de cobro asociada.";
                return false;
            }

            //Variable para resolver el nombre de la propiedad
            string lcNombrePropiedad = "";


            // Guardo la forma de cobro
            lcNombrePropiedad = eCash_NombrePropiedad.formacobro.ToString().ToLower();
            _Update_Property(lcNombrePropiedad, _cCodigoFormaCobro);

            // Guardo el moment en que s'ha d'imprimir el document
            int lnImprimirDocumento = 0;
            switch (this._oImprimirDocumento)
            {
                case eCash_OrdenImpresion.AntesCash:
                    lnImprimirDocumento = 0;
                    break;

                case eCash_OrdenImpresion.DespuesCash:
                    lnImprimirDocumento = 1;
                    break;

                case eCash_OrdenImpresion.NoImprimir:
                    lnImprimirDocumento = 2;
                    break;
            }

            //Propiedad imprmimir documento
            lcNombrePropiedad = eCash_NombrePropiedad.imprimirdocumento.ToString().ToLower();
            _Update_Property(lcNombrePropiedad, lnImprimirDocumento);

            #region Propiedades de operativa permitida

            lcNombrePropiedad = eCash_NombrePropiedad.Permitir_CobrosCaja.ToString().ToLower();
            _Update_Property(lcNombrePropiedad, _lPermitir_CobrosCaja);
            
            lcNombrePropiedad = eCash_NombrePropiedad.Permitir_CobrosFacturas.ToString().ToLower();
            _Update_Property(lcNombrePropiedad, _lPermitir_CobrosFacturas);

            lcNombrePropiedad = eCash_NombrePropiedad.Permitir_CobrosVarios.ToString().ToLower();
            _Update_Property(lcNombrePropiedad, _lPermitir_CobrosVarios);

            lcNombrePropiedad = eCash_NombrePropiedad.Permitir_PagosVarios.ToString().ToLower();
            _Update_Property(lcNombrePropiedad, _lPermitir_PagosVarios);

            lcNombrePropiedad = eCash_NombrePropiedad.Permitir_Reposiciones.ToString().ToLower();
            _Update_Property(lcNombrePropiedad, _lPermitir_Reposiciones);

            lcNombrePropiedad = eCash_NombrePropiedad.Permitir_Retiros.ToString().ToLower();
            _Update_Property(lcNombrePropiedad, _lPermitir_Retiros);

            #endregion Propiedades de operativa permitida

            #region Propiedades de visibilidad de operativa

            lcNombrePropiedad = eCash_NombrePropiedad.Visible_CobrosCaja.ToString().ToLower();
            _Update_Property(lcNombrePropiedad, _lVisible_CobrosCaja);

            lcNombrePropiedad = eCash_NombrePropiedad.Visible_CobrosFacturas.ToString().ToLower();
            _Update_Property(lcNombrePropiedad, _lVisible_CobrosFacturas);

            lcNombrePropiedad = eCash_NombrePropiedad.Visible_CobrosVarios.ToString().ToLower();
            _Update_Property(lcNombrePropiedad, _lVisible_CobrosVarios);

            lcNombrePropiedad = eCash_NombrePropiedad.Visible_PagosVarios.ToString().ToLower();
            _Update_Property(lcNombrePropiedad, _lVisible_PagosVarios);

            lcNombrePropiedad = eCash_NombrePropiedad.Visible_Reposiciones.ToString().ToLower();
            _Update_Property(lcNombrePropiedad, _lVisible_Reposiciones);

            lcNombrePropiedad = eCash_NombrePropiedad.Visible_Retiros.ToString().ToLower();
            _Update_Property(lcNombrePropiedad, _lVisible_Retiros);

            #endregion Propiedades de visibilidad de operativa

            //Create XML header
            XDeclaration lsHead = new XDeclaration("1.0", "Windows-1252", "yes");
            //Create XML content
            XElement lsContent = new XElement("VFPData", new XElement("curCash", this._oPropiedades.Select(kv => new XElement(kv.Key, kv.Value))));
            //Create XML string
            string lsXml = lsHead.ToString() + Environment.NewLine + lsContent.ToString();

            //Saves XML string to the DataBase table: terminal
            string sql = "update " + DB.SQLDatabase("COMUNES", "TERMINAL") + " set cashxml = " + DB.SQLString(lsXml) + " WHERE codigo=" + DB.SQLString(this._Terminal);
            
            if (!DB.SQLExec(sql))
            {
                this._Error_Message = "Se ha producido un error guardando la configuración de su cash en la Base de Datos.";
                return false;
            }

            return true;
        }

        private void _Update_Property(string tcNombrePropiedad, object toValue)
        {
            if (_oPropiedades.ContainsKey(tcNombrePropiedad)) 
                _oPropiedades[tcNombrePropiedad] = toValue;
            else 
                _oPropiedades.Add(tcNombrePropiedad, toValue);
        }

        private eCash_NombrePropiedad _GetEnum_NombrePropiedad(string tcNombre)
        {
            string[] lcNames = Enum.GetNames(typeof(eCash_NombrePropiedad));
            
            foreach (string lcName in lcNames)
            {
                if (lcName.Trim().ToLower() == tcNombre.Trim().ToLower()) return (eCash_NombrePropiedad)Enum.Parse(typeof(eCash_NombrePropiedad), lcName); 
            }

            return eCash_NombrePropiedad.none;
        }

        public virtual bool _Cobrar(docventatpv.ewDocVentaTPV toDocVenta, Decimal tnImporte)
        {
            return true;
        }

        public virtual void _Show()
        {
            Forms.frmCash loForm = new Forms.frmCash(this);
            loForm._ShowDialog();
        }

        public virtual bool _Probar()
        {
            return true;
        }

        public virtual bool _BackOffice()
        {
            return true;
        }

        public virtual bool _Desconectar()
        {
            return true;
        }

        public virtual bool _CobroFactura(CobrosPrevision toCobroFactura, decimal tnImporte)
        {
            //Se debe implemntar en la clase deribada
            return true;
        }

        public virtual bool _CobroVarios(CobrosVarios toCobroVarios, decimal tnImporte)
        {
            //Se debe implemntar en la clase deribada
            return true;
        }

        public virtual bool _PagoVarios(PagosVarios toPagosVarios, decimal tnImporte)
        {
            //Se debe implemntar en la clase deribada
            return true;
        }

        public virtual bool _Reposicion(Reposicion toReposicion, decimal tnImporte)
        {
            //Se debe implemntar en la clase deribada
            return true;
        }

        public virtual bool _Retiro(Retiros toRetiro, decimal tnImporte)
        {
            //Se debe implemntar en la clase deribada
            return true;
        }

        public virtual bool _Abono(Retiros toRetiro, decimal tnImporte)
        {
            //Se debe implemntar en la clase deribada
            return _Retiro(toRetiro, tnImporte);
        }

        public virtual bool _Arqueo(ArqueoTpv toArqueo, decimal tnImporte)
        {
            //Se debe implemntar en la clase deribada
            return true;
        }

        public virtual void _Obtener_Notificador()
        {
            //Instancia un formulario de notificación y le paso un ICash como parámetro
            if (!Sage.ES.S50.UnitTest.Tools.UnitTestDectector.Instance.IsInUnitTest)
            {
                _oNotifier = new Forms.frmWaitingFor(this);
            }
        }
        private object _oNotifier = null;

        public static bool _GetICash(out ICash toCash)
        {
            Terminal loTerminal = new Terminal();
            ICash loCash = loTerminal.Cash();
            if (loCash != null)
            {
                toCash = loCash;
                return true;
            }
            toCash = null;
            return false;
        }

        #endregion METODOS

        #region METODOS PROTECTED

        protected string _Connect(string tcServerIP, int tnPort, string lcMessage)
        {

            string lcResposta = string.Empty;

            try
            {
                // Create a TcpClient.
                // The client requires a TcpServer that is connected
                // to the same address specified by the server and port
                // combination.

                TcpClient client = new TcpClient(tcServerIP, tnPort);

                // Translate the passed message into ASCII and store it as a byte array.
                Byte[] data = new Byte[256];
                data = System.Text.Encoding.ASCII.GetBytes(lcMessage);

                // Get a client stream for reading and writing.
                // Stream stream = client.GetStream();
                NetworkStream stream = client.GetStream();

                // Send the message to the connected TcpServer. 
                stream.Write(data, 0, data.Length);

                // Buffer to store the response bytes.
                data = new Byte[256];

                // String to store the response ASCII representation.
                String responseData = String.Empty;

                // Read the first batch of the TcpServer response bytes.
                Int32 bytes = stream.Read(data, 0, data.Length);
                responseData = System.Text.Encoding.ASCII.GetString(data, 0, bytes);

                lcResposta = responseData;

                // Close everything.
                stream.Close();
                client.Close();
            }
            catch (ArgumentNullException e)
            {
                _Error_Message = "ArgumentNullException: " + e;
            }
            catch (SocketException e)
            {
                _Error_Message = "SocketException: " + e.ToString();
            }

            return lcResposta;
        }
        #endregion METODOS PROTECTED
    }
}