

namespace GMLL00ImportadorXsd.Logica
{
    using System;
    using System.Xml;
    using System.IO;
    using System.Xml.Schema;
    using System.Collections;
    using System.Collections.Generic;
    using System.Collections.ObjectModel;
    using System.Transactions;
    using Negocio;
    using System.Globalization;
    using System.Threading;
    using System.Configuration;


    public class FicheroXsd
    {
        Familia ObjFamilia = new Familia();
        Capa ObjCapa = new Capa();
        Estilo ObjEstilo = new Estilo();
        CampoCapa ObjCampoCapa = new CampoCapa();
        Dominio ObjDominio = new Dominio();
        ValoresDominio ObjValorDominio = new ValoresDominio();
        string Fichero = string.Empty;
        FicheroTexto ObjFichTexto = new FicheroTexto();

        private string RutaSalidaSql = string.Empty;
        private string NombreFicheroSqlSalida = string.Empty;
        private ObtenerDatos ObjObtDatos = new ObtenerDatos();
        private string AdjuntarNombreCapa = string.Empty;


        public FicheroXsd(string rutaFicheroXsd, string rutaEstilos, string rutaSalidaSql)
        {
            Fichero = rutaFicheroXsd;
            RutaSalidaSql = rutaSalidaSql;
            ObjEstilo.RutaFichero = rutaEstilos;
            AdjuntarNombreCapa = ObjObtDatos.AdjuntarNombreCapa.ToUpperInvariant();
        }


