E acho que não sou só eu que devo ser lembrado disto, pois há até um site cujo propósito é lembrar isto (bom,  existe site para tudo, mas enfim…).

Como não poderia deixar de ser nesta área, existem alguns acrônimos e lemas que te auxiliam nesta tarefa tão importante, que é entregar um software de valor e respeito no prazo. KISS, YAGNI e DRY. Comecemos pelo mais simpático:

KISS – Keep It Simple, Stupid

Mantenha simples. A simplicidade facilita o entendimento. O que é simples é fácil de usar, de manipular. É fácil de explicar. Mas isto não quer dizer que a simplicidade como objetivo é algo simples. Complexo?

A simplicidade, a elegância são características que necessitam de experiência, de criatividade para serem alcançadas. Usando um  exemplo já surrado , o iPhone. Simples. Elegante. Lembra-se dos smartphones antes dele? Pois então. E o que fazer? Estudar, compreender, testar e inventar. E depois ver se sua mãe compreendeu seu invento.

YAGNI – You Ain’t Gonna Need It

Não implemente nada, a não ser que seja necessário para seu produto. Não produza o que não será usado. Senão será mais trabalho no momento de criar e no momento de dar manutenção.

Entra a questão: e o que realmente é necessário? Pergunta difícil. Se perguntar ao cliente o que é necessário, você terá de criar o Facebook.  A resposta requer experiência e análise fundamentada do problema em questão. Entra novamente um pouco de senso estético. Elegância. Descreva as features. Elimine todas quanto possível.  Tire qualquer uma em que restem dúvidas.  Depois de criar este conjunto mínimo, escolha uma feature para jogar fora. Aí, talvez, sobre uma lista contendo apenas o que é necessário.

Mas sejamos pragmáticos também. A aplicação de YAGNI deve levar em conta também o custo de implementação. Se é barato fazer agora e barato depois, deixe para depois. Se é barato agora, mas ficará caríssimo depois, faça agora. Este conhecimento, de novo, requer prática e experiência.

DRY – Don’t Repeat Yourself

Uma regra, uma especificidade (repita em voz alta, comendo paçoca Amor), um pedaço do conhecimento deve estar declarada, escrita, de forma clara, em um único ponto do sistema.

Pode ser fácil. Ou bem difícil. Depende do tamanho. Do tamanho do produto e da equipe.  É muito comum equipes grandes de desenvolvimento escreverem diversas soluções para o mesmo problema, sem um ter conhecimento da solução do outro.

Já ouvi que isso ocorre em alguns lugares entre equipes de departamentos distintos, que são muito “ciosos” de seu código…

O fato é que é preciso que o sistema seja claro o suficiente e que os desenvolvedores se comuniquem de maneira eficiente para a aplicação do DRY. Como fazer isso? Seria uma boa perguntar ao Fred Brooks.

Disk-sistema entregas rápidas

E o que isto tudo significa? Significa a prática da Programação Zen. O melhor código é o não-código. Executar isso difícil. Requer perseverança e auto-controle. Exerçamos a melhor qualidade de um programador. Mantenha o sistema limpo, enxuto, conciso. Não crie, não produza a mais. Menos features, menos código, menos trabalho, menos tempo gasto. Talvez até dê para cumprir aquele prazo….

O NHibernate é um grande auxílio para quem deseja implementar um sistema usando DDD (não, não é quando você liga para o programador que mora longe. É Domain Driven Design).

Me deixa dormir!

Quem já usou o Hibernate sabe que configurá-lo pode ser a porta de entrada para o primeiro dos nove círculos do inferno. Bom, não passei por isto, pois nunca havia usado diretamente o Hibernate. Se existe algo bom em chegar na festa por último no mundo do desenvolvimento, é de ter mais coisas prontas e mastigadinhas. Entra então o Fluent NHibernate.

Historinha para bovinos hibernarem

Primeiro o contexto. Enfrento um código legado (código legado == código sem testes, segundo Feathers) que usa o framework Castle ActiveRecord (Castle AR). Embora este framework facilite bastante a vida, poupando o pobre programador da tarefa de escrever muito código CRUD, ganhando uma tendinite, ele não se dá muito bem com o DDD, tornando mais trabalhoso que o necessário a separação das Entidades do sistema de persistência.

Outro problema é que, apesar do Castle AR fornecer uma camada de abstração sobre o Hibernate, é necessário que você saiba como o Hibernate funciona. Decidi então me livrar do Castle AR e usar apenas o Hibernate. E como não quero editar os arquivos XML do Hibernate eu mesmo (o Castle AR fazia este trabalho) decidi usar o Fluent NHibernate.

Programação, sistemas e zumbis

O Fluent NHibernate segue uma sintaxe fluente para realizar toda a configuração do Hibernate usando a própria linguagem de programação. No meu caso, C#.

Primeiro um esquema altamente complexo do sistema que servirá de exemplo:

Chamem o Chris Redfield!

Um RaccoonCity City possui inúmeros Zombies. O City tem uma data, Month, com mês e ano, de quando se iniciou a infecção de sua população. Zombie possui uma data, Month, de quando ele mesmo foi infectado. Por enquanto não podemos estimar estas datas com precisão de dias, por isso queremos apenas mês e ano.

O diagrama acima gerou as seguintes classes:

• City é uma Entidade. E é uma Raíz de Agregado, ou Aggregate Root;
• Zombie é um Objeto Valor, ou Value Object. Quer dizer que todos os zumbis são iguais, desde que tenham as mesmas propriedades: FormerName e Infected. Deixei um Id mesmo assim;
• Month também é um Objeto Valor. Ele determina um mês e ano. Não estou interessado no dia.

Uma preocupação na modelagem foi quanto à lista Zombies. Para se adicionar um Zombie em um City é preciso usar o método AddZombie(). Assim tenho um lugar onde posso checar e validar o Zombie antes da adição.

Mas se eu exponho Zombies como um List<Zombie> nada impede o programador de fazer isso:

City raccoon = new City("Raccoon City", new Month(2010, 4));
raccoon.Zombies.Add(new Zombie("Zé Ninguém", new Month(2010, 7)));

ao invés de:

City raccoon = new City("Raccoon City", new Month(2010, 4));
raccoon.AddZombie(new Zombie("Zé Ninguém", new Month(2010, 7)));

Para resolver este problema eu guardo a lista como um List<Zombie> e exponho apenas um IEnumerable<Zombie>:

    public class City
    {
        public virtual int Id { get; private set; }

        public virtual string Name { get; private set; }

        public virtual Month InfectionStart { get; private set; }

        private readonly IList<Zombie> _zombies = new List<Zombie>();

        public virtual IEnumerable<Zombie> Zombies
        {
            get { return _zombies; }
        }

        protected City()
        {}

        public City(string name, Month startMonth)
        {
            Name = name;
            InfectionStart = startMonth;
        }

        public virtual void AddZombie(Zombie z)
        {
            _zombies.Add(z);
        }

    }

O IEnumerable apenas expõe método de consulta. Exatamente o que eu queria.

Vamos agora implementar a classe Zombie. Esta acaba sendo mais complicada, pois se trata de um VO (Value Object). É necessário realizar um override nos métodos Equals() e GetHashCode() para que o sistema possa comprar dois zumbis com as mesmas propriedades, mesmo que de instâncias diferentes, e devolver um resultado útil. E já podemos aproveitar para fazer override nos operadores == e !=, para que devolvam o mesmo resultado que o Equals():

    public class Zombie
    {
        public virtual int Id { get; private set;}
        public virtual string FormerName { get; set; }
        public virtual Month Infected { get; set; }

        public static bool operator ==(Zombie b1, Zombie b2)
        {
            return b1.FormerName == b2.FormerName && b1.Infected == b2.Infected;
        }

        public static bool operator !=(Zombie b1, Zombie b2)
        {
            return b1.FormerName != b2.FormerName || b1.Infected != b2.Infected;
        }

        public static bool operator >(Zombie b1, Zombie b2)
        {
            return b1.Infected > b2.Infected;
        }

        public static bool operator <(Zombie b1, Zombie b2)
        {
            return b1.Infected < b2.Infected;
        }

        public static bool operator >=(Zombie b1, Zombie b2)
        {
            return b1.Infected >= b2.Infected;
        }

        public static bool operator <=(Zombie b1, Zombie b2)
        {
            return b1.Infected <= b2.Infected;
        }

        public override bool Equals(object obj)
        {
            if (!(obj is Zombie))
                return false;

            return this == (Zombie)obj;
        }

        public override int GetHashCode()
        {
            return FormerName.GetHashCode() ^ Infected.GetHashCode();
        }
    }

Até aproveitei para implementar os operadores < e >, que dependem da data de infecção do safado.

