private byte[] GerarZipBaseRef()
        {
            string[] featureNameList;
            string[] featureTypeList;
            string[] featureAliasList;
            int      sridBase = 0;

            string connectionKey;

            Hashtable config = business.ObterConfiguracoesBaseRef();

            if (Project.Type == OPERACAO_BASEREF_GEOBASES)
            {
                featureNameList  = config["GEOBASES_FEATURE_NAMES"].ToString().Split(',');
                featureTypeList  = config["GEOBASES_FEATURE_TYPES"].ToString().Split(',');
                featureAliasList = config["GEOBASES_FEATURE_ALIASES"].ToString().Split(',');

                connectionKey = config["GEOBASES_CONNECTION_KEY"].ToString();

                sridBase = 31999;
            }
            else if (Project.Type == OPERACAO_BASEREF_INTERNA)
            {
                featureNameList  = config["INTERNO_FEATURE_NAMES"].ToString().Split(',');
                featureTypeList  = config["INTERNO_FEATURE_TYPES"].ToString().Split(',');
                featureAliasList = config["INTERNO_FEATURE_ALIASES"].ToString().Split(',');

                connectionKey = config["INTERNO_CONNECTION_KEY"].ToString();

                sridBase = Convert.ToInt32(config["SRID_BASE"]);
            }
            else
            {
                throw new Exception("Operacao Inválida ao gerar Base de Referência");
            }

            List <int> pnts_envelope = business.ObterEnvelope(Project.Id);

            if (pnts_envelope.Count != 4)
            {
                throw new Exception("Envelope da Caracterização " + Project.Id + " inválido");
            }

            FonteFeicaoOracleSpatial origem  = GetDatabaseFontFeicao(connectionKey);
            FonteFeicaoShapeStream   destino = new FonteFeicaoShapeStream();

            origem.Abrir();
            destino.Abrir();

            LeitorFeicao leitor       = null;
            ClasseFeicao classeFeicao = null;

            Expressao envelope = new Campo(String.Format("mdsys.sdo_geometry(2003,{0},null,sdo_elem_info_array(1,1003,3), sdo_ordinate_array({1},{2},{3},{4}))",
                                                         sridBase,
                                                         pnts_envelope[0],
                                                         pnts_envelope[1],
                                                         pnts_envelope[2],
                                                         pnts_envelope[3]));

            OperacaoEspacial operacao;
            Expressao        filtro;

            List <OperadorFeicaoShape> lstEscritores = new List <OperadorFeicaoShape>();
            List <string> srtNames = new List <string>();

            for (int i = 0; i < featureNameList.Length; i++)
            {
                string        alias    = featureAliasList[i];
                string        feicao   = featureNameList[i];
                TipoGeometria eTipoGeo = (TipoGeometria)Enum.Parse(typeof(TipoGeometria), featureTypeList[i], true);

                try
                {
                    classeFeicao = origem.ObterClasseFeicao(feicao);
                }
                catch
                {
                    classeFeicao = null;
                }

                if (classeFeicao == null)
                {
                    continue;
                }

                string campoGeo = classeFeicao.CampoGeometrico;
                operacao = new OperacaoEspacialInterseccao(new Campo(campoGeo), envelope);
                operacao = new OperacaoEspacialExtracao(operacao, eTipoGeo);
                operacao = new OperacaoEspacialDensificacao(operacao);

                filtro = new ExpressaoRelacionalOracleSpatial(new OperacaoEspacialRelacao(new Campo(campoGeo), envelope, TipoRelacaoEspacial.ANYINTERACT), TipoOperadorRelacional.Igual, new ConstanteOracleSpatial(DbType.String, "TRUE"));

                try
                {
                    leitor = origem.ObterLeitorFeicao(feicao, operacao, filtro);

                    OperadorFeicaoShape escritor = null;

                    while (leitor.Ler())
                    {
                        if (leitor.Atual.Geometria == null)
                        {
                            continue;
                        }

                        if (escritor == null)
                        {
                            escritor = (OperadorFeicaoShape)destino.CriarClasseFeicao(alias, eTipoGeo, leitor.Atual.Geometria.Dimensoes, leitor.Atual.Geometria.EhLrs, leitor.Atributos);

                            lstEscritores.Add(escritor);
                            srtNames.Add(alias);
                        }

                        escritor.Inserir(leitor.Atual);
                    }

                    leitor.Fechar();
                }
                catch (Exception exc)
                {
                    throw new Exception(String.Format("Feicao {0}", feicao), exc);
                }
            }

            byte[] byteReturn = null;

            if (lstEscritores.Count > 0)
            {
                using (MemoryStream ms = new MemoryStream())
                {
                    destino.ExportarParaZip(ms);
                    byteReturn = AdicionarArquivosPrj(ms, srtNames.ToArray());
                }

                foreach (OperadorFeicaoShape escritorShp in lstEscritores)
                {
                    escritorShp.Fechar();
                }
            }

            origem.Fechar();
            destino.Fechar();

            if (byteReturn == null)
            {
                string message = "Nenhuma Geometria nas Feições a seguir cruza com a Área de Abrangencia selecionada:";
                foreach (string featureName in featureAliasList)
                {
                    message += "\r\n   - " + featureName;
                }

                byteReturn = GerarZipComMensagem("Nenhuma Geometria Encontrada", message);
            }

            return(byteReturn);
        }
        private List <byte[]> GerarZipProcessado()
        {
            List <string> prjList = new List <string>();

            string[] featureList = null;
            string[] aliasList   = null;

            switch (Project.Type)
            {
            case OPERACAO_DOMINIALIDADE:
                featureList = "TMP_ATP,TMP_APMP,TMP_AFD,TMP_ROCHA,TMP_VERTICE,TMP_ARL,TMP_RPPN,TMP_AFS,TMP_AVN,TMP_AA,TMP_ACONSTRUIDA,TMP_DUTO,TMP_LTRANSMISSAO,TMP_ESTRADA,TMP_FERROVIA,TMP_NASCENTE,TMP_RIO_LINHA,TMP_RIO_AREA,TMP_LAGOA,TMP_REPRESA,TMP_DUNA,TMP_REST_DECLIVIDADE,TMP_ESCARPA,TMP_AREAS_CALCULADAS".Split(',');
                aliasList   = "ATP,APMP,AFD,ROCHA,VERTICE,ARL,RPPN,AFS,AVN,AA,ACONSTRUIDA,DUTO,LTRANSMISSAO,ESTRADA,FERROVIA,NASCENTE,RIO_LINHA,RIO_AREA,LAGOA,REPRESA,DUNA,REST_DECLIVIDADE,ESCARPA,AREAS_CALCULADAS".Split(',');
                break;

            case OPERACAO_ATIVIDADE:
                featureList = "TMP_PATIV,TMP_LATIV,TMP_AATIV,TMP_AIATIV".Split(',');
                aliasList   = "PATIV,LATIV,AATIV,AIATIV".Split(',');
                break;
            }

            FonteFeicaoOracleSpatial origem            = GetDatabaseFontFeicao();
            FonteFeicaoShapeStream   destino           = new FonteFeicaoShapeStream();
            FonteFeicaoShapeStream   destinoTrackmaker = new FonteFeicaoShapeStream();

            origem.Abrir();
            destino.Abrir();
            destinoTrackmaker.Abrir();

            LeitorFeicao leitor       = null;
            ClasseFeicao classeFeicao = null;

            List <OperadorFeicaoShape> lstEscritores           = new List <OperadorFeicaoShape>();
            List <OperadorFeicaoShape> lstEscritoresTrackmaker = new List <OperadorFeicaoShape>();

            int count = featureList.Length;

            for (int i = 0; i < count; i++)
            {
                string feicao = featureList[i];
                string alias  = aliasList[i];

                classeFeicao = origem.ObterClasseFeicao(feicao);
                if (classeFeicao == null)
                {
                    continue;
                }

                OperadorFeicaoShape escritor  = null;
                AtributoCollection  atributos = null;

                OperadorFeicaoShape escritorTrackmaker  = null;
                AtributoCollection  atributosTrackmaker = null;

                Expressao filtro = null;
                Atributo  atributo;
                Feicao    data;

                if (feicao == "TMP_AREAS_CALCULADAS")
                {
                    string[] tipos = "APP_APMP,APP_AA_USO,APP_AA_REC,APP_AVN,APP_ARL".Split(',');

                    foreach (string tipoArea in tipos)
                    {
                        ExpressaoRelacionalOracleSpatial termo1 = new ExpressaoRelacionalOracleSpatial(new Campo("PROJETO"), TipoOperadorRelacional.Igual, new ParametroOracleSpatial(DbType.Int32, Project.Id));
                        ExpressaoRelacionalOracleSpatial termo2 = new ExpressaoRelacionalOracleSpatial(new Campo("TIPO"), TipoOperadorRelacional.Igual, new ParametroOracleSpatial(DbType.String, tipoArea, 50));
                        filtro = new ExpressaoLogicaOracleSpatial(termo1, TipoOperadorLogico.E, termo2);

                        try
                        {
                            leitor = origem.ObterLeitorFeicao(feicao, null, filtro);
                        }
                        catch (Exception exc)
                        {
                            for (int k = 0; k < 5; k++)
                            {
                                try
                                {
                                    ExpressaoRelacionalOracleSpatial termoAux = new ExpressaoRelacionalOracleSpatial(new Campo("1"), TipoOperadorRelacional.Igual, new Campo("1"));
                                    filtro = new ExpressaoLogicaOracleSpatial(filtro, TipoOperadorLogico.E, termoAux);
                                    leitor = origem.ObterLeitorFeicao(feicao, null, filtro);
                                }
                                catch (Exception)
                                {
                                    if (k < 4)
                                    {
                                        continue;
                                    }

                                    throw new Exception(string.Format("Feicao: {0} / Project.Id: {1} / tipo {2} / where: {3}", feicao, Project.Id, tipoArea, filtro.GerarComando()), exc);
                                }

                                break;
                            }
                        }

                        escritor = null;

                        while (leitor.Ler())
                        {
                            if (escritor == null)
                            {
                                atributos = new AtributoCollection();
                                atributos.Adicionar(classeFeicao.Atributos["AREA_M2"]);

                                escritor = (OperadorFeicaoShape)destino.CriarClasseFeicao(tipoArea, leitor.Atual.Geometria.ObterTipo(), 2, false, atributos);
                                prjList.Add(tipoArea);

                                lstEscritores.Add(escritor);


                                //Trackmaker
                                atributo         = new Atributo();
                                atributo.Nome    = "NOME";
                                atributo.Tamanho = 200;
                                atributo.Tipo    = DbType.String;

                                atributosTrackmaker = new AtributoCollection();
                                atributosTrackmaker.Adicionar(atributo);
                                escritorTrackmaker = (OperadorFeicaoShape)destinoTrackmaker.CriarClasseFeicao(tipoArea, leitor.Atual.Geometria.ObterTipo(), 2, false, atributosTrackmaker);

                                lstEscritoresTrackmaker.Add(escritorTrackmaker);
                            }

                            //Normal information
                            data           = new Feicao();
                            data.ID        = leitor.Atual.ID;
                            data.Geometria = leitor.Atual.Geometria;

                            data.Atributos = new AtributoCollection();
                            foreach (Atributo attr in atributos)
                            {
                                atributo       = attr.Clonar();
                                atributo.Valor = leitor.Atual.Atributos[atributo.Nome].Valor;
                                data.Atributos.Adicionar(atributo);
                            }

                            escritor.Inserir(data);


                            //Trackmaker information
                            data           = new Feicao();
                            data.ID        = leitor.Atual.ID;
                            data.Geometria = leitor.Atual.Geometria;

                            data.Atributos = new AtributoCollection();
                            atributo       = atributosTrackmaker[0].Clonar();
                            atributo.Valor = GenerateTrackMakerNameValue("TMP_" + tipoArea, leitor.Atual.Atributos);
                            data.Atributos.Adicionar(atributo);

                            escritorTrackmaker.Inserir(data);
                        }
                    }
                }
                else
                {
                    filtro = new ExpressaoRelacionalOracleSpatial(new Campo("PROJETO"), TipoOperadorRelacional.Igual, new ParametroOracleSpatial(DbType.Int32, Project.Id));

                    try
                    {
                        leitor = origem.ObterLeitorFeicao(feicao, null, filtro);
                    }
                    catch (Exception)
                    {
                        for (int k = 0; k < 5; k++)
                        {
                            try
                            {
                                ExpressaoRelacionalOracleSpatial termoAux = new ExpressaoRelacionalOracleSpatial(new Campo("1"), TipoOperadorRelacional.Igual, new Campo("1"));
                                filtro = new ExpressaoLogicaOracleSpatial(filtro, TipoOperadorLogico.E, termoAux);
                                leitor = origem.ObterLeitorFeicao(feicao, null, filtro);
                            }
                            catch (Exception)
                            {
                                if (k < 4)
                                {
                                    continue;
                                }

                                throw;
                            }

                            break;
                        }
                    }

                    while (leitor.Ler())
                    {
                        if (escritor == null)
                        {
                            atributos = new AtributoCollection();

                            atributos.Adicionar(classeFeicao.Atributos["ID"]);

                            if (classeFeicao.Atributos.IndiceDe("LARGURA") >= 0)
                            {
                                atributos.Adicionar(classeFeicao.Atributos["LARGURA"]);
                            }

                            if (classeFeicao.Atributos.IndiceDe("NOME") >= 0)
                            {
                                atributos.Adicionar(classeFeicao.Atributos["NOME"]);
                            }

                            if (classeFeicao.Atributos.IndiceDe("AMORTECIMENTO") >= 0)
                            {
                                atributos.Adicionar(classeFeicao.Atributos["AMORTECIMENTO"]);
                            }

                            if (classeFeicao.Atributos.IndiceDe("COD_APMP") >= 0)
                            {
                                atributos.Adicionar(classeFeicao.Atributos["COD_APMP"]);
                            }

                            if (classeFeicao.Atributos.IndiceDe("COMPENSADA") >= 0)
                            {
                                atributos.Adicionar(classeFeicao.Atributos["COMPENSADA"]);
                            }

                            if (classeFeicao.Atributos.IndiceDe("ESTAGIO") >= 0)
                            {
                                atributos.Adicionar(classeFeicao.Atributos["ESTAGIO"]);
                            }

                            if (classeFeicao.Atributos.IndiceDe("PROJETO") >= 0)
                            {
                                atributos.Adicionar(classeFeicao.Atributos["PROJETO"]);
                            }

                            if (classeFeicao.Atributos.IndiceDe("SITUACAO") >= 0)
                            {
                                atributos.Adicionar(classeFeicao.Atributos["SITUACAO"]);
                            }

                            if (classeFeicao.Atributos.IndiceDe("TIPO") >= 0)
                            {
                                atributos.Adicionar(classeFeicao.Atributos["TIPO"]);
                            }

                            if (classeFeicao.Atributos.IndiceDe("ZONA") >= 0)
                            {
                                atributos.Adicionar(classeFeicao.Atributos["ZONA"]);
                            }

                            if (classeFeicao.Atributos.IndiceDe("AREA_M2") >= 0)
                            {
                                atributos.Adicionar(classeFeicao.Atributos["AREA_M2"]);
                            }

                            if (classeFeicao.Atributos.IndiceDe("CODIGO") >= 0)
                            {
                                atributos.Adicionar(classeFeicao.Atributos["CODIGO"]);
                            }

                            if (classeFeicao.Atributos.IndiceDe("VEGETACAO") >= 0)
                            {
                                atributos.Adicionar(classeFeicao.Atributos["VEGETACAO"]);
                            }

                            escritor = (OperadorFeicaoShape)destino.CriarClasseFeicao(alias, leitor.Atual.Geometria.ObterTipo(), 2, false, atributos);
                            prjList.Add(alias);

                            lstEscritores.Add(escritor);

                            //Trackmaker
                            atributo         = new Atributo();
                            atributo.Nome    = "NOME";
                            atributo.Tamanho = 200;
                            atributo.Tipo    = DbType.String;

                            atributosTrackmaker = new AtributoCollection();
                            atributosTrackmaker.Adicionar(atributo);
                            escritorTrackmaker = (OperadorFeicaoShape)destinoTrackmaker.CriarClasseFeicao(alias, leitor.Atual.Geometria.ObterTipo(), 2, false, atributosTrackmaker);

                            lstEscritoresTrackmaker.Add(escritorTrackmaker);
                        }

                        //Normal information
                        data           = new Feicao();
                        data.ID        = leitor.Atual.ID;
                        data.Geometria = leitor.Atual.Geometria;

                        data.Atributos = new AtributoCollection();
                        foreach (Atributo attr in atributos)
                        {
                            atributo       = attr.Clonar();
                            atributo.Valor = leitor.Atual.Atributos[atributo.Nome].Valor;
                            data.Atributos.Adicionar(atributo);
                        }

                        escritor.Inserir(data);

                        //Trackmaker information
                        data           = new Feicao();
                        data.ID        = leitor.Atual.ID;
                        data.Geometria = leitor.Atual.Geometria;

                        data.Atributos = new AtributoCollection();
                        atributo       = atributosTrackmaker[0].Clonar();
                        atributo.Valor = GenerateTrackMakerNameValue(feicao, leitor.Atual.Atributos);
                        data.Atributos.Adicionar(atributo);

                        escritorTrackmaker.Inserir(data);
                    }
                }

                leitor.Fechar();
            }

            byte[] byteReturn           = null;
            byte[] byteTrackmakerReturn = null;

            if (lstEscritores.Count > 0)
            {
                using (MemoryStream ms = new MemoryStream())
                {
                    destino.ExportarParaZip(ms);
                    byteReturn = AdicionarArquivosPrj(ms, prjList.ToArray());
                }

                using (MemoryStream ms = new MemoryStream())
                {
                    destinoTrackmaker.ExportarParaZip(ms);
                    byteTrackmakerReturn = AdicionarArquivosPrj(ms, prjList.ToArray());
                }

                foreach (OperadorFeicaoShape escritorShp in lstEscritores)
                {
                    escritorShp.Fechar();
                }

                foreach (OperadorFeicaoShape escritorShp in lstEscritoresTrackmaker)
                {
                    escritorShp.Fechar();
                }
            }

            origem.Fechar();
            destino.Fechar();
            destinoTrackmaker.Fechar();

            List <byte[]> result = new List <byte[]>();

            result.Add(byteReturn);
            result.Add(byteTrackmakerReturn);

            return(result);
        }