        public string ObtenerDatosEntrada()
        {
            int contadorDomain = 0;
            string salida = String.Empty;
            ArrayList CrearQueries = new ArrayList();
          
            NombreFicheroSqlSalida = Convert.ToString(ConfigurationManager.AppSettings["NombreFicheroSql"], null); 
            try
            {
                //Leemos el fichero XSD
                XmlTextReader reader = new XmlTextReader(Fichero);
                XmlSchema myschema = XmlSchema.Read(reader, ValidationCallback);
                XmlSchemaSet schemaSet = new XmlSchemaSet();
                schemaSet.Add(myschema);
                schemaSet.Compile();

                //Obtenemos las Familias textos
                XmlSchemaObjectCollection ObjColl = myschema.Items;
                int tipoGeometria = 0;

                try
                {
                    // Recorriendo el ObjColl, obtenemos las annotaciones del XSD, es decir las familias.
                    foreach (XmlSchemaAnnotation obj in ObjColl)
                    {
                        for (int i = 0; i <= obj.Items.Count - 1; i++)
                        {
                            XmlSchemaObject Object = obj.Items[i];
                            XmlSchemaAppInfo AppInf = new XmlSchemaAppInfo();
                            AppInf = (XmlSchemaAppInfo)Object;
                            XmlNode[] xmlNode = AppInf.Markup;

                            foreach (XmlNode xn in xmlNode)
                            {
                                ObjFamilia.NombreFamilia = xn.Name;
                                //la informacion acerca del idioma en este caso no es relevante.
                                if (!(ObjFamilia.NombreFamilia.ToUpper(CultureInfo.InvariantCulture).Equals("IDIOMA")))
                                {
                                    XmlNodeList listaNodos = xn.ChildNodes;

                                    for (int j = 0; j <= listaNodos.Count - 1; j++)
                                    {
                                        IEnumerator ObjIEnum1 = listaNodos.GetEnumerator();
                                        while (ObjIEnum1.MoveNext())
                                        {
                                            XmlNode nameIdioma = (XmlNode)ObjIEnum1.Current;
                                            string name = nameIdioma.Name;
                                            XmlNodeList nodeUltimo = nameIdioma.ChildNodes;

                                            if (name.ToUpper(CultureInfo.InvariantCulture).Equals("NAME"))
                                            {
                                                for (int k = 0; k <= nodeUltimo.Count - 1; k++)
                                                {
                                                    XmlNode clases = nodeUltimo.Item(k);
                                                    if (clases.Name.ToUpper(CultureInfo.InvariantCulture).Equals("EU"))
                                                    {
                                                        ObjFamilia.NombreEU = clases.InnerText;
                                                    }
                                                    if (clases.Name.ToUpper(CultureInfo.InvariantCulture).Equals("ES"))
                                                    {
                                                        ObjFamilia.NombreES = clases.InnerText;
                                                    }
                                                }
                                            }

                                            if (name.ToUpper(CultureInfo.InvariantCulture).Equals("DESCRIPCION"))
                                            {
                                                for (int k = 0; k <= nodeUltimo.Count - 1; k++)
                                                {
                                                    XmlNode clases = nodeUltimo.Item(k);
                                                    if (clases.Name.ToUpper(CultureInfo.InvariantCulture).Equals("EU"))
                                                    {
                                                        ObjFamilia.DescripcionEU = clases.InnerText;
                                                    }
                                                    if (clases.Name.ToUpper(CultureInfo.InvariantCulture).Equals("ES"))
                                                    {
                                                        ObjFamilia.DescripcionES = clases.InnerText;
                                                    }
                                                }
                                            }
                                            if (name.ToUpper(CultureInfo.InvariantCulture).Equals("CLASES"))
                                            {
                                                ObjFamilia.CapasFamilia.Clear();
                                                for (int k = 0; k <= nodeUltimo.Count - 1; k++)
                                                {
                                                    XmlNode clases = nodeUltimo.Item(k);

                                                    ObjFamilia.CapasFamilia.Add(clases.Name);
                                                }

                                            }
                                        }
                                    }

                                    //Creamos los inserts.
                                    this.CrearInsertFamilia(RutaSalidaSql, ObjFamilia);


                                    //Cuando acabe de crear el insert de la familia hay que empezar a leer las capas de esa familia
                                    ////////////////////////
                                    foreach (DictionaryEntry entry in myschema.Elements)
                                    {
                                        if (entry.Value is XmlSchemaElement)
                                        {

                                            XmlSchemaElement rootelement = (XmlSchemaElement)entry.Value;
                                            string nombreElement = rootelement.Name;
                                            ObjCapa.NombreCapa = nombreElement;

                                            if (!(nombreElement.ToUpper(CultureInfo.InvariantCulture).Equals("metadata".ToUpper(CultureInfo.InvariantCulture))))
                                            {
                                                //si no es metadatos hacemos lectura de la información
                                                //Comprobamos tambien que la capa corresponde a la familia 
                                                for (int b = 0; b <= ObjFamilia.CapasFamilia.Count - 1; b++)
                                                {

                                                    if (ObjFamilia.CapasFamilia[b].ToString().ToUpper(CultureInfo.InvariantCulture).Equals(nombreElement.ToUpper(CultureInfo.InvariantCulture)))
                                                    {

                                                        if (rootelement.ElementSchemaType is XmlSchemaComplexType)
                                                        {
                                                            ///////////////////// INICIO SACAMOS LOS VALORES DE ANOTATION DE LA CAPA
                                                            if (rootelement.ElementSchemaType.Annotation is XmlSchemaAnnotation)
                                                            {
                                                                XmlSchemaAnnotation annotationCapa = (XmlSchemaAnnotation)rootelement.ElementSchemaType.Annotation;

                                                                for (int q = 0; q <= annotationCapa.Items.Count - 1; q++)
                                                                {
                                                                    XmlSchemaObject ObjectA = annotationCapa.Items[q];
                                                                    ObjCapa.NombreEU = this.ObtenerValorNodo(ObjectA, "NAME", "EU");
                                                                    ObjCapa.NombreES = this.ObtenerValorNodo(ObjectA, "NAME", "ES");

                                                                    ObjCapa.DescripcionEU = this.ObtenerValorNodo(ObjectA, "DESCRIPCION", "EU");
                                                                    ObjCapa.DescripcionES = this.ObtenerValorNodo(ObjectA, "DESCRIPCION", "ES");

                                                                }
                                                                //Aqui debemos insertar el objeto capa 
                                                                int NumeroCapa = b + 1;
                                                                this.ObjEstilo.NombreFichero = ObjCapa.NombreCapa;
                                                                this.CrearInsertEstilos(RutaSalidaSql, ObjEstilo);
                                                                this.CrearInsertCapa(RutaSalidaSql, ObjCapa, NumeroCapa);


                                                            }
                                                            ///////////// FIN DE SACAMOS LOS VALORES DE ANOTATION DE LA CAPA

                                                            XmlSchemaComplexType roottype = (XmlSchemaComplexType)rootelement.ElementSchemaType;

                                                            if (roottype.ContentTypeParticle is XmlSchemaSequence)
                                                            {
                                                                XmlSchemaSequence sequence = roottype.ContentTypeParticle as XmlSchemaSequence;
                                                                //limpiamos el array para cargar solo los datos de la capa nueva
                                                                CrearQueries.Clear();
                                                                foreach (XmlSchemaElement childElement in sequence.Items)
                                                                {
                                                                    try
                                                                    {
                                                                        if (childElement.ElementSchemaType is XmlSchemaSimpleType)
                                                                        {
                                                                            XmlSchemaSimpleType simpleTipo = (XmlSchemaSimpleType)childElement.ElementSchemaType;
                                                                            ObjCampoCapa.NomCamCapa = childElement.Name;

                                                                            CrearQueries.Add(this.CambioNombreColumna(ObjCampoCapa.NomCamCapa));

                                                                            ObjCampoCapa.TipoDato = childElement.ElementSchemaType.TypeCode.ToString();

                                                                            XmlSchemaAnnotation annotationCamCapa = childElement.Annotation;

                                                                            for (int r = 0; r <= annotationCamCapa.Items.Count - 1; r++)
                                                                            {
                                                                                XmlSchemaObject ObjectCamCapa = annotationCamCapa.Items[r];
                                                                                ObjCampoCapa.NombreEU = this.ObtenerValorNodo(ObjectCamCapa, "NAME", "EU");
                                                                                ObjCampoCapa.NombreES = this.ObtenerValorNodo(ObjectCamCapa, "NAME", "ES");

                                                                                ObjCampoCapa.DescripcionEU = this.ObtenerValorNodo(ObjectCamCapa, "DESCRIPCION", "EU");
                                                                                ObjCampoCapa.DescripcionES = this.ObtenerValorNodo(ObjectCamCapa, "DESCRIPCION", "ES");

                                                                                //insertamos la nueva campoCapa
                                                                                this.CrearInsertCampoCapa(RutaSalidaSql, ObjCapa, ObjCampoCapa);

                                                                            }
                                                                            ////////AQUI EMPEZAMOS A COMPROBAR SI EL CAMPO TIENE DOMINIOS.
                                                                            ////////////////////////////////////////////////////////////////////
                                                                            ////////////////////////////////////////////////////////////////////

                                                                            try
                                                                            {
                                                                                if (!childElement.ElementSchemaType.Name.Equals(null))
                                                                                {
                                                                                    ObjDominio.NombreDominio = ObjCampoCapa.NombreES;
                                                                                    if (contadorDomain == 0)
                                                                                    {
                                                                                        this.CrearInsertDomainCategory(RutaSalidaSql);
                                                                                        contadorDomain++;
                                                                                    }
                                                                                    this.CrearInsertDomain(RutaSalidaSql, ObjCampoCapa, ObjDominio, ObjCapa.NombreCapa);

                                                                                    //si tenemos otra funcion debemos ir a buscar los valores de ella, mas hijos
                                                                                    XmlSchemaSimpleTypeContent content = (XmlSchemaSimpleTypeContent)simpleTipo.Content;

                                                                                    if (content is XmlSchemaSimpleTypeRestriction)
                                                                                    {
                                                                                        XmlSchemaSimpleTypeRestriction rest = (XmlSchemaSimpleTypeRestriction)simpleTipo.Content;
                                                                                        //string restricion = rest.BaseTypeName.Name;
                                                                                        XmlSchemaObjectCollection colecAtributos = new XmlSchemaObjectCollection();
                                                                                        colecAtributos = rest.Facets;

                                                                                        IEnumerator iterator = colecAtributos.GetEnumerator();
                                                                                        while (iterator.MoveNext())
                                                                                        {
                                                                                            XmlSchemaEnumerationFacet enumerator = (XmlSchemaEnumerationFacet)iterator.Current;
                                                                                            ObjValorDominio.Valor = Convert.ToString(enumerator.Value, null);
                                                                                            XmlSchemaAnnotation annotationDominio = enumerator.Annotation;

                                                                                            for (int k = 0; k <= annotationDominio.Items.Count - 1; k++)
                                                                                            {
                                                                                                XmlSchemaObject ObjectDominio = annotationDominio.Items[k];
                                                                                                ObjValorDominio.NombreValorDominioEU = this.ObtenerValorNodo(ObjectDominio, "NAME", "EU");
                                                                                                ObjValorDominio.NombreValorDominioES = this.ObtenerValorNodo(ObjectDominio, "NAME", "ES");

                                                                                                ObjCampoCapa.DescripcionEU = this.ObtenerValorNodo(ObjectDominio, "DESCRIPCION", "EU");
                                                                                                ObjCampoCapa.DescripcionES = this.ObtenerValorNodo(ObjectDominio, "DESCRIPCION", "ES");

                                                                                                this.CrearInsertValoresDominio(RutaSalidaSql, ObjValorDominio);
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            catch (NullReferenceException)
                                                                            {
                                                                            }
                                                                        }
                                                                        else if (childElement.ElementSchemaType is XmlSchemaComplexType)
                                                                        {
                                                                            if (!(string.IsNullOrEmpty(childElement.Name)))
                                                                            {
                                                                                ObjCampoCapa.NomCamCapa = childElement.Name;
                                                                                ObjCampoCapa.TipoDato = childElement.ElementSchemaType.Name;
                                                                                tipoGeometria = this.CrearInsertGeometryCampoCapa(RutaSalidaSql, ObjCapa, ObjCampoCapa);
                                                                            }
                                                                        }
                                                                    }
                                                                    catch (XmlSchemaValidationException)
                                                                    {

                                                                    }

                                                                }
                                                                this.CrearInsertCampoCapaIdMun(RutaSalidaSql, ObjCapa, tipoGeometria);

                                                                //una vez que tenemos todos los valores podemos crear las queries;
                                                                this.CrearInsertQueries(RutaSalidaSql, CrearQueries, ObjCapa.NombreCapa, tipoGeometria);

                                                            }
                                                        }

                                                    }

                                                }

                                            }

                                        }
                                    }

                                }
                            }

                        }

                    }

                }
                catch (InvalidCastException)
                {
                }
            }
            catch (XmlException ex)
            {
                salida = ex.Message;
            }
            catch (XmlSchemaException ex) { salida = ex.Message; }
            return salida;
        }


        //Obtener name /descripcion de los valores solicitados.
        private string ObtenerValorNodo(XmlSchemaObject Object, string campo, string idioma)
        {
            string valorDato = string.Empty;
            XmlSchemaAppInfo AppInf = new XmlSchemaAppInfo();
            AppInf = (XmlSchemaAppInfo)Object;
            XmlNode[] xmlNode = AppInf.Markup;

            foreach (XmlNode xn in xmlNode)
            {
                XmlNodeList nodeUltimo = xn.ChildNodes;
                if (xn.Name.ToUpper(CultureInfo.InvariantCulture).Equals(campo))
                {
                    for (int i = 0; i <= nodeUltimo.Count - 1; i++)
                    {
                        XmlNode clases = nodeUltimo.Item(i);
                        if (clases.Name.ToUpper(CultureInfo.InvariantCulture).Equals(idioma))
                        {
                            valorDato = clases.InnerText;
                        }
                    }
                }
            }

            return valorDato;
        }


        private static string TruncarLongitudDato(string dato, int longitud)
        {

            if (dato.Length > longitud)
            {
                dato = dato.Substring(0, longitud);
            }
            return dato;
        }

        //Creamos un metodo para la actualizacion de secuencias seq_domains y seq_domainnodes
        private void ActualizarSecuencias(string rutaSalidaSql)
        {
            string actualizaSecuencias = string.Empty;
            string comentario = string.Empty;
            //antes de iniciar el script actualizamos las secuencias
            comentario = "---antes de iniciar el script actualizamos las secuencias;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);
            actualizaSecuencias = "select setval('seq_domains',(SELECT cast(max(id)as bigint) FROM domains));";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, actualizaSecuencias);
            actualizaSecuencias = "select setval('seq_domainnodes',(SELECT cast(max(id)as bigint) FROM domainnodes));";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, actualizaSecuencias);
        }

        //Creamos los insert relacionados con la familia
        private void CrearInsertFamilia(string rutaSalidaSql, Familia ObjFamilia)
        {
            string insertFamilia = string.Empty;
            string comentario = string.Empty;

            comentario = "---------------------------------------------------------------------------------------------------;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);
            comentario = "----------------------------- INSERT DICTIONARY INICIO FAMILIAS  ----------------------------------;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);
            comentario = "---------------------------------------------------------------------------------------------------;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);

            this.ActualizarSecuencias(rutaSalidaSql);

            //Insertamos en dictionary el nombre de la familia
            insertFamilia = "insert into dictionary (id_vocablo,locale, traduccion) values (nextval('seq_dictionary'),'es_ES','" + TruncarLongitudDato(ObjFamilia.NombreES, 255) + "');";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertFamilia);
            insertFamilia = "insert into dictionary (id_vocablo,locale, traduccion) values (currval('seq_dictionary'),'eu_ES','" + TruncarLongitudDato(ObjFamilia.NombreEU, 255) + "');";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertFamilia);

            //Insertamos en dictionary la descripcion de la familia
            insertFamilia = "insert into dictionary (id_vocablo,locale, traduccion) values (nextval('seq_dictionary'),'es_ES','" + TruncarLongitudDato(ObjFamilia.DescripcionES, 255) + "');";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertFamilia);
            insertFamilia = "insert into dictionary (id_vocablo,locale, traduccion) values (currval('seq_dictionary'),'eu_ES','" + TruncarLongitudDato(ObjFamilia.DescripcionEU, 255) + "');";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertFamilia);