E só resta a classe Month:

    public class Month: IComparable
    {
        private int Dia { get { return 1; } }
        public int Mes { get; private set; }
        public int Ano { get; private set; }

        protected Month()
        {}

        public Month(int ano, int mes)
        {
            if (!AnoValido(ano))
                throw new ArgumentOutOfRangeException(String.Format("Ano não cabível. Ano apresentado: {0}", ano));

             if (!MesValido(mes))
                throw new ArgumentOutOfRangeException(String.Format("Mês não cabível. Mês apresentado: {0}", mes));

            Ano = ano;
            Mes = mes;
        }

        private bool AnoValido(int ano)
        {
            // Valores válidos para o SQL Server.
            // Observe que dado o escopo do problema não faz sentido nada fora deste intevalo mesmo.
            if (1753 <= ano && ano <= 9999)
                return true;

            return false;
        }

        private bool MesValido(int mes)
        {
            if (1 <= mes && mes <= 12)
                return true;

            return false;
        }

        public DateTime AsDateTime()
        {
            return new DateTime(Ano, Mes, Dia);
        }

        public override string ToString()
        {
            return AsDateTime().ToString();
        }

        public static bool operator ==(Month d1, Month d2)
        {
            return d1.Ano == d2.Ano && d1.Mes == d2.Mes;
        }

        public static bool operator !=(Month d1, Month d2)
        {
            return d1.Ano != d2.Ano || d1.Mes != d2.Mes;
        }

        public static bool operator <=(Month d1, Month d2)
        {
            if (d1 == d2)
                return true;

            if (d1.Ano < d2.Ano)
                return true;

            if (d1.Ano > d2.Ano)
                return false;

            if (d1.Mes < d2.Mes)
                return true;

            return false;
        }

        public static bool operator >=(Month d1, Month d2)
        {
            if (d1 == d2)
                return true;

            if (d1.Ano > d2.Ano)
                return true;

            if (d1.Ano < d2.Ano)
                return false;

            if (d1.Mes > d2.Mes)
                return true;

            return false;
        }

        public static bool operator <(Month d1, Month d2)
        {
            if (d1 == d2)
                return false;

            if (d1.Ano < d2.Ano)
                return true;

            if (d1.Ano > d2.Ano)
                return false;

            if (d1.Mes < d2.Mes)
                return true;

            return false;
        }

        public static bool operator >(Month d1, Month d2)
        {
            if (d1 == d2)
                return false;

            if (d1.Ano > d2.Ano)
                return true;

            if (d1.Ano < d2.Ano)
                return false;

            if (d1.Mes > d2.Mes)
                return true;

            return false;
        }

        public override bool Equals(object obj)
        {
            if (!(obj is Month))
                return false;

            return this == (Month) obj;
        }

        public override int GetHashCode()
        {
            return Ano.GetHashCode() ^ Mes.GetHashCode();
        }

        public int CompareTo(object obj)
        {
            Month d = (Month)obj;

            if (this < d)
                return -1;
            else if (this > d)
                return 1;

            return 0;

        }
    }

Mesma história dos Zumbis: implementei Equals(), e GetHashCode() e os operadores. Asism posso escrever código do tipo:

Data d1 = new Data(2000, 1);
Data d2 = new Data(2000, 1);
if (d1 == d2)
    doSomething();
else if (d1 > d2)
    doSomethingElse();
else if (d1 < d2)
    doEtc();

Com as classes do modelo implementadas, posso adicionar validações, testes e tudo mais, sem me preocupar com a camada de persistência, tornando a criação de testes unitários um trabalho bem simples. Mas este post não é sobre DDD.

Persistência != Teimosia

Vamos mapear nossas estimadas classes, usando o Fluent NHibernate, para que possam ir para o banco de dados. Comecemos com a classe Zombie, mapeada pela classe ZombieMap:

public class ZombieMap: ClassMap<Zombie>
{
    public ZombieMap()
    {
        Id(x => x.Id);
        Map(x => x.FormerName);
        Map(x => x.Infected);
    }
}

Bem simples, não? Isto nos informa que a classe Zombie será mapeada para uma tabela Zombie, com campos FormerName (com tipo nvarchar(255)) e Infected (com tipo … hmmm, calma aí, veremos adiante).

Vamos ver a classe City:

public class CityMap: ClassMap<City>
{
    public  CityMap()
    {
        Id(x => x.Id);
        Map(x => x.Name);
        Map(x => x.InfectionStart);
        HasMany<Zombie>(x => x.Zombies)
            .Access.CamelCaseField(Prefix.Underscore)
            .Cascade.AllDeleteOrphan()
            .AsBag();
    }
}

Também bem simples. A diferença aqui fica por conta do HasMany<Zombie>, cujo significado é bem simples, um City possui muitos Zombies.

Algo não tão óbvio é o Access.CamelCaseField(Prefix.Underscore). Isto diz que a propriedade Zombies possui um campo que serve de suporte, com nome escrito no estilo camelCase (diferente de PascalCase) e iniciado por um underscore. Se trata do campo _zombies, que é Zombies escrito em camelCase e iniciado por underscore.

Cascade.AllDeleteOrphans() informa ao NHibernate para apagar os Zombies órfãos, quer dizer, que não possuem um City.

AsBag() é mais complicado. Primeiro é preciso entender que o NHibernate lida com vários tipos de coleções: Set, Bag, Map e List. Cada uma com características próprias. No caso optei por bag, mas poderia ter usado list (que é um bag indexado).

Bom, resta agora a classe Month. Decidi não guardar o month em uma tabela própria. Ela nada mais é que uma data, onde apenas mês e ano importam. Então é apropriado guardá-lo em um campo DATETIME no banco de dados.

Para isso acontecer configuramos o NHibernate para tratar o Month como um DATETIME na hora de persistir tanto o City quanto o Zombie (campos Infected), criando uma classe que implementa a interface IUserType:

public class MonthUserType: IUserType
{
    public new bool Equals(object x, object y)
    {
        if (ReferenceEquals(x, y)) return true;

        if (x == null || y == null) return false;

        return x.Equals(y);
    }

    public int GetHashCode(object x)
    {
        return x == null ? typeof(Month).GetHashCode() : x.GetHashCode();
    }

    //voltando do BD: passar de datetime para Month
    public object NullSafeGet(IDataReader rs, string[] names, object owner)
    {
        var date = NHibernateUtil.DateTime.NullSafeGet(rs, names[0]) as DateTime?;

        if (date == null) return null;

        return new Month(date.Value.Year, date.Value.Month);
    }

    //indo pro BD: passar de Month para datetime
    public void NullSafeSet(IDbCommand cmd, object value, int index)
    {
        DateTime? date = null;

        if (value != null)
            date = ((Month) value).AsDateTime();

        NHibernateUtil.DateTime.NullSafeSet(cmd, date, index);
    }

    public object DeepCopy(object value)
    {
        return value;
    }

    public object Replace(object original, object target, object owner)
    {
        return original;
    }

    public object Assemble(object cached, object owner)
    {
        return cached;
    }

    public object Disassemble(object value)
    {
        return value;
    }

    public SqlType[] SqlTypes
    {
        get { return new[] { NHibernateUtil.DateTime.SqlType }; }
    }

    public Type ReturnedType
    {
        get { return typeof (Month); }
    }

    public bool IsMutable
    {
        get { return false; }
    }
}

Esta classe vai tratar do trabalho de converter de Month para DATETIME e vice-versa. Para usar nosso MonthUserType é necessário configurar os mapeamentos das classes City e Zombie:

Map(x => x.Infected).CustomType(typeof(MonthUserType));

Mas eu não usei esta abordagem. Imagine que tenhamos mais que essas duas classes para alterar ou que eu deseje deixar a configuração mais limpa. Podemos deixar os mapeamentos já configurados do mesmo jeito, e informar o NHibernate a usar o MonthUserType usando Convenções (Conventions).

Basta implementar uma classe com a informação de que nossa convenção é usar MonthUserType para persistir objetos Month:

    public class MonthUserTypeConvention: UserTypeConvention<MonthUserType>
    {
    }

É assim mesmo, vazio. No caso nem foi necessário realizar nenhum override dos métodos Apply() ou Accept().

E pronto! Suas classes estão prontas para serem persistidas no banco de dados.

Infraestrutura

Bom, mas para se gravar os dados no banco é preciso ao menos saber como se conectar ao banco. Vamos facilitar nossa vida criando um método fábrica de objetos fábricas (ou algo assim):

    public static class FluentSessionFactory
    {
        public static ISessionFactory CreateFactory(string connectionString)
        {
            return Fluently.Configure()
              .Database(MsSqlConfiguration.MsSql2005.ConnectionString(connectionString))
              .Mappings(
                m => m.FluentMappings
                    .AddFromAssemblyOf<City>()
                    .Conventions.AddFromAssemblyOf<MonthUserTypeConvention>()
              )
              .ExposeConfiguration(BuildSchema)
              .BuildSessionFactory();
        }

        private static void BuildSchema(Configuration config)
        {
            SchemaExport schema = new SchemaExport(config);
            schema.Drop(false, true);
            schema.Create(false, true);
        }

    }

Note que meu banco é um Sql Server 2005. Acerte o código para teu banco de dados. E para usar:

ISessionFactory factory = FluentSessionFactory.CreateFactory(@"Database=test_db;Server=localhost\sqlexpress;user=theuser;pwd=thepassword;");
ISession session = factory.OpenSession();
/** cria objetos e manda para o bd usando Session.Save(objeto) **/
session.Close();

Mas tome cuidado. Note um schema.Drop() e um schema.Create() lá em cima. Eles jogam as tabelas do banco fora e depois recriam-nas. Bom para o ambiente de desenvolvimento. Ruim para ambiente de produção. Muito ruim.

1, 2, 3 Testando

Nada melhor que usar testes automatizados para verificar se está tudo funcionando. Quer dizer, comer camarão na praia tomando cerveja é melhor que isso, mas vamos lá.

O Fluent NHibernate conta com um método muito útil para verificar se os mapeamentos estão redondinhos. Se trata do PersistenceSpecification.VerifyTheMappings().

Veja como é simples:

[TestClass]
public class CityMapTest
{
    private static readonly string ConnString = @"Database=db_test;Server=localhost\sqlexpress;user=theuser;pwd=thepassword;";
    private static ISession Session;

    private TestContext testContextInstance;

    public TestContext TestContext
    {
        get
        {
            return testContextInstance;
        }
        set
        {
            testContextInstance = value;
        }
    }

    [ClassInitialize()]
    public static void MyClassInitialize(TestContext testContext)
    {
        ISessionFactory factory = FluentSessionFactory.CreateFactory(ConnString);
        Session = factory.OpenSession();
    }

    [ClassCleanup()]
    public static void MyClassCleanup()
    {
        Session.Close();
    }

    [TestMethod]
    public void CrudTest()
    {
        new PersistenceSpecification<City>(Session)
            .CheckProperty(x => x.Id, 1)
            .CheckProperty(x => x.Name, "Raccoon City")
            .CheckProperty(x => x.InfectionStart, new Month(1998, 8))
            .CheckList(
                x => x.Zombies,
                new []
                {
                    new Zombie { FormerName  =  "John Doe", Infected = new Month(1998, 7) },
                    new Zombie { FormerName  =  "José da Silva", Infected = new Month(1998, 6) }
                },
                (r, z) => r.AddZombie(z))
            .VerifyTheMappings();
    }
}

Ao executar o teste acima serão criadas as tabelas City e Zombie no banco de dados, que serão preenchidas com os dados fornecidos. Depois esses dados serão lidos e convetidos em objetos do sistema. Daí estes objetos serão comparados com os objetos originais. Se estiver tudo ok, o teste sinalizará verde. Se não, hora de corrigir bugs.

E é isso. Ah, para quem quiser o código do projeto…

Posts relacionados

• Linq to Sql
• DDD
• Encodings e charsets em Asp.NET
• DNS poisoning na NET Virtua

Ultimamente tenho pensado numa programação Zen: o melhor código é o não-código. Quanto menos código você escrever, menos terá para manter, menos terá para entender, menos terá para depurar. Ou talvez esteja exacerbando apenas a melhor qualidade de um programador.

Chega de papo-furado, segue a lista (todas no namespace System):

Fonte: http://mikevallotton.wordpress.com/2009/07/08/net-exceptions-all-of-them/

O fiel mordomo

Mas estes dias criei um projeto no Hudson, referente à uma solução já no framework .NET v4, escrita no Visual Studio 2010 (v10).

O primeiro passo foi entrar nas configurações do Hudson e criar outra entrada para o plugin MSBuild, apontando para a versão 4 do mesmo. Basta ir para Gerenciar Hudson → Configurar Sistema → MSBuild e incluir:

C:\Windows\Microsoft.NET\Framework\v4.0.30319\MSBuild.exe

Feito isto, configurei o novo projeto para usar esta nova entrada do MSBuild. E o projeto falhou na construção com a seguinte mensagem:

error MSB4019: The imported project "C:\Program Files (x86)\MSBuild\Microsoft\VisualStudio\v10.0\WebApplications\Microsoft.WebApplication.targets" was not found. Confirm that the path in the <Import> declaration is correct, and that the file exists on disk.

O jeito foi atender a demanda: criei as respectivas pastas e copiei o arquivo do meu micro para o servidor. Pronto. Agora só resta resolver alguns pepinos com assemblies…

Update: parece que preciso instalar ou o Visual Studio 2010 ou o Windows 7 SDK  no servidor em questão. Mas ocorrem dois problemas: (1) o VS2010 é caro e (2) o SDK ainda não saiu. O jeito é aguardar meados de junho.

Posts relacionados

• Compilando seu Web Application Project com o MSBuild
• Problema rodando testes MbUnit no VS2008 Test Runner
• ASP.NET Development Server (integrated web server)
• Linq to Sql

A parte chata é que isto impossbilita a edição das páginas e controles à quente, direto no servidor. Opa, na verdade esta é parte boa.

Após instalar basta clicar com o botão direito sobre o seu projeto no Visual Studio que surgirá uma opção Add Web Deployment Project…. Clicando nesta opção o projeto deveria ser criado. Deveria. Ao menos aqui no Windows 7 não funciona.

Um erro surge dizendo, entre outras coisas: Unable to create the project file.

Como solucionar? Você deve rodar o Visual Studio como Administrador. Simples assim.

Posts relacionados

• Substituindo texto com Perl e Estouro de Pilha
• Agrupando arquivos na árvore do VS 2005
• Esquema de cores para o Visual Studio 2008

Login failed for user ‘NT AUTHORITY\NETWORK SERVICE’

ou

Falha no login ‘AUTORIDADE NT\SERVIÇO DE REDE’

Não se preocupe. Execute o seguinte no banco de dados master no SQL Server:

sp_grantlogin 'NT AUTHORITY\NETWORK SERVICE'

ou

sp_grantlogin 'AUTORIDADE NT\SERVIÇO DE REDE'

Pronto, sua aplicação conversará com seu banco de dados.

Posts relacionados

• Linked Server: consultando o PostGreSQL através do MS SQL Server
• Linked server com Oracle
• Acessando o MS SQL Server através do PostGreSQL
• Linked Servers

Depois registre um System DSN, ou Fonte de Dados do Sistema. Para isto basta se encaminhar para:

Painel de Controle → Ferramentas Administrativas → Fontes de Dados ODBC.

Basta preencher as caixinhas e depois testar. Com a conexão funcionando,  agora é hora de se criar um Linked Server entre o MS SQL Server e o PostGreSQL.

EXEC master.dbo.sp_droplinkedsrvlogin
          @rmtsrvname=N'LINKEDSERVERNAME'
	, @locallogin=NULL

EXEC master.dbo.sp_dropserver
	  @server = 'LINKEDSERVERNAME'

EXEC master.dbo.sp_addlinkedserver
	  @server = 'LINKEDSERVERNAME'
	, @provider = 'Postgresql OLE DB'
	, @datasrc = 'Postgresql ANSI'

EXEC master.dbo.sp_addlinkedsrvlogin
	  @rmtsrvname=N'LINKEDSERVERNAME'
	, @useself=N'False'
	, @locallogin=NULL
	, @rmtuser='usuariopostgres'
	, @rmtpassword='senhapostgres'

Agora você pode fazer consultas assim:

SELECT * FROM openquery(LINKEDSERVERNAME, 'SELECT * FROM TABELADOPOSTGRES')

Posts relacionados

• Acessando o MS SQL Server através do PostGreSQL
• Linked server com Oracle
• Login failed for user ‘NT AUTHORITY\NETWORK SERVICE’
• Linked Servers

E ainda implementa os métodos definidos pela OGC.

Isto possibilita operações CRUD sobre o dados georreferenciados, diretamente através de comandos SQL.

Os métodos estáticos, acessíveis através de geometry::NomeDoMétodo(),  são:

• STGeomFromText (geometry Data Type)
• STPointFromText (geometry Data Type)
• STLineFromText (geometry Data Type)
• STPolyFromText (geometry Data Type)
• STMPointFromText (geometry Data Type)
• STMLineFromText (geometry Data Type)
• STMPolyFromText (geometry Data Type)
• STGeomCollFromText (geometry Data Type)
• STGeomFromWKB (geometry Data Type)
• STPointFromWKB (geometry Data Type)
• STLineFromWKB (geometry Data Type)
• STPolyFromWKB (geometry Data Type)
• STMPointFromWKB (geometry Data Type)
• STMLineFromWKB (geometry Data Type)
• STMPolyFromWKB (geometry Data Type)
• STGeomCollFromWKB (geometry Data Type)

E os métodos do objeto geometry:

• STArea
• STAsBinary
• STAsText
• STBoundary
• STBuffer
• STCentroid
• STContains
• STConvexHull
• STCrosses
• STDifference
• STDimension
• STDisjoint
• STDistance
• STEndpoint
• STEnvelope
• STEquals
• STExteriorRing
• STGeometryN
• STGeometryType
• STInteriorRingN
• STIntersection
• STIntersects
• STIsClosed
• STIsEmpty
• STIsRing
• STIsSimple
• STIsValid
• STLength
• STNumGeometries
• STNumInteriorRing
• STNumPoints
• STOverlaps
• STPointN
• STPointOnSurface
• STRelate
• STSrid
• STStartPoint
• STSymDifference
• STTouches
• STUnion
• STWithin
• STX
• STY