            // insert layerfamilies
            // Buscamos el indice de dictionary para guardar el layerfamilies 
            comentario = "--insert layerfamilies;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);
            insertFamilia = "insert into layerfamilies (id_layerfamily,id_name,id_description) values (nextval('seq_layerfamilies'), (SELECT max(id_vocablo) FROM dictionary  where locale ='es_ES' and traduccion='" + TruncarLongitudDato(ObjFamilia.NombreES, 255) + "') ,currval('seq_dictionary'));";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertFamilia);

        }

        //Creamos los insert relacionados con los estilos
        private void CrearInsertEstilos(string rutaSalidaSql, Estilo ObjEstilo)
        {
            string insertEstilos = string.Empty;
            string comentario = string.Empty;

            comentario = "--INSERT DE LOS ESTILOS DE LA CAPA;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);
            //Los estilos de la capa lo leeremos de un fichero xml.


            if (File.Exists(ObjEstilo.RutaFichero + "\\" + ObjEstilo.NombreFichero + ".xml"))
            {
                StreamReader sr = new StreamReader(ObjEstilo.RutaFichero + "\\" + ObjEstilo.NombreFichero + ".xml");
                ObjEstilo.Texto = sr.ReadToEnd().Replace("'", "''"); //Reemplazamos en sr la comilla simple por 2 comillas simple, para que lo escriba correctamente               
                sr.Close();
            }
            else
            {                
                ObjEstilo.Texto = "";
                string NombreFicheroLog = ConfigurationManager.AppSettings["NombreFicheroLog"].ToString();
                this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroLog, "No existe el fichero de estilo " + ObjEstilo.NombreFichero);
            }

            insertEstilos = "insert into STYLES (ID_STYLE, XML) values(nextval('seq_styles'),'" + ObjEstilo.Texto + "');";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertEstilos);
        }


        //Insertamos informacion de la capa. 
        private void CrearInsertCapa(string rutaSalidaSql, Capa ObjCapa, int NumeroCapa)
        {
            string insertCapa = string.Empty;
            string comentario = string.Empty;
            string adjuntaNom = string.Empty;
            if (AdjuntarNombreCapa.Equals("SI", StringComparison.OrdinalIgnoreCase))
            {
                adjuntaNom = "_" + ObjCapa.NombreCapa;
            }
            else
            {
                adjuntaNom = "";
            }

            comentario = "---------------------------------------------------------------------------------------------------;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);
            comentario = "----------------------------- INSERT DICTIONARY INICIO CAPA  ----------------------------------;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);
            comentario = "---------------------------------------------------------------------------------------------------;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);
            //Insertamos dictionary con los name de la capa

            insertCapa = "INSERT INTO dictionary (id_vocablo,locale, traduccion) values (nextval('seq_dictionary'),'es_ES','" + TruncarLongitudDato(ObjCapa.NombreES + adjuntaNom, 255) + "');";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCapa);
            insertCapa = "INSERT INTO dictionary (id_vocablo,locale, traduccion) values (currval('seq_dictionary'),'eu_ES','" + TruncarLongitudDato(ObjCapa.NombreEU + adjuntaNom, 255) + "');";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCapa);

            comentario = " --Insertamos dictionary con los name de la capa;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);
            //OJO La  palabra capa del nombre esta escrita manualmente.INSERT INTO 


            insertCapa = "INSERT INTO acl(idacl, name) VALUES (nextval('seq_acl'),'" + TruncarLongitudDato("Capa " + ObjCapa.NombreES + adjuntaNom, 50) + "');";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCapa);


            //-- INSERT DE R_ACL_PERM
            comentario = " -- INSERT DE R_ACL_PERM;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);

            insertCapa = "INSERT INTO r_acl_perm (idperm, idacl) VALUES (871, currval('seq_acl') );"; // --'Geopista.Layer.Leer'
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCapa);
            insertCapa = "INSERT INTO r_acl_perm (idperm, idacl) VALUES (872, currval('seq_acl') );"; // --'Geopista.Layer.Escribir'
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCapa);
            insertCapa = "INSERT INTO r_acl_perm (idperm, idacl) VALUES (873, currval('seq_acl') );"; // --'Geopista.Layer.Añadir'
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCapa);
            insertCapa = "INSERT INTO r_acl_perm (idperm, idacl) VALUES (874, currval('seq_acl') );"; // --'Geopista.Layer.ModificarSLD' 
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCapa);

            //--Insertamos Layers, con todos los Id necesarios
            comentario = " --Insertamos Layers, con todos los Id necesarios;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);
            insertCapa = "INSERT INTO LAYERS(ID_LAYER,ID_NAME,ID_STYLES,ACL,NAME,MODIFICABLE,ID_ENTIDAD) VALUES (NEXTVAL('seq_layers'),CURRVAL('seq_dictionary'),CURRVAL('seq_styles'),CURRVAL('seq_acl'),'" + ObjCapa.NombreCapa + "',1,0);";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCapa);

            // -- Insertado layer ya podemos insertar la relacion en la familia
            comentario = "-- Insertado layer ya podemos insertar la relacion en la familia;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);
            //-- OJO, para poner la position habra que tener en cuenta cuantas capas existen en cada familia y de  cual se trata. Empezamos con = 1 
            insertCapa = "insert into layerfamilies_layers_relations (id_layerfamily, id_layer, position) values (currval('seq_layerfamilies'),currval('seq_layers')," + NumeroCapa + ");";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCapa);

            //      ----------------------------------------
            //      -----INSERTAMOS LA TablaNuevaCapa
            //      ----------------------------------------
            comentario = "     ----------------------------------------;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);
            comentario = "     -----INSERTAMOS LA TablaNuevaCapa-----;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);
            comentario = "     ----------------------------------------;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);

            insertCapa = "CREATE TABLE " + ObjCapa.NombreCapa + " () WITH OIDS;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCapa);
            insertCapa = "GRANT ALL ON TABLE " + ObjCapa.NombreCapa + " TO visualizador;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCapa);
            insertCapa = "GRANT SELECT ON TABLE " + ObjCapa.NombreCapa + " TO guiaurbana;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCapa);
            insertCapa = "GRANT SELECT ON TABLE " + ObjCapa.NombreCapa + " TO consultas;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCapa);
        }

        private int CrearInsertGeometryCampoCapa(string rutaSalidaSql, Capa ObjCapa, CampoCapa ObjCampoCapa)
        {
            // Cuando conseguimos la geometria de la capa insertamos en Tables
            // Y ya podemos insertar las columnas id, geometry.

            //----------------------------------------
            //-----Creamos insert en tables
            //----------------------------------------
            //         --alfanumerico: null
            //         --geometry: 0
            //         --point: 1
            //         --linestring: 3
            //         --polygon: 5
            //         --collection: 6
            //         --multipoint:	7
            //         --multilinestring: 9
            //         --multipolygon: 11
            string insertGeometryCamposCapa = string.Empty;
            string comentario = string.Empty;
            int tipoGeomentria = 0;

            switch (ObjCampoCapa.TipoDato)
            {
                case "PointPropertyType":
                    tipoGeomentria = 7;
                    break;
                case "LineStringPropertyType":
                    tipoGeomentria = 9;
                    break;
                case "PolygonPropertyType":
                    tipoGeomentria = 11;
                    break;
                default:
                    break;
            }

            //----------------------------------------
            //-----Creamos insert en tables
            //----------------------------------------
            comentario = "---------------------------------------------------------------------------------------------------;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);
            comentario = "----------------------------- INSERT DICTIONARY INICIO CAMPOS CAPA  ----------------------------------;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);
            comentario = "---------------------------------------------------------------------------------------------------;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);



            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);
            insertGeometryCamposCapa = "INSERT INTO tables (id_table, name, geometrytype, external) VALUES(nextval('seq_tables'),'" + ObjCapa.NombreCapa + "'," + tipoGeomentria + ",0);";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertGeometryCamposCapa);
            //--Insertamos columna en la nueva tabla 

            insertGeometryCamposCapa = "ALTER TABLE " + ObjCapa.NombreCapa + " ADD COLUMN id NUMERIC(8)  UNIQUE;  ALTER TABLE " + ObjCapa.NombreCapa + " ALTER COLUMN id SET NOT NULL;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertGeometryCamposCapa);

            insertGeometryCamposCapa = "insert into columns (id,id_table,name,\"Length\",\"Precision\",\"Scale\",\"Type\") values (nextval('seq_columns'),CURRVAL('seq_tables'),'id',null,8,0,2);";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertGeometryCamposCapa);
            //--insertamos en dictionary para los atributes
            comentario = "--insertamos en dictionary para los atributes;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);

            insertGeometryCamposCapa = "insert into dictionary (id_vocablo,locale, traduccion) values (nextval('seq_dictionary'),'es_ES','id');  ";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertGeometryCamposCapa);
            insertGeometryCamposCapa = "insert into dictionary (id_vocablo,locale, traduccion) values (CURRVAL('seq_dictionary'),'eu_ES','id');  ";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertGeometryCamposCapa);
            insertGeometryCamposCapa = "insert into attributes (id, id_alias, id_layer, id_column, position, editable) values (nextval('seq_attributes'),currval('seq_dictionary'),CURRVAL('seq_layers'),CURRVAL('seq_columns'),1,true);";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertGeometryCamposCapa);
            insertGeometryCamposCapa = "insert into columns_domains (id_domain, id_column, level) values (10067,CURRVAL('seq_columns'),0); "; // -- El ID siempre lleva el valor 10067 de los dominios 
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertGeometryCamposCapa);

            insertGeometryCamposCapa = "ALTER TABLE " + ObjCapa.NombreCapa + " ADD COLUMN \"GEOMETRY\" GEOMETRY;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertGeometryCamposCapa);
            insertGeometryCamposCapa = "insert into columns (id,id_table,name,\"Length\",\"Precision\",\"Scale\",\"Type\") values (nextval('seq_columns'),CURRVAL('seq_tables'),'GEOMETRY',null,0,0,1);";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertGeometryCamposCapa);
            // --insertamos en dictionary para los atributes
            insertGeometryCamposCapa = "insert into dictionary (id_vocablo,locale, traduccion) values (nextval('seq_dictionary'),'es_ES','GEOMETRY');";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertGeometryCamposCapa);
            insertGeometryCamposCapa = "insert into dictionary (id_vocablo,locale, traduccion) values (CURRVAL('seq_dictionary'),'eu_ES','GEOMETRY'); ";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertGeometryCamposCapa);
            insertGeometryCamposCapa = "insert into attributes (id, id_alias, id_layer, id_column, position, editable) values (nextval('seq_attributes'),currval('seq_dictionary'),CURRVAL('seq_layers'),CURRVAL('seq_columns'),(select max(position)+1 from attributes where id_layer=currval('seq_layers')),true);";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertGeometryCamposCapa);

            return tipoGeomentria;
        }


        // Cambiamos el nombre de la columna. 
        // Localgis tiene en sus tablas una columna por defecto llamada ID, por lo que no puede existir otra con el mismo nombre.
        // La modificamos el nombre por "IDGIS". A la columna AÑO tambien le cambiamos el nombre, para quitarle la Ñ evitando asi posibles problemas.
        private string CambioNombreColumna(string nombreColumna)
        {
            if (nombreColumna.ToUpper(CultureInfo.InvariantCulture).Equals("ID"))
            {
                nombreColumna = "IDGIS";
            }
            else if (nombreColumna.ToUpper(CultureInfo.InvariantCulture).Equals("AÑO"))
            {
                nombreColumna = "ANNO";
            }
            return nombreColumna;
        }

        private void CrearInsertCampoCapa(string rutaSalidaSql, Capa ObjCapa, CampoCapa ObjCampoCapa)
        {
            string insertCamposCapa = string.Empty;
            string comentario = string.Empty;
            int tipoDato = 0;
            string nombreCampo = string.Empty;

            //-- Insertamos la columna en columns
            //-- Valores de type:
            //-- Geometry 1
            //-- varchar 3 
            //-- date 4 
            //-- numeric 2 
            //-- char 3 
            //-- entero 2
            //-- > Si es varchar solo se rellena el length --> sino se rellenan precision y escala y el length no.



            comentario = "--insertamos los ALTER TABLE de columns;";
            ObjCampoCapa.NomCamCapa = this.CambioNombreColumna(ObjCampoCapa.NomCamCapa);

            nombreCampo = ObjCampoCapa.NomCamCapa.ToLower(CultureInfo.CurrentCulture);


            //leer fichero configuracion
            switch (ObjCampoCapa.TipoDato)
            {
                case "Integer":
                    tipoDato = 2;
                    insertCamposCapa = "ALTER TABLE " + ObjCapa.NombreCapa + " ADD COLUMN " + ObjCampoCapa.NomCamCapa + " integer;";
                    this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapa);
                    insertCamposCapa = "insert into columns (id,id_table,name,\"Length\",\"Precision\",\"Scale\",\"Type\") values (nextval('seq_columns'),CURRVAL('seq_tables'),'" + nombreCampo + "',null,0,0," + tipoDato + ");";
                    this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapa);
                    break;
                case "String":
                    tipoDato = 3;
                    insertCamposCapa = "ALTER TABLE " + ObjCapa.NombreCapa + " ADD COLUMN " + ObjCampoCapa.NomCamCapa + " VARCHAR(" + ObjObtDatos.LongString + ");";
                    this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapa);
                    insertCamposCapa = "insert into columns (id,id_table,name,\"Length\",\"Precision\",\"Scale\",\"Type\") values (nextval('seq_columns'),CURRVAL('seq_tables'),'" + nombreCampo + "'," + ObjObtDatos.LongString + ",null,null," + tipoDato + ");";
                    this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapa);
                    break;
                case "Double":
                    tipoDato = 2;
                    insertCamposCapa = "ALTER TABLE " + ObjCapa.NombreCapa + " ADD COLUMN " + ObjCampoCapa.NomCamCapa + "  numeric(" + ObjObtDatos.LongDouble + ");";
                    this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapa);
                    insertCamposCapa = "insert into columns (id,id_table,name,\"Length\",\"Precision\",\"Scale\",\"Type\") values (nextval('seq_columns'),CURRVAL('seq_tables'),'" + nombreCampo + "',null," + ObjObtDatos.LongDouble + "," + tipoDato + ");";
                    //insertCamposCapa = "insert into columns (id,id_table,name,\"Length\",\"Precision\",\"Scale\",\"Type\") values (nextval('seq_columns'),CURRVAL('seq_tables'),'" + nombreCampo + "',null,18,2," + tipoDato + ");";
                    this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapa);
                    break;
                default:
                    break;
            }

            //  --insertamos en dictionary para los atributes

            comentario = "--insertamos en dictionary para los atributes;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);

            insertCamposCapa = "insert into dictionary (id_vocablo,locale, traduccion) values (nextval('seq_dictionary'),'es_ES','" + TruncarLongitudDato(ObjCampoCapa.NombreES, 255) + "');";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapa);

            insertCamposCapa = "insert into dictionary (id_vocablo,locale, traduccion) values (CURRVAL('seq_dictionary'),'eu_ES','" + TruncarLongitudDato(ObjCampoCapa.NombreEU, 255) + "'); ";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapa);
            insertCamposCapa = "insert into attributes (id, id_alias, id_layer, id_column, position, editable) values (nextval('seq_attributes'),currval('seq_dictionary'),CURRVAL('seq_layers'),CURRVAL('seq_columns'),(select max(position)+1 from attributes where id_layer=currval('seq_layers')),true);";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapa);
        }


        private void CrearInsertCampoCapaIdMun(string rutaSalidaSql, Capa ObjCapa, int tipoGeometria)
        {
            string insertCamposCapaIdMun = string.Empty;
            string comentario = string.Empty;
            int tipoDato = 0;
            //antes de insertar el IdMuncipio tenemos que insertar el campo longitud si es linea, y perimetro y superficie si es poligono
            //en ambos casos el dato es de tipo double
            //es tipoGeometria=7 cuando se trata de punto
            switch (tipoGeometria)
            {
                case 9:   //en este caso es linea
                    tipoDato = 2;
                    insertCamposCapaIdMun = "ALTER TABLE " + ObjCapa.NombreCapa + " ADD COLUMN longitud_localgis  numeric(" + ObjObtDatos.LongDouble + ");";
                    this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapaIdMun);
                    insertCamposCapaIdMun = "insert into columns (id,id_table,name,\"Length\",\"Precision\",\"Scale\",\"Type\") values (nextval('seq_columns'),CURRVAL('seq_tables'),'longitud_localgis',null," + ObjObtDatos.LongDouble + "," + tipoDato + ");";
                    this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapaIdMun);

                    insertCamposCapaIdMun = "insert into dictionary (id_vocablo,locale, traduccion) values (nextval('seq_dictionary'),'es_ES','Longitud LocalGIS');";
                    this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapaIdMun);
                    insertCamposCapaIdMun = "insert into dictionary (id_vocablo,locale, traduccion) values (CURRVAL('seq_dictionary'),'eu_ES','Luzera LocalGIS'); ";
                    this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapaIdMun);
                    insertCamposCapaIdMun = "insert into attributes (id, id_alias, id_layer, id_column, position, editable) values (nextval('seq_attributes'),currval('seq_dictionary'),CURRVAL('seq_layers'),CURRVAL('seq_columns'),(select max(position)+1 from attributes where id_layer=currval('seq_layers')),true);";
                    this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapaIdMun);
                    break;
                case 11:  //en este caso el poligono
                    tipoDato = 2;
                    //Insertamos la superfice
                    insertCamposCapaIdMun = "ALTER TABLE " + ObjCapa.NombreCapa + " ADD COLUMN superficie_localgis  numeric(" + ObjObtDatos.LongDouble + ");";
                    this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapaIdMun);
                    insertCamposCapaIdMun = "insert into columns (id,id_table,name,\"Length\",\"Precision\",\"Scale\",\"Type\") values (nextval('seq_columns'),CURRVAL('seq_tables'),'superficie_localgis',null," + ObjObtDatos.LongDouble + "," + tipoDato + ");";
                    this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapaIdMun);
                    insertCamposCapaIdMun = "insert into dictionary (id_vocablo,locale, traduccion) values (nextval('seq_dictionary'),'es_ES','Superficie LocalGIS');";
                    this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapaIdMun);
                    insertCamposCapaIdMun = "insert into dictionary (id_vocablo,locale, traduccion) values (CURRVAL('seq_dictionary'),'eu_ES','Azalea LocalGIS'); ";
                    this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapaIdMun);
                    insertCamposCapaIdMun = "insert into attributes (id, id_alias, id_layer, id_column, position, editable) values (nextval('seq_attributes'),currval('seq_dictionary'),CURRVAL('seq_layers'),CURRVAL('seq_columns'),(select max(position)+1 from attributes where id_layer=currval('seq_layers')),true);";
                    this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapaIdMun);

                    //Insertamos el perimetro
                    insertCamposCapaIdMun = "ALTER TABLE " + ObjCapa.NombreCapa + " ADD COLUMN perimetro_localgis  numeric(" + ObjObtDatos.LongDouble + ");";
                    this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapaIdMun);
                    insertCamposCapaIdMun = "insert into columns (id,id_table,name,\"Length\",\"Precision\",\"Scale\",\"Type\") values (nextval('seq_columns'),CURRVAL('seq_tables'),'perimetro_localgis',null," + ObjObtDatos.LongDouble + "," + tipoDato + ");";
                    this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapaIdMun);
                    insertCamposCapaIdMun = "insert into dictionary (id_vocablo,locale, traduccion) values (nextval('seq_dictionary'),'es_ES','Perímetro LocalGIS');";
                    this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapaIdMun);
                    insertCamposCapaIdMun = "insert into dictionary (id_vocablo,locale, traduccion) values (CURRVAL('seq_dictionary'),'eu_ES','Perimetroa LocalGIS'); ";
                    this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapaIdMun);
                    insertCamposCapaIdMun = "insert into attributes (id, id_alias, id_layer, id_column, position, editable) values (nextval('seq_attributes'),currval('seq_dictionary'),CURRVAL('seq_layers'),CURRVAL('seq_columns'),(select max(position)+1 from attributes where id_layer=currval('seq_layers')),true);";
                    this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapaIdMun);
                    break;
            }


            //--despues de insertar todas las columnas insertamos el idmuncipio que tiene que ser el ultimo en las tablas columns y atributes
            comentario = "--despues de insertar todas las columnas insertamos el idmuncipio que tiene que ser el ultimo en las tablas columns y atributes;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);
            insertCamposCapaIdMun = "ALTER TABLE " + ObjCapa.NombreCapa + " ADD COLUMN  id_municipio  NUMERIC(5); ALTER TABLE " + ObjCapa.NombreCapa + " ALTER COLUMN id_municipio SET NOT NULL;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapaIdMun);
            insertCamposCapaIdMun = "insert into columns (id,id_table,name,\"Length\",\"Precision\",\"Scale\",\"Type\") values (nextval('seq_columns'),CURRVAL('seq_tables'),'id_municipio',null,5,0,2);";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapaIdMun);

            insertCamposCapaIdMun = "insert into columns_domains (id_domain, id_column, level) values (10068,CURRVAL('seq_columns'),0);";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapaIdMun);
            /////////
            insertCamposCapaIdMun = "insert into dictionary (id_vocablo,locale, traduccion) values (nextval('seq_dictionary'),'es_ES','ID de municipio');  ";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapaIdMun);
            insertCamposCapaIdMun = "insert into dictionary (id_vocablo,locale, traduccion) values (CURRVAL('seq_dictionary'),'eu_ES','ID de municipio');  ";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapaIdMun);

            insertCamposCapaIdMun = "insert into attributes (id, id_alias, id_layer, id_column, position, editable) values (nextval('seq_attributes'),currval('seq_dictionary'),CURRVAL('seq_layers'),CURRVAL('seq_columns'),(select max(position)+1 from attributes where id_layer=currval('seq_layers')),true);";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapaIdMun);
            ///////            

            //--CREAMOS LA SECUENCIA DE LA TABLA CUANDO HAYAMOS TEMINADO DE CREARLA
            comentario = "--CREAMOS LA SECUENCIA DE LA TABLA CUANDO HAYAMOS TEMINADO DE CREARLA	;";	 //  -- OJO al nombre de la secuencia
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);
            insertCamposCapaIdMun = " CREATE SEQUENCE \"public\".\"seq_" + ObjCapa.NombreCapa + "\" INCREMENT 1 MINVALUE 1 START 1 CACHE 1;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCamposCapaIdMun);
        }


        private void CrearInsertQueries(String rutaSalidaSql, ArrayList camposQuery, String nombreCapa, int tipoGeometria)
        {
            string insertQueries = string.Empty;
            string select = string.Empty;
            string AnadeSelect = string.Empty;
            string insert = string.Empty;
            string AnadeInsert = string.Empty;
            string AnadeInsert1 = string.Empty;
            string update = string.Empty;
            string AnadeUpdate = string.Empty;
            string delete = string.Empty;


            //Al insertar las querys hay que insertar insertar el campo longitud si es linea, y perimetro y superficie si es poligono
            //en ambos casos el dato es de tipo double
            //es tipoGeometria=7 cuando se trata de punto
            switch (tipoGeometria)
            {
                case 9:   //en este caso es linea                  
                    camposQuery.Add("longitud_localgis");
                    break;
                case 11:  //en este caso el poligono                    
                    //Insertamos la superfice
                    camposQuery.Add("superficie_localgis");
                    //Insertamos el perimetro
                    camposQuery.Add("perimetro_localgis");
                    break;
            }
            //a camposQuery, le tenemos que añadir los que añadimos por defecto, es decir el id, geometry y el ultimo id_municipio
            select = "SELECT  " + nombreCapa + ".id,  transform(" + nombreCapa + ".\"GEOMETRY\", ?T) AS \"GEOMETRY\", ";
            insert = "INSERT INTO " + nombreCapa + " (id,\"GEOMETRY\", ";
            update = "UPDATE " + nombreCapa + " SET id=?1,\"GEOMETRY\"=transform(GeometryFromText(text(?2),?S), ?T) ";
            delete = "DELETE FROM " + nombreCapa + " WHERE id =?1";

            for (int i = 0; i <= camposQuery.Count - 1; i++)
            {

                AnadeSelect = AnadeSelect + nombreCapa + "." + camposQuery[i].ToString();
                AnadeInsert = AnadeInsert + camposQuery[i].ToString();
                // AnadeUpdate = AnadeUpdate + camposQuery[i].ToString() + "=?" + (i + 3);

                if (i != camposQuery.Count - 1)
                {
                    AnadeSelect = AnadeSelect + ", ";
                    AnadeInsert = AnadeInsert + ", ";
                    AnadeUpdate = AnadeUpdate + ", ";
                }
                else if (i == camposQuery.Count - 1)
                {
                    AnadeInsert = AnadeInsert + ",id_municipio) VALUES (?PK,transform(GeometryFromText(text(?2),?S),?T), ";
                }
                if (i != camposQuery.Count - 1)
                {
                    AnadeInsert1 = AnadeInsert1 + "?" + (i + 3) + ",";
                    AnadeUpdate = AnadeUpdate + camposQuery[i].ToString() + "=?" + (i + 3);
                }
                else if (i == camposQuery.Count - 1)
                {
                    switch (tipoGeometria)
                    {
                        case 7:
                            AnadeInsert1 = AnadeInsert1 + "?" + (i + 3) + ",?M)";
                            break;
                        case 9:   //en este caso es linea                  

                            AnadeInsert1 = AnadeInsert1 + " round(length2d(GeometryFromText(?2,?S))::numeric,2),?M)";
                            AnadeUpdate = AnadeUpdate + ", longitud_localgis = round(length2d(GeometryFromText(?2,?S))::numeric,2) ";
                            break;

                        case 11:   //en este caso es POLIGONO                  
                            //Primero hemos insertado la superficie y despues el perimetro      


                            AnadeInsert1 = AnadeInsert1.Substring(0, AnadeInsert1.LastIndexOf("?", StringComparison.Ordinal));
                            AnadeInsert1 = AnadeInsert1 + " round(area2d(GeometryFromText(?2,?S))::numeric,2), round(perimeter(GeometryFromText(?2,?S))::numeric,2) ,?M)";
                            AnadeUpdate = AnadeUpdate + ", superficie_localgis = round(area2d(GeometryFromText(?2,?S))::numeric,2), perimetro_localgis = round(perimeter(GeometryFromText(?2,?S))::numeric,2) ";
                            break;

                    }
                }
            }


            select = select + AnadeSelect + " FROM " + nombreCapa + " WHERE " + nombreCapa + ".id_municipio IN (?M)";
            insert = insert + AnadeInsert + AnadeInsert1;
            update = update + AnadeUpdate + " ,id_municipio = ?M  WHERE id=?1";

            insertQueries = "INSERT INTO queries( id, id_layer, databasetype, selectquery, updatequery, insertquery, deletequery) " +
                            " VALUES (NEXTVAL('seq_querys'),CURRVAL('seq_layers'),1,'" + select + "', '" + update + "', '" + insert + "', '" + delete + "');";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertQueries);


        }
        private void CrearInsertDomainCategory(string rutaSalidaSql)
        {
            string insertCampos = string.Empty;
            string comentario = string.Empty;
            //leer fichero configuracion
            //- Para el primer dominio, solo para el primero que insertamos insertamos tambien en domaincategory, leyendolo del fichero de configuracion.
            comentario = "-- Para el primer dominio, insertamos también en domaincategory, leyendolo del fichero de configuracion;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);

            insertCampos = " INSERT INTO dictionary(id_vocablo,locale,traduccion) values(nextval('seq_dictionary'),'es_ES','" + ObjObtDatos.NombreDominioES + "');";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCampos);
            insertCampos = " INSERT INTO dictionary (id_vocablo,locale, traduccion) values (currval('seq_dictionary'),'eu_ES','" + ObjObtDatos.NombreDominioEU + "');";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCampos);
            insertCampos = " INSERT INTO domaincategory (id, id_description) VALUES (nextval('seq_domaincategory'), currval('seq_dictionary'));";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertCampos);
        }

        private void CrearInsertDomain(string rutaSalidaSql, CampoCapa ObjCampoCapa, Dominio ObjDominio, string NombreCapa)
        {
            string insertDomain = string.Empty;
            string comentario = string.Empty;

            string adjuntaNom = string.Empty;
            if (AdjuntarNombreCapa.Equals("SI", StringComparison.OrdinalIgnoreCase))
            {
                adjuntaNom = "_" + NombreCapa;
            }
            else
            {
                adjuntaNom = "";
            }


            //leer fichero configuracion
            //-- para insertar los dominios cogemos el ultimo domaincategory insertado, este solo se insertara una vez
            comentario = "-- para insertar los dominios cogemos el ultimo domaincategory insertado, este solo se insertara una vez;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);


            insertDomain = "insert into Domains (ID, NAME,ID_CATEGORY) values (nextval('seq_domains'),'" + TruncarLongitudDato(ObjDominio.NombreDominio + adjuntaNom, 100) + "', currval('seq_domaincategory'));";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertDomain);
            comentario = "-- relacionamos la columna y el dominio;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);
            insertDomain = "insert into columns_domains (id_domain, id_column, level) values (CURRVAL('seq_domains'), CURRVAL('seq_columns'),0); ";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertDomain);
            comentario = "		--inicio damos de alta los domainNodes;";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, comentario);
            insertDomain = "		insert into dictionary(id_vocablo,locale,traduccion) values(nextval('seq_dictionary'),'es_ES','" + TruncarLongitudDato(ObjCampoCapa.NombreES, 255) + "');	";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertDomain);
            insertDomain = "		insert into dictionary(id_vocablo,locale,traduccion) values(currval('seq_dictionary'),'eu_ES','" + TruncarLongitudDato(ObjCampoCapa.NombreEU, 255) + "');";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertDomain);


            insertDomain = "		insert into domainnodes(id,id_domain,pattern,id_description,type, permissionlevel, parentdomain, id_municipio) ";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertDomain);
            insertDomain = "				values(nextval('seq_domainnodes'),currval('seq_domains'),null,currval('seq_dictionary'),4,1,null,null);";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertDomain);

        }

        private void CrearInsertValoresDominio(string rutaSalidaSql, ValoresDominio ObjValoresDominio)
        {
            string insertDomain = string.Empty;

            //leer fichero configuracion
            //-- para insertar los dominios cogemos el ultimo domaincategory insertado, este solo se insertara una vez

            insertDomain = "			insert into dictionary(id_vocablo,locale,traduccion) values(nextval('seq_dictionary'),'es_ES','" + ObjValoresDominio.NombreValorDominioES + "');	";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertDomain);
            insertDomain = "			insert into dictionary(id_vocablo,locale,traduccion) values(currval('seq_dictionary'),'eu_ES','" + ObjValoresDominio.NombreValorDominioEU + "');  ";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertDomain);



            insertDomain = "            insert into domainnodes(id,id_domain,pattern,id_description,type, permissionlevel, parentdomain, id_municipio)  ";
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertDomain);
            insertDomain = "				values(nextval('seq_domainnodes'),currval('seq_domains'),'" + ObjValoresDominio.Valor + "',currval('seq_dictionary'),7,null,(SELECT id FROM domainnodes  where id_domain =currval('seq_domains') and \"type\"=4),null); ";// -- el '1' será el valor del combo
            this.ObjFichTexto.EscribirTexto(rutaSalidaSql, NombreFicheroSqlSalida, insertDomain);

        }


        static void ValidationCallback(object sender, ValidationEventArgs args)
        {

        }



    }
}