Estes métodos podem ser chamados da seguinte forma, por exemplo:

SELECT coluna1.STArea() FROM tabela

onde coluna1 é do tipo geometry.

Posts relacionados

• Inserindo registros geoespaciais: ArcSDE e SQL Server
• ArcSDE e MS SQL Server 2008
• ArcGIS Javascript, Dojo e o método require
• SIG – Sistema de Informação Geográfica

Primeiro  é necessário criar uma tabela no SQL Server e registrá-la junto ao ArcSDE. Isto é bem simples de se realizar utilizando o ArcCatalog (note que também dá para se criar a tabela via SQL e registrá-la no ArcSDE via linha de comando).  Basta entrar no ArcCatalog, conectar-se com sua instância do ArcSDE e clicar com o botão direito no ícone do banco de dados. Depois é só escolher o Feature Class:

Criando um Feature Class

É apresentada então uma caixa de diálogo para criar sua tabela que conterá sua feição. Criei uma tabela chamada MeuFeatureClass. As colunas OBJECTID e SHAPE são criadas por padrão. Adicionei um campo1 e um campo2 também. E escolhi o tipo da geometria como POINT.

Criada a tabela é bem simples de se inserir um registro através de comando SQL:

INSERT INTO
MeuBD.sde.MeuFeatureClass
(OBJECTID, campo1, campo2, shape)
VALUES
(1, valor1, valor2, geometry::STGeomFromText('POINT (-46.616667 -23.533333)', 4674))

O comando acima insere um registro na tabela contendo um ponto localizado no município de São Paulo – SP, usando o SRID 4674 (SIRGAS 2000).

Note que não usamos uma função típica do T-SQL  para transformar o texto dado em uma coordenada válida pro sistema.  Isto me deixou confuso no início, pois eu não encontrava funções geoespaciais no banco de dados. Liste as funções existentes no banco de dados do ArcSDE que oê não encontrará nada relacionado ao sistema geo.

Estas funções ficam disponíveis como métodos da classe e objetos  geometry.  No caso acima, o STGeomFromText é um método estático da classe geometry. Os mundos da Orientação a Objetos e do SQL se mesclam cada vez mais…

Posts relacionados

• ArcSDE e MS SQL Server 2008
• Funções Geoespaciais do MS SQL Server 2008
• SIG – Sistema de Informação Geográfica
• Cache e camadas no ArcGIS Server

Algo que pode ajudar nesta tarefa é usar a própria API Google para carregar estas outras APIs:

http://code.google.com/apis/ajaxlibs/

O código, retirado direto do site, é o seguinte:

// Load Google JS API
<script src="http://www.google.com/jsapi"></script>
<script>
// Load jQuery
google.load("jquery", "1");
</script>

Você simplesmente:

• carrega a API javascript do Google;
• utiliza a API do Google para carregar as outras APIs, podendo escolher a versão, inclusive.

A opção de escolher a versão do script ajuda bastante a manter seus sistemas atualizados de forma bem simples.

O problema é apenas não poder guardar as APIs no servidor. Em uma rede local sem acesso à internet, por exemplo, isto já não serve.

Posts relacionados

• ArcGIS Javascript, Dojo e o método require
• Ext JS
• Type “casting” no Javascript
• Campo DateField em um formulário ExtJS

Seu SRID, num sistema geográfico, é  EPSG:  4674:

GEOGCS["SIRGAS 2000",
    DATUM["Sistema_de_Referencia_Geocentrico_para_America_del_Sur_2000",
        SPHEROID["GRS 1980",6378137,298.257222101,
            AUTHORITY["EPSG","7019"]],
        TOWGS84[0,0,0,0,0,0,0],
        AUTHORITY["EPSG","6674"]],
    PRIMEM["Greenwich",0,
        AUTHORITY["EPSG","8901"]],
    UNIT["degree",0.01745329251994328,
        AUTHORITY["EPSG","9122"]],
    AUTHORITY["EPSG","4674"]]

Na prática o SIRGAS utiliza o mesmo elipsóde de referência do WGS84 – GRS 1980. Veja mais no site da UFRGS. O mesmo ocorre com o posicionamento do elipsóide, com seus centros situando-se bem próximos um do outro.

Isto significa que as medidas dados pelo SIRGAS são quase iguais aos dados pelo WGS84,  onde uma diferença entre as medidas pode ser menor que o erro aproximado de seu instrumento GPS, pois esta diferença está na ordem de centímetros.

Assim, se seu equipamento for antigo é bem provável que ocorram duas coisas:

• ele não tenha uma precisão tão boa a ponto de se distinguir entre WGS84 e SIRGAS 2000;
• ele não possua o SIRGAS 2000 em seu rol de referências.

Então use o WGS84 e seja feliz.

Posts relacionados

• Sistema de Referenciamento Espacial
• SIG – Sistema de Informação Geográfica
• ArcSDE e MS SQL Server 2008
• Inserindo registros geoespaciais: ArcSDE e SQL Server

Para determinarmos essa posição precisamos de duas coisas: um ponto de referência e um sistema de coordenadas.

Datum

Para descrever esta localização temos de levar em conta algumas coisas. Primeiro, a Terra não é plana. Verdade. E nem uma bola.  Mas podemos aproximar sua superfície à algumas formas geométricas.  A primeira que vem à mente é a esfera. É boa para se montar globos escolares e pintar os continentes em  bolas de  praia. Mas, como aprendemos na escolinha, a Terra é achatada nos pólos. Mas a aproximação com a esfera serve para qualquer coisa que conte com uma escala pequena.

Globo terrestre

Segue então uma segunda aproximação: um elipsóide ou esferóide. Ou uma esfera achatada.  Esta forma geométrica é bastante utilizada para descrever a superfície do planeta,  parte por facilitar bastante os cálculos envolvidos e parte por se adequar razoavelmente à superfície verdadeira da Terra. Para obter um grau maior de aproximação modificamos os tamanhos dos eixos do elipsóide e também deslocamos seu centro, ajeitando-o com relação à Terra.

Ou seja, se a Terra fosse um esferóide perfeito, todos os pontos de sua superfície iriam tocar nos pontos do esferóide de referência.  Como isso não ocorre, a gente ajeita o esferóide, definindo em que pontos o esferóide toca a superfície do planeta.  Note que definição de pontos tem data de validade, ou pelo menos data de referência, visto que a posição relativa entre os continentes muda com o tempo. Digamos que nosso esferóide toca a superfície do planeta em um ponto específico de Pindamonhangaba e em outro em Paris. Infelizmente estes pontos não corresponderão exatamente ao mesmo local no dia seguinte. Por isso temos nomes como WGS84, SAD69. Os números se referem ao ano .

Esferóide

Uma outra forma é a geóide. A geóide se trata de uma figura geométrica cuja superfície possui sempre a mesma força gravitacional, correspondendo mais ou menos ao nível médio do mar. Uma esfera não rolaria para lado nenhum em cima da superfície de uma geóide. Os cálculos sobre esta figura são mais complicados, mas é uma aproximação bastante útil para analisar a construção de canais, rodovias extensas e redes de água e esgoto.

Geóide

A escolha da figura geométrica, a definição de suas dimensões e o posicionamento desta figura com relação à Terra nos dá o datum (nota: só estou considerando sistema geocêntricos, deixando os topocêntricos de lado).

Espermatozóide

Sistema Geográfico de Coordenadas

Temos um datum. Mas isto não basta. Precisamos de um sistema de coordenadas para localizar o que quer que seja. Para isto temos um Sistema Geográfico de Coordenadas (geographic coordinate system ou GCS), também conhecido como sistema esférico de coordenadas,  que inclui uma unidade de medida angular, um meridiano principal e um datum.

Latitude (φ) e Longitude (λ)

Com o datum, o equador e o meridiano principal, geralmente o de Greenwich, conseguimos um ponto de referência,  onde φ = 0° e λ = 0°,  e o centro do esferóide, a partir do qual todas as medidas são baseadas. Só para constar, a cidade de São Paulo se encontra em 23°33′0″ S, 46°38′0″ W, ou seja, latitude  -23°33′0″ e longitude -46°38′0″.

Sistema de Coordenadas Projetadas

O GCS ajuda a localizar algum ponto. Mas para visualizar o mapa no papel, ou na tela do computador, precisamos levar tudo que está em um objeto 3D em pontos correspondentes em um plano 2D. Isto se chama projeção. A mesma projeção que se ensina nas aulas de matemática da escolinha, mas aplicada em nossos mapas.

Pensando na superfície da Terra, podemos pensar em algumas características:

• Área
• Forma
• Direção
• Posicionamento relativo
• Distância
• Escala

Quando projetamos esta superfície em um plano, podemos preservar algumas delas. Mas não todas. Por isto existem vários tipos de projeção. Cada uma prioriza alguma das propriedades descritas. A mais famosa é a Projeção de Mercator, que privilegia direção e posicionamento relativo.

Projeção de Mercator

A projeção de Mercator é do tipo cilíndrica. Pense em uma bola de tênis enfiada em uma lata de batatas Pringles.  O problema dela é que deforma bastante a área conforme nos afastamos da linha do Equador. É só reparar no tamanho da Ántártica, que não é nem o dobro da do Brasil.

O cilindro em que é projetado o mapa tem seu eixo na mesma direção do eixo de rotação da Terra,  ou seja, o cilindro toca a Terra ao longo da linha do Equador.

Projeção cilíndrica

Isto nos leva à outra projeção importante: o Sistema Universal Transverso de Mercator (UTM). Ele é bastante semelhante à projeção de Mercator tradicional.

As diferenças são que o eixo do cilindro faz 90° com o eixo de rotação da Terra e o próprio cilindro é rotacionado  para obtermos projeções  mais precisas em cada fatia em que o cilindro toca a Terra.

Universal Transverse of Mercator

Estas fatias são então quadriculadas em uma grade. Cada quadrado desta grade forma então um sistema de coordenadas cartesianas, onde a unidade de medida é o metro.

Sistema de Referenciamento Espacial (Spatial Reference System)

E por fim temos o sistema de referencimento espacial, que nada mais é que a descrição de um conjunto que tem tudo que esta aí em cima. Um exemplo:

GEOGCS["SAD69",
    DATUM["South_American_Datum_1969",
        SPHEROID["GRS 1967 (SAD69)",6378160,298.25,
            AUTHORITY["EPSG","7050"]],
        AUTHORITY["EPSG","6618"]],
    PRIMEM["Greenwich",0,
        AUTHORITY["EPSG","8901"]],
    UNIT["degree",0.01745329251994328,
        AUTHORITY["EPSG","9122"]],
    AUTHORITY["EPSG","4618"]]

O que é descrito acima, num formato conhecido como Well Known Text (WKT),  é o sistema SAD 69. Note é descrito o sistema geográfico de coordenadas (GEOGCS) com o datum utilizado,  o meridiano principal – Greenwich e a unidade de medida – degree,  assim como outras informações.  É comum utilizar apenas um número para nos referir a esta referência espacial. Este número, o SRID,  pode ser visto na última linha: EPSG 4618. Muito mais exemplos em SpatialReference.org.

Outro exemplo:

PROJCS["SIRGAS 2000 / UTM zone 23S",
    GEOGCS["SIRGAS 2000",
        DATUM["Sistema_de_Referencia_Geocentrico_para_America_del_Sur_2000",
            SPHEROID["GRS 1980",6378137,298.257222101,
                AUTHORITY["EPSG","7019"]],
            TOWGS84[0,0,0,0,0,0,0],
            AUTHORITY["EPSG","6674"]],
        PRIMEM["Greenwich",0,
            AUTHORITY["EPSG","8901"]],
        UNIT["degree",0.01745329251994328,
            AUTHORITY["EPSG","9122"]],
        AUTHORITY["EPSG","4674"]],
    UNIT["metre",1,
        AUTHORITY["EPSG","9001"]],
    PROJECTION["Transverse_Mercator"],
    PARAMETER["latitude_of_origin",0],
    PARAMETER["central_meridian",-45],
    PARAMETER["scale_factor",0.9996],
    PARAMETER["false_easting",500000],
    PARAMETER["false_northing",10000000],
    AUTHORITY["EPSG","31983"],
    AXIS["Easting",EAST],
    AXIS["Northing",NORTH]]

Neste caso é descrito um sistema de coordenadas projetadas (PROJCS), o que requer, além das informações previstas para o GEOGCS, qual o tipo de projeção – Transverse Mercator – e localização do ponto de referência  que determina o origem do sistema de medidas, no caso  em metros.  O srid é 31983.

Ao invés de passar toda estas informações para alguém, basta informar o SRID.  Finalmente sabemos de onde vem o tal SRID que popula nossos banco de dados geográficos, e que devemos passar como parâmetro para as APIs Geo deste  mundão esferóide afora.

Posts relacionados

• SIRGAS 2000
• ArcSDE e MS SQL Server 2008
• SIG – Sistema de Informação Geográfica
• Inserindo registros geoespaciais: ArcSDE e SQL Server

O jeito é então alertar o Asp.NET  da existência destes navegadores.  E para isto basta criar uma pasta e um arquivo.

Se já não existir, crie em seu projeto uma pasta App_Browsers. E dentro dela crie um arquivo chamado safari.browser, que deve conter o seguinte:

<browsers>
    <browser refID="Safari1Plus">
        <controlAdapters>
            <adapter controlType="System.Web.UI.WebControls.Menu" adapterType="" />
        </controlAdapters>
    </browser>
</browsers>

E pronto! Tanto Safari quanto Chrome agora poderão mostrar seus lindos menus tablefull.

Posts relacionados

• Problema rodando testes MbUnit no VS2008 Test Runner
• ASP.NET Development Server (integrated web server)
• HttpPostedFile: IE versus Firefox
• Criando um método de log em Asp.NET

Vem daí a dificuldade de se estabelecer prazos. De gerar metodologias. De ser produtivo, ter qualidade e criar soluções. Como apressar, controlar e gerenciar algo tão pessoal quanto a produção de código? Talvez tornando-o impessoal e automático. Mas não seria isto remover as características que diferenciam um software bom de um ótimo?

Pode-se criar arte em massa. Pode-se criar obra únicas. Pode-se apreciar ou não uma obra-prima. Não é tão diferente no mundo do código fonte. Quem já não vislumbrou, modificando um programa qualquer, uma obra de arte barroca? Cheia de meandros, voltas, incertezas e becos sem saída. Um labirinto a provocar emoções: fúria, alegria,  raiva, medo, alívio (bom, este só quando o código compila e/ou passa nos testes). Estou divergindo…

E quem programa pode ser entendido como um artesão. Alguém que martela teclas para produzir, vez ou outra, um pouco de arte. E podemos encontrar, procurando bastante, entre estes artesãos, um verdadeiro artista.

Why?

É o caso de Why the Luck Stiff, ou simplesmente _why. Seu trabalho mais conhecido é seu livro: Why’s (poignant) Guide to Ruby. Mesmo que você não programe, mesmo que você não entenda nem mesmo HTML, dê uma olhada.  O livro é excelente. Se parece com algo saído de uma viagem  de LSD, misturado com Alice no País das Maravilhas e lições de Ruby. E existe até uma trilha sonora para acompanhá-la!

Mas, onde encontro este livro? O site do _why saiu do ar. Assim como muitos outros projetos pertencentes a ele. Até a conta no twitter, @_why, sumiu. _why desapareceu. Ninguém sabe ninguém viu.

É um feito notável para alguém que alcançou certa notoriedade online, e com uma presença forte na internet. Participou de palestras e eventos, mas sempre se identificando por seu pseudônimo.  Ainda existe o anonimato, afinal (há quem diga que _why apenas está dando um tempo e retornará como _because).

Mas dá para apreciar sua obra em alguns mirrors.  E já tratei de guardar a trilha sonora para ouvir enquanto programo. Quem sabe não tenho uma epifania (ou uma síncope, dependendo do código a editar). E tem até tradução para o português, que até onde vi está ótima.

As raposas de _why

So long _why, and thanks for all the chunky bacon.

Posts relacionados

• Ruby – Why’s (poinant) guide to ruby
• Fontpark 2.0
• Como se tornar um ótimo programador
• Desenvolvedor Web

Tentando criar um código JS mais organizado, encontrei o método dojo.require, que, em conjunto dos métodos dojo.declare e dojo.provide, devolvem um pouco de sanidade ao programandor.  Ele funciona da seguinte maneira.  Você inventa um namespace/pacote,  e depois associa um caminho à ele:

dojo.registerModulePath( "pacote", "http://localhost/scripts/")

E depois pode incluir ou importar pacotes assim:

dojo.require("pacote.MinhaClasse");

A mágica é que o arquivo http://localhost/scripts/MinhaClasse.js é carregado automaticamente. Legal! Parecido com Java, C# e um monte de outras linguagens. Agora vou criar arquivos correspondentes às classes que criarei, e organizar a macarronada Javascript.

Mas não. A API Javascript ArcGIS, por alguma razão, procura pelo arquivo http://localhost/scripts/MinhaClasse.xd.js !!! De onde saiu este xd? E mesmo criando o arquivo que ele espera, seu conteúdo não é processado da forma correta.

Elaborando alguns testes eu susbtitui a referência:

<script type=”text/javascript” src=”http://serverapi.arcgisonline.com/jsapi/arcgis/?v=1.4″></script>

pela:

<script type=”text/javascript” src=”http://dojotoolkit.org/sites/all/modules/dojo/dtk_build/dojo/dojo.js”></script>

E funcionou ok. Parece que a versão do dojo entregue pela ESRI no ArcGIS não permite o uso do dojo.require. Para que isto seja possível, é necessário compilar o dojo de forma a permiti-lo carregar arquivos de domínios distintos, ou cross domain. Mas na API da ESRI não dá. Pena.

Encontrei como resolver o problema:

        djConfig = {
            parseOnLoad: true,
            baseUrl: "./scripts",
            modulePaths: {
                "minhasClasses": "./minhasClasses",
                "meusDijits": "./BLA"
            },
           isDebug: true
        }

Isto me ensina a aprender direito antes de escrever! =)

Posts relacionados

• Carregando bibliotecas Javascript abertas
• Funções Geoespaciais do MS SQL Server 2008
• Cache e camadas no ArcGIS Server
• SIG – Sistema de Informação Geográfica

A partir de outra máquina virtual, rodando o Ubuntu Jaunty Desktop, consigo normalmente acessar o banco de dados no Ubuntu Server, então tudo ok. Ou quase tudo ok.

Para acessar o banco de dados postgresql a partir de meu sistema hospedeiro – ou seria anfitirião? estalajadeiro?, rodando o indefectível ( até o momento) Windows 7 tive de instalar os controladores ODBC (disponíves no ftp do Postgresql) .

Depois de instalar, navego até o Painel de Controle, depois para Fontes de dados Odbc e, CADÊ? Sumiu, ninguém viu. Só aparecem listados os controladores das fontes de dados do SQL Server. Muito estranho.

Mas eu já havia feito isto. Uma busca em minha memória e me lembrei que era um problema de versão do sistema. O controlador, ou driver , que instalei é de 32 bits. O sistema é de 64 bits. E o Windows não gosta de misturar alhos com bugalhos.

Para acessar finalmente o gerenciador de fontes de dados ODBC 32 bits é necessário executar este safado:

C:\Windows\SysWOW64\odbcad32.exe

Agora sim!

Posts relacionados

• Impressora Epson TX600FW
• Recriando o Show Desktop
• Não consegue listar os Databases no SQL Management Studio?
• Lerdeza para remover arquivos no Vista?

O próprio PostGIS possui um script para migração de dados. Se trata de um script Perl que recebe um dump do PostgreSQL e mais alguns outros parâmetros, trata-os gerando um novo dump e depois finalmente faz o restore do dump no banco de dados.

Problemas

Parecia tudo ok, até eu tentar fazer um backup do novo banco:

ERROR:  geometry contains non closed rings

Será que os dados se corromperam durante a migração?

O PostGIS 1.4 é um pouco mais restritivo quanto aos dados que armazena. Um multipolygon ou polygon, por exemplo, só podem ser inseridos no sistema se estiverem bem formados, o que significa que devem ser polígonos fechados (hmm,  e existe “polígono aberto”?).

O problema é que a versão 1.1.6 é mais, digamos, liberal. Você consegue gravar “polígonos  abertos”, consegue fazer SELECTs e backups em cima deles. Apenas operações  que envolvam as formas geométricas podem dar problema.

E o processo de migração de dados não realiza nenhuma verificação de validade destas entidades.

Assim, os dados migrados para a nova versão continua com “polígonos abertos”,  impossibilitando, na versão 1.4,  até mesmo um simples select sobre os dados da tabela.

A solução foi encontrar os registros com este problema e removê-los da tabela através da seguinte consulta SQL:

DELETE
FROM <nome_da_tabela>
WHERE isvalid(coords) != 't'

E se você possui muitas tabelas com o problema, boa sorte!

Posts relacionados

• SIG – Sistema de Informação Geográfica
• ArcSDE e MS SQL Server 2008
• ArcGIS Javascript, Dojo e o método require
• Cache e camadas no ArcGIS Server

No tests were run because no tests are loaded or the selected tests are disabled

O problema é que o projeto de testes é tratado como uma simples biblioteca de classes, embora seus métodos sejam decorados com atributos [Test] e similares.

E como fazer o VS2008 entender que o projeto em questão é de testes? É necessário abrir o arquivo .csproj correspondente ao projeto e incluir o seguinte:

<ProjectTypeGuids>
{3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}
</ProjectTypeGuids>

Logo antes do primeiro </PropertyGroup> do arquivo. O VS2008 verifica o tipo do projeto em questão através destes identificadores. E como encontrei estes números? Criei um projeto de testes MSTest pelo VS2008 e abri o .csproj.

E encontrei o significado destes guids:

• {3AC096D0-A1C2-E12C-1390-A8335801FDAB} identifica um Test Project
• {FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} identifica um Windows Forms C# Project

Posts relacionados

• Compilando seu Web Application Project com o MSBuild
• Erro no deploy automático: Hudson versus MSBuild
• O Menu Asp.NET e o Chrome (e Safari)
• Gerando boletos bancários em Asp.NET – Parte I

Em primeiro lugar é necessário que você tenha os dados armazenados em algum lugar, um banco de dados talvez. Mas vou presumir que seu código já trate dos dados e me ater à construção de duas partes fundamentais do boleto: a linha digitável e o código de barras.

Note que, embora alguns dígitos da linha digitável sigam um padrão, cada banco pode possuir regras próprias para gerá-la. Entre em contato com seu banco para ter essas informações.

Linha digitável

A linha digitável, lembrando novamente que estou seguindo as instruções do Itaú, possui 47 dígitos.

Abaixo segue a construção da linha, lembrando que DAC significa dígito de auto-conferência, ou simplesmente dígito verificador.

Campo 1 (AAABC.CCDDX):

• AAA = código do banco – Itaú = 341;
• B = código da moeda – Real = 9;
• CCC = código da carteira de cobrança;
• DD = dois primeiros dígitos do Nosso Número;
• X = DAC  módulo 10 do campo 1;

Campo 2 (DDDDD.DEFFFY):

• DDDDDD = restante do Nosso Número;
• E = DAC do grupo agência/conta/carteira/nosso número;
• FFF = três primeiros números da agência;
• Y = DAC módulo 10 do campo 2;

Campo 3 (FGGGG.GGHHHZ):

• F = último número da agência;
• GGGGGG = conta corrente + DAC;
• HHH = zeros;
• Z = DAC módulo 10 do campo 3;

Campo 4 (K):

• K = DAC módulo 11 do código de barras (único DAC que vai para o código de barras);

Campo 5 (UUUUVVVVVVVVVV):

• UUUU = fator de vencimento;
• VVVVVVVVVV = valor do boleto, sem ponto e vírgula, ou zeros, no caso do valor ser preenchido pelo próprio sacado.

O fator de vencimento contém 4 dígitos e é o número de dias desde 7 de outubro de 1997,  servindo para indicar a data de vencimento do boleto (teremos o bug do milênio 21 de fevereiro de 2025?).

Seu cálculo é bem simples, como podemos ver pelo método abaixo:

private int FatorVencimento(DateTime date)
{
    DateTime zeroDay = new DateTime(1997, 10, 7);
    return (date - zeroDay).Days;
}

DAC

Analisando as regras anteriores, temos que a maior parte do trabalho consiste-se em concatenar strings e calcular DACs.

Para criar nossa Linha Digitável iremos dispor de dois algoritmos para calcular os DAC:s o módulo 10 e o módulo 11.

O cálculo do DAC módulo 10 é realizado da seguinte forma. Tome o campo a ter calculado o DAC. Multiplique cada algarismo do campo pela sequência de multiplicadores 2, 1, 2, 1, 2, 1…, posicionados
da direita para a esquerda. Some os resultados, que chamarei de N.
Calcule o módulo 10 de N – mod10(N) ou N%10.
O DAC será 10 – mod10(N). Caso o DAC seja 10, considere-o como 0.

Segue abaixo um método para calcular o DAC módulo 10:

private int CalculaDacMod10(string campo)
{
    int soma = 0;
    int m;

    // caso exista um número par de algarismos, inicia a mult. por 1
    if ((campo.Length % 2) == 0)
        m = 1;
    else
        m = 2;
    foreach (char c in campo)
    {
        soma += Convert.ToInt32(c) * m;
        m = 3 - m; //regra aplicada: (x+y) - x = y; (x+y) - y = x
    }

    int dac = 10 - (soma % 10);

    if (dac == 10)
        return 0;

    return dac;
}

O cálculo do DAC módulo 11 é bem semelhante.Ele depois será utilizado para compor o DAC do código de barras.

Tendo o trecho a ter o DAC calculado, tome seus algarismos e multiplique-os, iniciando-se da direita para a esquerda, pela sequência numérica de 2 a 9 ( 2, 3, 4, 5, 6,
7, 8, 9, 2, 3, 4… e assim por diante). Some o resultado obtendo nosso N.

Calcule agora o módulo 11 de N – mod11(N) ou N%11. O DAC será 11 – mod11(N). Caso o cálculo do DAC tenha dado 0, 10 ou 11, considere-o como 1.

O método abaixo faz o cálculo do DAC módulo 11:

private int CalculaDacMod11(string campo)
{
    int soma = 0;
    int m = 2;

    //Invertendo a string, para facilitar o trabalho com os multiplicadores
    char [] arr = campo.ToCharArray();
    Array.Reverse(arr);
    string reversed = new String(arr);

    foreach(char c in reversed)
    {
        soma += Convert.ToInt32(c) * m;
        m = (m + 1 > 9 ? 2 : m + 1);
    }

    int dac = 11 - (soma % 11);

    if (dac == 0 || dac == 10 || dac == 11)
        return 1;

    return dac;
}

Código de Barras

O padrão de código de barras para os boletos no Brasil é o denominado 2 de 5 intercalado, que pode ser resumido nas seguintes características:

• codifica apenas caracteres numéricos (0-9);
• cada caractere é representado por 5 barras, dentre os quais 2 são mais longas;
• codificação binária – largo é 1, estreito é 0;
• os espaços também possuem signifcado, por isso o intercalado

Este código de barras serve apenas para representar nossa linha digitável, tranformado o que é uma seqüência de números em uma imagem. Existem muitos controles por aí que fazem isto, mas não encontrei nenhum gratuito para Asp.NET.

Neste exemplo vou utilizar o barcodenet.net. Ele pode ser testado e é completamente funcional, a diferença é que, enquanto você não resgistrá-lo,  ele  criará uma linha escrito barcodenet.net (ou algo assim) logo acima do código de barras.

Embora a linha digitável possua 47 dígitos, o número que será codificado em barras possui apenas 44. Por quê? Porque devemos nos livrar de três dos quatro DACs que constam nela. Assim o código de barra terá apenas um DAC.

Outra diferença importante é de que a ordem em que os campos se apresentam na linha digitável não é a mesma da apresentada pelo código de barras.

Segue como gerar então os dígitos que compõem o código de barras:

• 3 dígitos do código do Banco (341);
• 1 dígito com o código da moeda (3);
• 1 dígito do DAC do Código de Barras;
• 4 dígitos do fator de vencimento;
• 10 dígitos do valor do tíitulo, desconsiderando qualquer sinal de pontuaçaõ;
• 3 dígitos da carteira;
• 9 dígitos do Nosso Número mais seu próprio DAC;
• 4 dígitos da agência;
• 6 dígitos da conta corrente, com seu próprio DAC;
• 3 dígitos não utilizados e composto por zeros (000).

Depois de gerar os dígitos que compõem o código de barras, é questão de torná-lo em imagem utilizando o controle comentado anteriormente:

public byte[] CodigoBarras()
{
    BarcodeNETWeb barcode = new BarcodeNETWeb();
    barcode.BarcodeText = DigitosCodigoBarrasComDac();
    barcode.BarcodeType = BARCODE_TYPE.INT2OF5;

    return barcode.GetBarcodeBitmap(FILE_FORMAT.PNG);
}

Código

Segue então a listagem do código fonte utilizado neste trabalho. Claro que há muito o que melhorar nele, mas isto fica como exercício. =)

Note que modifiquei a classe Dados do post anterior.

public class LinhaDigitavel
{
    public int Banco { get; private set; }
    public int Moeda { get {return 9; }}
    public string CarteiraCobranca { get; private set; }
    public string NossoNumero { get; private set; }
    public string Agencia { get; private set; }
    public string ContaCorrente { get; private set; }
    public DateTime Vencimento { get; private set; }
    public decimal Valor { get; private set; }

    public LinhaDigitavel(
        int banco,
        string carteira,
        string nossonumero,
        string agencia,
        string contacorrente,
        DateTime vencimento,
        decimal valor)
    {
        this.Banco = banco;
        this.CarteiraCobranca = carteira;
        this.NossoNumero = nossonumero;
        this.Agencia = agencia;
        this.ContaCorrente = contacorrente;
        this.Vencimento = vencimento;
        this.Valor = valor;
    }

    public LinhaDigitavel(Dados dados)
    {
        this.Banco = dados.Banco;
        this.CarteiraCobranca = dados.Carteira;
        this.NossoNumero = dados.NossoNumero;
        this.Agencia = dados.Agencia;
        this.ContaCorrente = dados.ContaCorrente;
        this.Vencimento = dados.DataVencimento;
        this.Valor = dados.ValorDocumento;
   } 

    public string FormatoParaImpressao()
    {
        return
            Campo1().Substring(0, 5) + "." + Campo1().Substring(5) + " "
            + Campo2().Substring(0, 5) + "." + Campo2().Substring(5) + " "
            + Campo3().Substring(0, 5) + "." + Campo3().Substring(5) + " "
            + Campo4() + " "
            + Campo5();
    }

    public byte[] CodigoBarras()
    {
        BarcodeNETWeb barcode = new BarcodeNETWeb();
        barcode.BarcodeText = DigitosCodigoBarrasComDac();
        barcode.BarcodeType = BARCODE_TYPE.INT2OF5;

        return barcode.GetBarcodeBitmap(FILE_FORMAT.PNG);
    }

    private string Campo1()
    {
        string campo =
            this.Banco.ToString("000")
            + this.Moeda.ToString("0")
            + this.CarteiraCobranca.Trim()
            + this.NossoNumero.Split('-')[0].Substring(0, 2);

        if (campo.Length != 9) throw new Exception("Entrada inválida");

        return campo + CalculaDacMod10(campo).ToString("0");
    }

    private string Campo2()
    {
        string campo =
            this.NossoNumero.Split('-')[0].Substring(2, 6)
            + this.DacAgenciaContaCarteiraNossNumero().ToString("0")
            + this.Agencia.Substring(0, 3);

        if (campo.Length != 10) throw new Exception("Entrada inválida");

        return campo + CalculaDacMod10(campo).ToString("0");
    }

    private string Campo3()
    {
        string campo =
            this.Agencia.Substring(3, 1)
            + this.ContaCorrente.Split('-')[0] + this.ContaCorrente.Split('-')[1] //sinto falta de explode/implode
            + "000";

        if (campo.Length != 10) throw new Exception("Entrada inválida");

        return campo + CalculaDacMod10(campo).ToString("0");
    }

    private string Campo4()
    {
        return DacCodigoBarras().ToString("0");
    }

    private string Campo5()
    {

        return
            this.FatorVencimento().ToString("0000")
            + FormataValor(this.Valor);
    }

    private string FormataValor(decimal valor)
    {
        string[] value = this.Valor.ToString("00000000.00", System.Globalization.CultureInfo.InvariantCulture).Split('.');
        return value[0] + value[1];
    }

    private int DacAgenciaContaCarteiraNossNumero()
    {
        string termo =
            this.Agencia
            + this.ContaCorrente.Split('-')[0]
            + this.CarteiraCobranca
            + this.NossoNumero.Split('-')[0];

        if (termo.Length != 20) throw new Exception("Entrada inválida");

        return CalculaDacMod10(termo);
    }

    private int DacCodigoBarras()
    {
        return CalculaDacMod11(DigitosCodigoBarrasSemDac());
    }

    private string DigitosCodigoBarrasSemDac()
    {

        string termo =
            this.Banco.ToString("000")
            + this.Moeda.ToString("0")
            + this.FatorVencimento().ToString("0000")
            + this.Valor.ToString("0000000000")
            + this.CarteiraCobranca
            + this.NossoNumero.Split('-')[0] + this.NossoNumero.Split('-')[1]
            + this.Agencia
            + this.ContaCorrente.Split('-')[0] + this.ContaCorrente.Split('-')[1] //sinto falta de explode/implode
            + "000";

        return termo;
    }

    private string DigitosCodigoBarrasComDac()
    {
        string termo = DigitosCodigoBarrasSemDac();
        return termo.Substring(0, 4) + DacCodigoBarras().ToString("0") + termo.Substring(4);
    }

    private int FatorVencimento()
    {
        DateTime zeroDay = new DateTime(1997, 10, 7);
        return (this.Vencimento - zeroDay).Days;
    }

    ///
    /// DAC móulo 10
    /// Exemplo:
    /// Considerando-se a seguinte representação numérica do código de barras:
    /// 34191.1012? 34567.88005? 71234.57000? 6 16670000012345
    /// Temos:
    /// a) Multiplicando a sequência dos campos pelo módulo 10:
    ///  Campo 1 341911012 Campo 2 3456788005 Campo 3 7123457000
    ///        X 212121212       X 1212121212       X 1212121212
    ///  Observação: Os campos 4 e 5 não tem DAC
    /// b) Some, individualmente, os algarismos dos resultados do produtos:
    ///  Campo 1 : 6 + 4 + 2 + 9 + 2 + 1 + 0 + 1 + 4 = 29
    ///  Campo 2 : 3 + 8 + 5 + 1 + 2 + 7 + 1 + 6 + 8 + 0 + 0 + 1 + 0 = 42
    ///  Campo 3 : 7 + 2 + 2 + 6 + 4 + 1 + 0 + 7 + 0 + 0 + 0 = 29
    /// c) Divida o total encontrado por 10, a fim de determinar o resto da divisão:
    ///  Campo 1 : 29 / 10 = 2, resto 9
    ///  Campo 2 : 42 / 10 = 4, resto 2
    ///  Campo 3 : 29 / 10 = 2, resto 9
    /// d) Calculando o DAC:
    ///  Campo 1 : DAC = 10 - 9 : DAC = 1
    ///  Campo 2 : DAC = 10 - 2 : DAC = 8
    ///  Campo 3 : DAC = 10 - 9 : DAC = 1
    /// Portanto, a sequência correta da linha digitável será:
    ///  34191.10121 34567.880058 71234.570001 6 16670000012345
    ///
    ///
<span> </span>
    ///
    private int CalculaDacMod10(string campo)
    {
        int soma = 0;
        int m;

        // caso exista um número par de algarismos, inicia a mult. por 1
        if ((campo.Length % 2) == 0)
            m = 1;
        else
            m = 2;
        foreach (char c in campo)
        {
            soma += Convert.ToInt32(c) * m;
            m = 3 - m; //regra aplicada: (x+y) - x = y; (x+y) - y = x
        }

        int dac = 10 - (soma % 10);

        if (dac == 10)
            return 0;

        return dac;
    }

    ///
    /// Considerando o seguinte conteúdo do Código de Barras:
    ///  3419?1667000001234511012345678800571423457000
    /// onde:
    ///  341 = Código do Banco
    ///  9 = Código da Moeda
    ///  ? = DAC do Código de Barras
    ///  1667 Fator de Vencimento (01/05/2002)
    ///  0000012345 = Valor do Título (123,45)
    ///  110123456788 = Carteira/Nosso Número/DAC (110/12345678-8)
    ///  0057123457 = Agência/Conta Corrente/DAC (0057/12345-7)
    ///  000 = Posições Livres (zeros)
    ///  Temos:
    ///   a) Multiplica-se a sequência do código de barras pelo módulo 11:
    ///      3419166700000123451101234567880057123457000
    ///    X 4329876543298765432987654329876543298765432
    /// b) Soma-se o resultado dos produtos obtidos no item “a” acima:
    ///   12 + 12 + 2 + 81 + 8 + 42 + 36 + 35 + 0 + 0 + 0 + 0 + 0 + 7 + 12 + 15 + 16 + 15 + 2 +
    ///   9 + 0 + 7 + 12 + 15 + 16 + 15 + 12 + 63 + 64 + 56 + 0 + 0 + 20 + 21 + 2 + 18 + 24 +
    ///   28 + 30 + 35 + 0 + 0 + 0 = 742
    /// c) Determina-se o resto da Divisão:
    ///   742 / 11 = 67, resto 5
    /// d) Calcula-se o DAC:
    ///   DAC = 11 – 5  então  DAC = 6
    ///   Portanto, a sequência correta do código de barras será:
    ///   34196166700000123451101234567880057123457000
    ///       ^---DAC
    ///
    ///

    ///
    private int CalculaDacMod11(string campo)
    {
        int soma = 0;
        int m = 2;

        //Invertendo a string, para facilitar o trabalho com os multiplicadores
        char [] arr = campo.ToCharArray();
        Array.Reverse(arr);
        string reversed = new String(arr);

        foreach(char c in reversed)
        {
            soma += Convert.ToInt32(c) * m;
            m = (m + 1 &gt; 9 ? 2 : m + 1);
        }

        int dac = 11 - (soma % 11);

        if (dac == 0 || dac == 10 || dac == 11)
            return 1;

        return dac;
    }
}

public class Dados
{
    public DateTime DataDocumento { get; set; }
    public DateTime DataVencimento { get; set; }
    public DateTime DataProcessamento { get; set; }

    public string Cedente { get; set; }
    public string SacadoResumido { get; set; }
    public string SacadoCompleto { get; set; }

    public int Banco { get; set; }
    public string Agencia { get; set; }
    public string ContaCorrente { get; set; }
    public string CodigoCedente { get; set; }

    public int NumeroDocumento { get; set; }
    public string EspecieDocumento { get; set; }
    public string Aceite { get; set; }
    public string NossoNumero { get; set; }
    public string Carteira { get; set; }

    public string Instrucoes { get; set; }

    public int Quantidade { get; set; }
    public decimal Valor { get; set; }
    public decimal ValorDocumento { get; set; }

    public string CodigoBaixa { get; set; }
    public byte[] CodigoBarra
    {
        get
        {
            LinhaDigitavel linha = new LinhaDigitavel(this);
            return linha.CodigoBarras();
        }
    }
    public string LinhaDigitavel
    {
        get
        {
            LinhaDigitavel linha = new LinhaDigitavel(this);
            return linha.FormatoParaImpressao();
        }
    }
}

Um exemplo de uso do gerador de boletos:

protected void btnGeraBoleto_OnClick(object sender, EventArgs e)
{
    Boleto boleto = new Boleto(Portal.Controles.Boleto.Banco.ITAU, Server);
    List
 dados = new List
();

    dados.Add(
        new Portal.Controles.Boleto.Dados()
        {
            Aceite = "N",
            Agencia = "1234",
            Banco = 341,
            Carteira = "109",
            Cedente = "Indústria ACME",
            CodigoBaixa = "109/12345678-9",
            CodigoCedente = "12345-6",
            ContaCorrente = "12345-6",
            DataDocumento = DateTime.Now,
            DataProcessamento = DateTime.Now,
            DataVencimento = new DateTime(2009, 4, 5),
            EspecieDocumento = "DM",
            Instrucoes =
@"Não receber após o vencimento",
            NossoNumero = "12345678-9",
            NumeroDocumento = 0000000012,
            Quantidade = 0,
            SacadoCompleto =
@"Padoca do Zé - LTDA                  CNPJ - 12.345.678/0001-23
Rua das Casas, 123
01234-123        Vl do Bairro          Sao Paulo          SP",
            SacadoResumido = "Padoca do Zé - LTDA",
            Valor = 0,
            ValorDocumento = 2637.00m
        });

    boleto.Baixa(Response, dados);
}

Fechando

Embora existam outras opções, como cartões de crédito e pagamento direto online, o boleto ainda é utilizado devido à familiaridade e facilidade de pagamento por parte do comprador. Por isso temos de saber gerá-lo em nossos sistemas, mesmo que utilizemos soluções prontas.

Vimos que gerar um boleto na plataforma .Net é algo simples, composto por uma guia impressa, alguma lógica para a geração da linha digitável e uma ferramenta de terceiros para a criação do código de barras. A parte mais difícil fica no sistema subjacente, não abordada, onde entra o retorno do pagamento do boleto e finalmente na remessa da mercadoria. Mas isto fica para uma próxima.

Posts relacionados

• Gerando boletos bancários em Asp.NET – Parte I
• Ligando um controle à um Enum
• HttpPostedFile: IE versus Firefox
• Conseguindo a URL completa de uma página

Uma das maneiras de se incluir código Javascript no controle é este:

protected override void OnPreRender(EventArgs e)
{
    base.OnPreRender(e);
    if (!Page.ClientScript.IsClientScriptBlockRegistered("algumid"))
    {
        string script = @"
function MinhaFuncaoJS()
{
    ...
    ...
    ...
}
...
...
...
function OutraFuncaoJS()
{
    ...
    ...
    ...
}
";
        Page.ClientScript.RegisterClientScriptBlock(
            this.GetType(),
            "algumid",
            script,
            true);
    }
}

O que não é muito bom por alguns motivos, entre outros:

• se torna difícil reutilizar código Javascript;
• deve-se tomar cuidado ao incluir mais de um controle na página, pois acaba-se incluindo o mesmo código Javascript mais de uma vez na página;
• é mais fácil cometer equívocos no código Javascript.

A maneira de se contornar isto é embarcando o código Javascript na aplicação – ou embedding the script resource.

Para tanto você apenas cria o arquivo contendo o script, por exemplo MeuProjeto/minhasfuncoes.js, o inclui no projeto e, através de suas propriedades, configura o item Build Action como Embedded Resource.

Modifique esta propriedade para Embedded

Isto inclui o script na DLL gerada na compilação. Para acessá-lo é preciso registrá-lo no AssemblyInfo.cs:

[assembly: WebResource("MeuProjeto.minhasfuncoes.js", "text/javascript")]

E depois em cada controle que irá utilizar o script:

protected override void OnPreRender(EventArgs e)
{
    Page.ClientScript.RegisterClientScriptResource(
        typeof(GeoImage),
        "MeuProjeto.minhasfuncoes.js");
    base.OnPreRender(e);
}

E pronto! O sistema irá incluir o script em sua página através de um handler WebResource.axd.

Posts relacionados

• Framework de testes funcionais NexusLight
• DataSource Parameters: falta um PropertyParameter!
• Ligando um controle à um Enum
• Estendendo o BoundField