Criou o serviço da conta sintética 
22/08/2010 20:09:43-org.hibernate.cfg.annotations.Version <clinit> 
INFO: Hibernate Annotations 3.3.0.GA 
22/08/2010 20:09:43-org.hibernate.cfg.Environment <clinit> 
INFO: Hibernate 3.2.5 
22/08/2010 20:09:43-org.hibernate.cfg.Environment <clinit> 
INFO: hibernate.properties not found 
22/08/2010 20:09:43-org.hibernate.cfg.Environment buildBytecodeProvider 
INFO: Bytecode provider name : cglib 
22/08/2010 20:09:43-org.hibernate.cfg.Environment <clinit> 
INFO: using JDK 1.4 java.sql.Timestamp handling 
22/08/2010 20:09:43-org.hibernate.ejb.Version <clinit> 
INFO: Hibernate EntityManager 3.3.1.GA 
22/08/2010 20:09:44-org.hibernate.cfg.AnnotationBinder bindClass 
INFO: Binding entity from annotated class: modelo.Lancamento 
22/08/2010 20:09:44-org.hibernate.cfg.annotations.EntityBinder bindTable 
INFO: Bind entity modelo.Lancamento on table Lancamento 
22/08/2010 20:09:44-org.hibernate.cfg.AnnotationBinder bindClass 
INFO: Binding entity from annotated class: modelo.ContaContabilSintetica 
22/08/2010 20:09:44-org.hibernate.cfg.annotations.EntityBinder bindTable 
INFO: Bind entity modelo.ContaContabilSintetica on table ContaContabilSintetica 
22/08/2010 20:09:44-org.hibernate.cfg.AnnotationBinder bindClass 
INFO: Binding entity from annotated class: modelo.ContaContabilAnalitica 
22/08/2010 20:09:44-org.hibernate.cfg.annotations.EntityBinder bindTable 
INFO: Bind entity modelo.ContaContabilAnalitica on table ContaContabilAnalitica 
22/08/2010 20:09:44-org.hibernate.cfg.AnnotationBinder bindClass 
INFO: Binding entity from annotated class: modelo.Reserva 
22/08/2010 20:09:44-org.hibernate.cfg.annotations.EntityBinder bindTable 
INFO: Bind entity modelo.Reserva on table RESERVA 
22/08/2010 20:09:44-org.hibernate.cfg.AnnotationBinder bindClass 
INFO: Binding entity from annotated class: modelo.Cor 
22/08/2010 20:09:44-org.hibernate.cfg.annotations.EntityBinder bindTable 
INFO: Bind entity modelo.Cor on table COR 
22/08/2010 20:09:44-org.hibernate.cfg.annotations.CollectionBinder bindOneToManySecondPass 
INFO: Mapping collection: modelo.ContaContabilSintetica.contasContabeisAnaliticas -> ContaContabilAnalitica 
22/08/2010 20:09:44-org.hibernate.cfg.annotations.CollectionBinder bindOneToManySecondPass 
INFO: Mapping collection: modelo.ContaContabilSintetica.contasContabeisSinteticasFilhas -> ContaContabilSintetica 
22/08/2010 20:09:44-org.hibernate.validator.Version <clinit> 
INFO: Hibernate Validator 3.0.0.GA 
22/08/2010 20:09:45-org.hibernate.connection.C3P0ConnectionProvider configure 
INFO: C3P0 using driver: org.postgresql.Driver at URL: jdbc:postgresql://127.0.0.1:5432/JavaDB 
22/08/2010 20:09:45-org.hibernate.connection.C3P0ConnectionProvider configure 
INFO: Connection properties: {user=marcelo, password=****, autocommit=true, release_mode=auto} 
22/08/2010 20:09:45-org.hibernate.connection.C3P0ConnectionProvider configure 
INFO: autocommit mode: true 
22/08/2010 20:09:45-com.mchange.v2.log.MLog <clinit> 
INFO: MLog clients using log4j logging. 
22/08/2010 20:09:45-com.mchange.v2.c3p0.C3P0Registry banner 
INFO: Initializing c3p0-0.9.1 [built 16-January-2007 14:46:42; debug? true; trace: 10] 
22/08/2010 20:09:45-com.mchange.v2.c3p0.impl.AbstractPoolBackedDataSource getPoolManager 
INFO: Initializing c3p0 pool... com.mchange.v2.c3p0.PoolBackedDataSource@ef220090 [ connectionPoolDataSource -> com.mchange.v2.c3p0.WrapperConnectionPoolDataSource@690bc899 [ acquireIncrement -> 3, acquireRetryAttempts -> 30, acquireRetryDelay -> 1000, autoCommitOnClose -> false, automaticTestTable -> null, breakAfterAcquireFailure -> false, checkoutTimeout -> 0, connectionCustomizerClassName -> null, connectionTesterClassName -> com.mchange.v2.c3p0.impl.DefaultConnectionTester, debugUnreturnedConnectionStackTraces -> false, factoryClassLocation -> null, forceIgnoreUnresolvedTransactions -> false, identityToken -> 1hge13c8a17avx571dzw4fw|32d8ca48, idleConnectionTestPeriod -> 0, initialPoolSize -> 5, maxAdministrativeTaskTime -> 0, maxConnectionAge -> 0, maxIdleTime -> 600, maxIdleTimeExcessConnections -> 0, maxPoolSize -> 20, maxStatements -> 50, maxStatementsPerConnection -> 0, minPoolSize -> 5, nestedDataSource -> com.mchange.v2.c3p0.DriverManagerDataSource@3595583f [ description -> null, driverClass -> null, factoryClassLocation -> null, identityToken -> 1hge13c8a17avx571dzw4fw|3e0d1329, jdbcUrl -> jdbc:postgresql://127.0.0.1:5432/JavaDB, properties -> {user=******, password=******, autocommit=true, release_mode=auto} ], preferredTestQuery -> null, propertyCycle -> 0, testConnectionOnCheckin -> false, testConnectionOnCheckout -> false, unreturnedConnectionTimeout -> 0, usesTraditionalReflectiveProxies -> false; userOverrides: {} ], dataSourceName -> null, factoryClassLocation -> null, identityToken -> 1hge13c8a17avx571dzw4fw|52205756, numHelperThreads -> 3 ] 
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings 
INFO: RDBMS: PostgreSQL, version: 8.4.1 
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings 
INFO: JDBC driver: PostgreSQL Native Driver, version: PostgreSQL 8.0 JDBC2 with NO SSL (build 310) 
22/08/2010 20:09:45-org.hibernate.dialect.Dialect <init> 
INFO: Using dialect: org.hibernate.dialect.PostgreSQLDialect 
22/08/2010 20:09:45-org.hibernate.transaction.TransactionFactoryFactory buildTransactionFactory 
INFO: Transaction strategy: org.hibernate.transaction.JDBCTransactionFactory 
22/08/2010 20:09:45-org.hibernate.transaction.TransactionManagerLookupFactory getTransactionManagerLookup 
INFO: No TransactionManagerLookup configured (in JTA environment, use of read-write or transactional second-level cache is not recommended) 
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings 
INFO: Automatic flush during beforeCompletion(): disabled 
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings 
INFO: Automatic session close at end of transaction: disabled 
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings 
INFO: JDBC batch size: 15 
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings 
INFO: JDBC batch updates for versioned data: disabled 
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings 
INFO: Scrollable result sets: enabled 
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings 
INFO: JDBC3 getGeneratedKeys(): disabled 
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings 
INFO: Connection release mode: auto 
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings 
INFO: Default batch fetch size: 1 
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings 
INFO: Generate SQL with comments: disabled 
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings 
INFO: Order SQL updates by primary key: disabled 
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings 
INFO: Order SQL inserts for batching: disabled 
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory createQueryTranslatorFactory 
INFO: Query translator: org.hibernate.hql.ast.ASTQueryTranslatorFactory 
22/08/2010 20:09:45-org.hibernate.hql.ast.ASTQueryTranslatorFactory <init> 
INFO: Using ASTQueryTranslatorFactory 
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings 
INFO: Query language substitutions: {} 
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings 
INFO: JPA-QL strict compliance: enabled 
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings 
INFO: Second-level cache: enabled 
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings 
INFO: Query cache: disabled 
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory createCacheProvider 
INFO: Cache provider: org.hibernate.cache.NoCacheProvider 
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings 
INFO: Optimize cache for minimal puts: disabled 
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings 
INFO: Structured second-level cache entries: disabled 
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings 
INFO: Echoing all SQL to stdout 
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings 
INFO: Statistics: disabled 
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings 
INFO: Deleted entity synthetic identifier rollback: disabled 
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings 
INFO: Default entity-mode: pojo 
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings 
INFO: Named query checking : enabled 
22/08/2010 20:09:45-org.hibernate.impl.SessionFactoryImpl <init> 
INFO: building session factory 
22/08/2010 20:09:46-org.hibernate.impl.SessionFactoryObjectFactory addInstance 
INFO: Not binding factory to JNDI, no JNDI name configured 

>>>>>>>>>>>>> STRANGE SELECTS START HERE <<<<<<<<<<<<<<<<<<
Hibernate:   
    select 
        contaconta0_.contaContabilSinteticaID as contaCon1_1_0_, 
        contaconta0_.contaContabilSinteticaPai as contaCon5_1_0_, 
        contaconta0_.grupoContabil as grupoCon2_1_0_, 
        contaconta0_.nome as nome1_0_, 
        contaconta0_.observacao as observacao1_0_   
    from 
        ContaContabilSintetica contaconta0_   
    where 
        contaconta0_.contaContabilSinteticaID=? 
Hibernate:   
    select 
        contascont0_.contaContabilSinteticaID as contaCon4_1_, 
        contascont0_.contaContabilAnaliticaID as contaCon1_1_, 
        contascont0_.contaContabilAnaliticaID as contaCon1_2_0_, 
        contascont0_.contaContabilSinteticaID as contaCon4_2_0_, 
        contascont0_.nome as nome2_0_, 
        contascont0_.observacao as observacao2_0_   
    from 
        ContaContabilAnalitica contascont0_   
    where 
        contascont0_.contaContabilSinteticaID=? 
Hibernate:   
    select 
        lancamento0_.contaContabilAnaliticaID as contaCon1_1_, 
        lancamento0_.lancamentoID as lancamen2_1_, 
        lancamento1_.lancamentoID as lancamen1_0_0_, 
        lancamento1_.dataCadastro as dataCada2_0_0_, 
        lancamento1_.historico as historico0_0_, 
        lancamento1_.valor as valor0_0_   
    from 
        ContaCreditada lancamento0_   
    left outer join 
        Lancamento lancamento1_   
            on lancamento0_.lancamentoID=lancamento1_.lancamentoID   
    where 
        lancamento0_.contaContabilAnaliticaID=? 
Hibernate:   
    select 
        lancamento0_.contaContabilAnaliticaID as contaCon1_1_, 
        lancamento0_.lancamentoID as lancamen2_1_, 
        lancamento1_.lancamentoID as lancamen1_0_0_, 
        lancamento1_.dataCadastro as dataCada2_0_0_, 
        lancamento1_.historico as historico0_0_, 
        lancamento1_.valor as valor0_0_   
    from 
        ContaDebitada lancamento0_   
    left outer join 
        Lancamento lancamento1_   
            on lancamento0_.lancamentoID=lancamento1_.lancamentoID   
    where 
        lancamento0_.contaContabilAnaliticaID=? 
Hibernate:   
    select 
        lancamento0_.contaContabilAnaliticaID as contaCon1_1_, 
        lancamento0_.lancamentoID as lancamen2_1_, 
        lancamento1_.lancamentoID as lancamen1_0_0_, 
        lancamento1_.dataCadastro as dataCada2_0_0_, 
        lancamento1_.historico as historico0_0_, 
        lancamento1_.valor as valor0_0_   
    from 
        ContaCreditada lancamento0_   
    left outer join 
        Lancamento lancamento1_   
            on lancamento0_.lancamentoID=lancamento1_.lancamentoID   
    where 
        lancamento0_.contaContabilAnaliticaID=? 
Hibernate:   
    select 
        lancamento0_.contaContabilAnaliticaID as contaCon1_1_, 
        lancamento0_.lancamentoID as lancamen2_1_, 
        lancamento1_.lancamentoID as lancamen1_0_0_, 
        lancamento1_.dataCadastro as dataCada2_0_0_, 
        lancamento1_.historico as historico0_0_, 
        lancamento1_.valor as valor0_0_   
    from 
        ContaDebitada lancamento0_   
    left outer join 
        Lancamento lancamento1_   
            on lancamento0_.lancamentoID=lancamento1_.lancamentoID   
    where 
        lancamento0_.contaContabilAnaliticaID=? 
Hibernate:   
    select 
        contascont0_.contaContabilSinteticaPai as contaCon5_1_, 
        contascont0_.contaContabilSinteticaID as contaCon1_1_, 
        contascont0_.contaContabilSinteticaID as contaCon1_1_0_, 
        contascont0_.contaContabilSinteticaPai as contaCon5_1_0_, 
        contascont0_.grupoContabil as grupoCon2_1_0_, 
        contascont0_.nome as nome1_0_, 
        contascont0_.observacao as observacao1_0_   
    from 
        ContaContabilSintetica contascont0_   
    where 
        contascont0_.contaContabilSinteticaPai=?
>>>>>>>>> END <<<<<<<<<<<
Recuperou conta sintética ID = 5 
Conta sintética 1 
ATIVO

/**
* As contas contábeis sintéticas servem somente para agrupar as contas contábeis
* analíticas, não sendo permitido lançamentos nestas contas. Outra boa finalidade
* para estas contas é a geração de relatórios sintéticos para niveis gerenciais
* de uma empresa, visto que tais contas sintéticas possuem o seu saldo como sendo
* o somatório dos saldos de suas contas analíticas. Toda conta contábil sintética
* deve percenter a um grupo contábil, ativo, passivo ou de resultado, sendo esta
* última dividida em 3 grupos, contas de receitas, contas de despesas e contas de
* apuração de resultado. Estes 3 grupo deverão sempre ter seus saldos
* transportados para as contas patrimonias, ativo e passivo, ficando assim com
* saldo zero ao final de um exercício contábil.
* @author Marcelo Magalhães
* @version 1.0
* @created 31-jul-2010 01:45:54
*/ 
package modelo; 
 
import java.io.Serializable; 
import java.util.HashSet; 
import java.util.Iterator; 
import java.util.Set; 
 
import javax.persistence.Column; 
import javax.persistence.Entity; 
import javax.persistence.FetchType; 
import javax.persistence.GeneratedValue; 
import javax.persistence.GenerationType; 
import javax.persistence.Id; 
import javax.persistence.JoinColumn; 
import javax.persistence.ManyToOne; 
import javax.persistence.OneToMany; 
import javax.persistence.SequenceGenerator; 
import javax.persistence.Table; 
import javax.persistence.Transient; 
 
import org.hibernate.annotations.Cascade; 
import org.hibernate.annotations.CascadeType; 
import org.hibernate.annotations.Fetch; 
import org.hibernate.annotations.FetchMode; 
 
@Entity 
@Table(name="ContaContabilSintetica") 
 
@SequenceGenerator(name="CONTACONTABILSINTETICA_SEQ", sequenceName="CONTACONTABILSINTETICA_SEQ", allocationSize=1) 
public class ContaContabilSintetica implements Serializable   
{ 
 
    private static final long serialVersionUID = 1; 
    private static final boolean TRUE = true; 
    private static final boolean FALSE = false; 
    /**
     * Lista das contas analíticas pertencentes a esta conta sintética.
     */ 
    private Set<ContaContabilAnalitica> contasContabeisAnaliticas; 
    /**
     * Identificador da conta sintética. Sequencia gerada pelo banco de dados.
     */ 
    private Long contaContabilSinteticaID; 
    /**
     * Identificador da conta contábil sintética (pai) que contém esta conta contábil
     * sintética (filho).
     */ 
    private ContaContabilSintetica contaContabilSinteticaPai; 
    /**
     * Classificador do tipo de grupo ao qual pertence a conta contábil sintética.
     * Este classificador é uma enumeração.
     */ 
    private int grupoContabil; 
    /**
     * Nome da conta contábil. Alfanumérico de até 70 caracteres.
     */ 
    private String nome; 
    /**
     * Campo destinado a observações sobre a conta.
     */ 
    private String observacao; 
    private Set<ContaContabilSintetica> contasContabeisSinteticasFilhas; 
 
    /**
     * Construtor padrão
     */ 
    public ContaContabilSintetica() 
    { 
        this.contasContabeisAnaliticas = new HashSet<ContaContabilAnalitica>(); 
        this.contasContabeisSinteticasFilhas = new HashSet<ContaContabilSintetica>(); 
    } 
 
    /**
     * Construtor com argumentos.
     * 
     * @param contaContabilSinteticaID
     * @param grupoContabil
     * @param nome
     * @param observacao
     * @param contaContabilSinteticaPai
     */ 
    public ContaContabilSintetica(long contaContabilSinteticaID, GrupoContabil grupoContabil, String nome, String observacao, ContaContabilSintetica contaContabilSinteticaPai) 
    { 
        this.contaContabilSinteticaID = contaContabilSinteticaID; 
        this.grupoContabil = grupoContabil.getIdentificador(); 
        this.nome = nome; 
        this.observacao = observacao; 
        this.contaContabilSinteticaPai = contaContabilSinteticaPai; 
     
        this.contasContabeisAnaliticas = new HashSet<ContaContabilAnalitica>(); 
        this.contasContabeisSinteticasFilhas = new HashSet<ContaContabilSintetica>(); 
    } 
 
    @Id 
    @GeneratedValue(strategy=GenerationType.SEQUENCE, generator="CONTACONTABILSINTETICA_SEQ") 
    @Column(name="contaContabilSinteticaID", unique=TRUE, nullable=TRUE, insertable=FALSE, updatable=FALSE) 
    public Long getContaContabilSinteticaID() 
    { 
        return this.contaContabilSinteticaID; 
    } 
 
    @Column(name="nome", unique=FALSE, nullable=FALSE, insertable=TRUE, updatable=TRUE, length=255) 
    public String getNome() 
    { 
        return this.nome; 
    } 
 
    @Column(name="observacao", unique=FALSE, nullable=TRUE, insertable=TRUE, updatable=TRUE, length=255) 
    public String getObservacao() 
    { 
        return this.observacao; 
    } 
 
    @Column(name="grupoContabil", unique=FALSE, nullable=FALSE, insertable=TRUE, updatable=TRUE) 
    public GrupoContabil getGrupoContabil() 
    { 
            int i;   
            for (GrupoContabil g : GrupoContabil.values()) 
            { 
                i = g.getIdentificador(); 
                if (i == grupoContabil) 
                { 
                return g; 
                } 
            } 
            return null; 
    } 
 
    @OneToMany(mappedBy="contaContabilSintetica", fetch = FetchType.LAZY) 
    //@Fetch(FetchMode.SELECT) 
    @Cascade(CascadeType.DELETE_ORPHAN) 
    public Set<ContaContabilAnalitica> getContasContabeisAnaliticas() 
    { 
        return this.contasContabeisAnaliticas; 
    } 
     
    @OneToMany(mappedBy="contaContabilSinteticaPai",fetch=FetchType.LAZY) 
    @Fetch(FetchMode.SELECT) 
    @Cascade(CascadeType.DELETE_ORPHAN) 
    public Set<ContaContabilSintetica> getContasContabeisSinteticasFilhas() 
    { 
        return this.contasContabeisSinteticasFilhas; 
    } 
     
    @ManyToOne(fetch = FetchType.LAZY) 
    @JoinColumn(name="contaContabilSinteticaPai") 
    @Fetch(FetchMode.SELECT) 
    public ContaContabilSintetica getContaContabilSinteticaPai() 
    { 
        return this.contaContabilSinteticaPai; 
    } 
 
    /**
     * 
     * @param contaContabilSinteticaID
     */ 
    public void setContaContabilSinteticaID(Long contaContabilSinteticaID) 
    { 
        this.contaContabilSinteticaID = contaContabilSinteticaID; 
    } 
 
    /**
     * 
     * @param nome
     */ 
    public void setNome(String nome) 
    { 
        this.nome = nome; 
    } 
 
    /**
     * 
     * @param observacao
     */ 
    public void setObservacao(String observacao) 
    { 
        this.observacao = observacao; 
    } 
 
    /**
     * 
     * @param grupoContabil
     */ 
    public void setGrupoContabil(GrupoContabil grupoContabil) 
    { 
        this.grupoContabil = grupoContabil.getIdentificador(); 
    } 
 
    /**
     * 
     * @param contasContabeisAnaliticas
     */ 
    public void setContasContabeisAnaliticas(Set<ContaContabilAnalitica> contasContabeisAnaliticas) 
    { 
        Iterator<ContaContabilAnalitica> iterator = contasContabeisAnaliticas.iterator(); 
     
        while (iterator.hasNext()) 
        { 
            ContaContabilAnalitica contaAnalitica = (ContaContabilAnalitica)iterator.next(); 
            this.adicionarContaContabilAnalitica(contaAnalitica); 
        }   
    } 
 
    /**
     * 
     * @param contaContabilSinteticaPai
     */ 
    public void setContaContabilSinteticaPai(ContaContabilSintetica contaContabilSinteticaPai) 
    { 
        this.contaContabilSinteticaPai = contaContabilSinteticaPai; 
    } 
 
    /**
     * 
     * @param contasContabeisSinteticasFilhas
     */ 
    public void setContasContabeisSinteticasFilhas(Set<ContaContabilSintetica> contasContabeisSinteticasFilhas) 
    { 
        Iterator<ContaContabilSintetica> iterator = contasContabeisSinteticasFilhas.iterator(); 
     
        while (iterator.hasNext()) 
        { 
            ContaContabilSintetica contaSintetica = (ContaContabilSintetica)iterator.next(); 
            this.adicionarContaContabilSinteticaFilha(contaSintetica); 
        }   
    } 
 
    /**
     * 
     * @param contaContabilAnalitica
     */ 
    @Transient 
    public void adicionarContaContabilAnalitica(ContaContabilAnalitica contaContabilAnalitica) 
    { 
        if (!this.getContasContabeisAnaliticas().contains(contaContabilAnalitica)) 
        { 
            this.contasContabeisAnaliticas.add(contaContabilAnalitica); 
            contaContabilAnalitica.adicionarContaContabilSintetica(this); 
        } 
    } 
 
    /**
     * 
     * @param contaContabilAnalitica
     */ 
    @Transient 
    public void removerContaContabilAnalitica(ContaContabilAnalitica contaContabilAnalitica) 
    { 
        if (this.getContasContabeisAnaliticas().contains(contaContabilAnalitica)) 
        { 
            this.contasContabeisAnaliticas.remove(contaContabilAnalitica); 
            contaContabilAnalitica.removerContaContabilSintetica(this); 
        } 
    } 
 
    /**
     * 
     * @param contaContabilSinteticaFilha
     */ 
    @Transient 
    public void adicionarContaContabilSinteticaFilha(ContaContabilSintetica contaContabilSinteticaFilha) 
    { 
        if (!this.getContasContabeisSinteticasFilhas().contains(contaContabilSinteticaFilha)) 
        { 
            this.contasContabeisSinteticasFilhas.add(contaContabilSinteticaFilha); 
        } 
    } 
 
    /**
     * 
     * @param contaContabilSinteticaFilha
     */ 
    @Transient 
    public void revomerContaContabilSinteticaFilha(ContaContabilSintetica contaContabilSinteticaFilha) 
    { 
        if (this.getContasContabeisSinteticasFilhas().contains(contaContabilSinteticaFilha)) 
        { 
            this.contasContabeisSinteticasFilhas.remove(contaContabilSinteticaFilha); 
        } 
    } 
 
    /**
     * Saldo total da conta contábil. Nas contas contábeis analíticas é a diferença
     * entre os lançamento de crédito e os de débito. Já nas contas contábies
     * sintéticas, o saldo, é o somatório dos saldos das contas contábeis analí ticas
     * pertencentes a esta conta.
     */ 
    @Transient 
    public float getSaldo() 
    { 
        Iterator<ContaContabilAnalitica> iterator = contasContabeisAnaliticas.iterator(); 
     
        float saldoTotal = 0; 
     
        while (iterator.hasNext()) 
        { 
            saldoTotal = saldoTotal + iterator.next().getSaldo(); 
        } 
     
        return saldoTotal; 
    } 
 
}

/**
* Nas contas contábeis analíticas é que são feitos os lançamentos contábeis que
* ocorrem no dia a dia de uma entidade. Esta conta não pode possuir sub-contas
* associadas a ela e o seu saldo é definido como a diferença entre os lançamentos
* de crédito e de débito.
* @author Marcelo Magalhães
* @version 1.0
* @created 31-jul-2010 01:45:52
*/ 
package modelo; 
 
import java.io.Serializable; 
import java.util.HashSet; 
import java.util.Iterator; 
import java.util.Set; 
 
import javax.persistence.Column; 
import javax.persistence.Entity; 
import javax.persistence.FetchType; 
import javax.persistence.GeneratedValue; 
import javax.persistence.GenerationType; 
import javax.persistence.Id; 
import javax.persistence.JoinColumn; 
import javax.persistence.JoinTable; 
import javax.persistence.ManyToMany; 
import javax.persistence.ManyToOne; 
import javax.persistence.SequenceGenerator; 
import javax.persistence.Table; 
import javax.persistence.Transient; 
 
import org.hibernate.annotations.Cascade; 
import org.hibernate.annotations.CascadeType; 
import org.hibernate.annotations.Fetch; 
import org.hibernate.annotations.FetchMode; 
 
@Entity 
@Table(name="ContaContabilAnalitica") 
 
@SequenceGenerator(name="CONTACONTABILANALITICA_SEQ", sequenceName="CONTACONTABILANALITICA_SEQ", allocationSize=1) 
public class ContaContabilAnalitica implements Serializable   
{ 
 
    private static final long serialVersionUID = 1; 
    private static final boolean TRUE = true; 
    private static final boolean FALSE = false; 
    private Set<Lancamento> lancamentosDebito; 
    private Set<Lancamento> lancamentosCredito; 
    /**
     * Identificador da conta analítica. Sequencia gerada pelo banco de dados.
     */ 
    private Long contaContabilAnaliticaID; 
    /**
     * Identificador da conta contábil sintética (pai) que contém esta conta contábil
     * analítica.
     */ 
    private ContaContabilSintetica contaContabilSintetica; 
    /**
     * Nome da conta contábil. Alfanumérico de até 70 caracteres.
     */ 
    private String nome; 
    /**
     * Campo destinado a observações sobre a conta.
     */ 
    private String observacao; 
 
    /**
     * Construtor padrão
     */ 
    public ContaContabilAnalitica() 
    { 
        this.lancamentosDebito = new HashSet<Lancamento>(); 
        this.lancamentosCredito = new HashSet<Lancamento>(); 
    } 
 
    /**
     * Construtor padrão com argumentos
     * 
     * @param contaContabilAnaliticaID
     * @param contaContabilSintetica
     * @param nome
     * @param observacao
     */ 
    public ContaContabilAnalitica(Long contaContabilAnaliticaID, ContaContabilSintetica contaContabilSintetica, String nome, String observacao) 
    { 
        this.contaContabilAnaliticaID = contaContabilAnaliticaID; 
        this.contaContabilSintetica = contaContabilSintetica; 
        this.nome = nome; 
        this.observacao = observacao; 
     
        this.lancamentosDebito = new HashSet<Lancamento>(); 
        this.lancamentosCredito = new HashSet<Lancamento>(); 
    } 
 
    @Id 
    @GeneratedValue(strategy=GenerationType.SEQUENCE, generator="CONTACONTABILANALITICA_SEQ") 
    @Column(name="contaContabilAnaliticaID", unique=TRUE, nullable=TRUE, insertable=TRUE, updatable=TRUE) 
    public Long getContaContabilAnaliticaID() 
    { 
        return this.contaContabilAnaliticaID; 
    } 
 
    @Column(name="nome", unique=FALSE, nullable=FALSE, insertable=TRUE, updatable=TRUE, length=255) 
    public String getNome() 
    { 
        return this.nome; 
    } 
 
    @Column(name="observacao", unique=FALSE, nullable=TRUE, insertable=TRUE, updatable=TRUE, length=255) 
    public String getObservacao() 
    { 
        return this.observacao; 
    } 
 
    @ManyToMany(fetch=FetchType.LAZY) 
    @JoinTable(name="ContaDebitada", joinColumns = {@JoinColumn(name="contaContabilAnaliticaID", nullable=TRUE)}, inverseJoinColumns = {@JoinColumn(name="lancamentoID", nullable=TRUE)}) 
    @Fetch(FetchMode.SELECT) 
    @Cascade(CascadeType.DELETE_ORPHAN) 
    public Set<Lancamento> getLancamentosDebito() 
    { 
        return this.lancamentosDebito; 
    } 
 
    @ManyToMany(fetch=FetchType.LAZY) 
    @JoinTable(name="ContaCreditada", joinColumns = {@JoinColumn(name="contaContabilAnaliticaID", nullable=TRUE)}, inverseJoinColumns = {@JoinColumn(name="lancamentoID", nullable=TRUE)}) 
    @Fetch(FetchMode.SELECT) 
    @Cascade(CascadeType.DELETE_ORPHAN) 
    public Set<Lancamento> getLancamentosCredito() 
    { 
        return this.lancamentosCredito; 
    } 
 
    @ManyToOne(fetch = FetchType.LAZY) 
    @JoinColumn(name="contaContabilSinteticaID", insertable=TRUE, updatable=TRUE) 
    @Fetch(FetchMode.SELECT) 
    public ContaContabilSintetica getContaContabilSintetica() 
    { 
        return this.contaContabilSintetica; 
    } 
 
    /**
     * 
     * @param contaContabilAnaliticaID
     */ 
    public void setContaContabilAnaliticaID(Long contaContabilAnaliticaID) 
    { 
        this.contaContabilAnaliticaID = contaContabilAnaliticaID; 
    } 
 
    /**
     * 
     * @param nome
     */ 
    public void setNome(String nome) 
    { 
        this.nome = nome; 
    } 
 
    /**
     * 
     * @param observacao
     */ 
    public void setObservacao(String observacao) 
    { 
        this.observacao = observacao; 
    } 
 
    /**
     * 
     * @param lancamentosDebito
     */ 
    public void setLancamentosDebito(Set<Lancamento> lancamentosDebito) 
    { 
        Iterator<Lancamento> iterator = lancamentosDebito.iterator(); 
     
        while (iterator.hasNext()) 
        { 
            Lancamento lancamento = (Lancamento)iterator.next(); 
            this.adicionarLancamentoDebito(lancamento); 
        }   
    } 
 
    /**
     * 
     * @param lancamentosCredito
     */ 
    public void setLancamentosCredito(Set<Lancamento> lancamentosCredito) 
    { 
        Iterator<Lancamento> iterator = lancamentosCredito.iterator(); 
     
        while (iterator.hasNext()) 
        { 
            Lancamento lancamento = (Lancamento)iterator.next(); 
            this.adicionarLancamentoCredito(lancamento); 
        }   
    } 
 
    /**
     * 
     * @param contaContabilSintetica
     */ 
    public void setContaContabilSintetica(ContaContabilSintetica contaContabilSintetica) 
    { 
        this.contaContabilSintetica = contaContabilSintetica; 
    } 
 
    /**
     * 
     * @param lancamento
     */ 
    @Transient 
    public void adicionarLancamentoDebito(Lancamento lancamento) 
    { 
        if (!this.getLancamentosDebito().contains(lancamento)) 
        { 
            this.lancamentosDebito.add(lancamento); 
            lancamento.adicionarContaDebito(this); 
        } 
    } 
 
    /**
     * 
     * @param lancamento
     */ 
    @Transient 
    public void adicionarLancamentoCredito(Lancamento lancamento) 
    { 
        if (!this.getLancamentosCredito().contains(lancamento)) 
        { 
            this.lancamentosCredito.add(lancamento); 
            lancamento.adicionarContaCredito(this); 
        } 
    } 
 
    /**
     * 
     * @param lancamento
     */ 
    @Transient 
    public void removerLancamentoDebito(Lancamento lancamento) 
    { 
        if (this.getLancamentosDebito().contains(lancamento)) 
        { 
            this.lancamentosDebito.remove(lancamento); 
            lancamento.removerContaDebito(this); 
        } 
    } 
 
    /**
     * 
     * @param lancamento
     */ 
    @Transient 
    public void removerLancamentoCredito(Lancamento lancamento) 
    { 
        if (this.getLancamentosCredito().contains(lancamento)) 
        { 
            this.lancamentosCredito.remove(lancamento); 
            lancamento.removerContaCredito(this); 
        } 
    } 
 
    /**
     * 
     * @param contaContabilSintetica
     */ 
    @Transient 
    public void adicionarContaContabilSintetica(ContaContabilSintetica contaContabilSintetica) 
    { 
        this.contaContabilSintetica = contaContabilSintetica; 
        contaContabilSintetica.adicionarContaContabilAnalitica(this); 
    } 
 
    /**
     * 
     * @param contaContabilSintetica
     */ 
    @Transient 
    public void removerContaContabilSintetica(ContaContabilSintetica contaContabilSintetica) 
    { 
        if (this.contaContabilSintetica.equals(contaContabilSintetica)) 
        { 
            this.contaContabilSintetica = null; 
            contaContabilSintetica.removerContaContabilAnalitica(this); 
        } 
    } 
 
    /**
     * Saldo total da conta contábil. Nas contas contábeis analíticas é a diferença
     * entre os lançamento de crédito e os de débito. Já nas contas contábies
     * sintéticas, o saldo, é o somatório dos saldos das contas contábeis analí ticas
     * pertencentes a esta conta.
     */ 
    @Transient 
    @Column(name="saldo", unique=FALSE, nullable=FALSE, insertable=TRUE, updatable=TRUE, precision=2) 
    public float getSaldo() 
    { 
        float saldo = 0; 
        //1 - recuperar o vetor de lançamentos de crédito e somar os valores doa lançamentos 
        //2 - recuperar o vetor de lançamentos de débito e somar os valores doa lançamentos 
        //3 - subtrair um resultado do outro (créditos - débitos) 
        return saldo; 
    } 
 
}

/**
* Os lançamentos contábes são feitos somente nas contas contábeis analíticas e na
* forma de partidas dobradas, ou seja, para cada lançamento de crédito existe um
* lançamento de débito correspondente. Na conta onde é feito o lançamento de
* crédito é chamada de conta de crédito e a conta que recebe o lançamento de
* débito tem o nome de conta de débito. Pode existir mais de uma conta de crédito
* e de débito no mesmo lançamento, contudo não podendo ser a mesma para o crédito
* e para o débito
* @author Marcelo Magalhães
* @version 1.0
* @created 31-jul-2010 01:45:53
*/ 
package modelo; 
 
import java.io.Serializable; 
import java.util.Date; 
import java.util.Calendar; 
import java.util.HashSet; 
import java.util.Set; 
 
import javax.persistence.Column; 
import javax.persistence.Entity; 
import javax.persistence.FetchType; 
import javax.persistence.GeneratedValue; 
import javax.persistence.GenerationType; 
import javax.persistence.Id; 
import javax.persistence.JoinColumn; 
import javax.persistence.JoinTable; 
import javax.persistence.ManyToMany; 
import javax.persistence.SequenceGenerator; 
import javax.persistence.Table; 
import javax.persistence.Temporal; 
import javax.persistence.TemporalType; 
import javax.persistence.Transient; 
 
import org.hibernate.annotations.Fetch; 
import org.hibernate.annotations.FetchMode; 
 
@Entity 
@Table(name="Lancamento") 
 
@SequenceGenerator(name="LANCAMENTO_SEQ", sequenceName="LANCAMENTO_SEQ", allocationSize=1) 
public class Lancamento implements Serializable   
{ 
 
    private static final long serialVersionUID = 1; 
    private static final boolean TRUE = true; 
    private static final boolean FALSE = false; 
    /**
     * Identificador da(s) conta(s) de débito do lançamento.
     */ 
    private Set<ContaContabilAnalitica> contasDebito; 
    /**
     * Identificador da(s) conta(s) de crédito do lançamento.
     */ 
    private Set<ContaContabilAnalitica> contasCredito; 
    /**
     * Identificador do lançamento. Sequence gerada pelo banco de dados.
     */ 
    private long lancamentoID; 
    /**
     * Data da cadastro do lançamento. O valor padrão é data corrente. Formato: yyyy-
     * mm-dd hh:mm:ss
     */ 
    private Calendar dataCadastro; 
    /**
     * Valor do lançamento
     */ 
    private float valor; 
    /**
     * Histórico ou descrição do lançamento
     */ 
    private String historico; 
 
    /**
     * Construtor padrão
     */ 
    public Lancamento() 
    { 
        this.dataCadastro = Calendar.getInstance(); 
        dataCadastro.setTime(new Date()); 
         
        this.contasDebito = new HashSet<ContaContabilAnalitica>(); 
        this.contasCredito = new HashSet<ContaContabilAnalitica>(); 
    } 
 
    /**
     * Construtor padrão com argumentos
     * 
     * @param lancamentoID
     * @param valor
     * @param historico
     * @param contasDebito
     * @param contasCredito
     */ 
    public Lancamento(long lancamentoID, float valor, String historico, Set<ContaContabilAnalitica> contasDebito, Set<ContaContabilAnalitica> contasCredito) 
    { 
        this.lancamentoID = lancamentoID; 
        this.valor = valor; 
        this.historico = historico; 
        this.contasDebito = contasDebito; 
        this.contasCredito = contasCredito; 
         
        this.dataCadastro = Calendar.getInstance(); 
        dataCadastro.setTime(new Date()); 
    } 
 
    @Id 
    @Column(name="lancamentoID", unique=TRUE, nullable=TRUE, insertable=TRUE, updatable=TRUE) 
    @GeneratedValue(strategy=GenerationType.SEQUENCE, generator="LANCAMENTO_SEQ") 
    public long getLancamentoID() 
    { 
        return this.lancamentoID; 
    } 
 
    @Temporal(TemporalType.TIMESTAMP) 
    @Column(name="dataCadastro", unique=FALSE, nullable=FALSE, insertable=TRUE, updatable=TRUE) 
    public Calendar getDataCadastro() 
    { 
        return this.dataCadastro; 
    } 
 
    @Column(name="valor", unique=FALSE, nullable=FALSE, insertable=TRUE, updatable=TRUE, length=255, precision=2) 
    public float getValor() 
    { 
        return this.valor; 
    } 
 
    @Column(name="historico", unique=FALSE, nullable=FALSE, insertable=TRUE, updatable=TRUE, length=255) 
    public String getHistorico() 
    { 
        return this.historico; 
    } 
 
    @ManyToMany(fetch=FetchType.LAZY) 
    @JoinTable(name="ContaDebitada", joinColumns = {@JoinColumn(name="lancamentoID")},inverseJoinColumns = {@JoinColumn(name="contaContabilAnaliticaID")}) 
    @Fetch(FetchMode.SELECT) 
    public Set<ContaContabilAnalitica> getContasDebito() 
    { 
        return this.contasDebito; 
    } 
 
    @ManyToMany(fetch=FetchType.LAZY) 
    @JoinTable(name="ContaCreditada", joinColumns = {@JoinColumn(name="lancamentoID")},inverseJoinColumns = {@JoinColumn(name="contaContabilAnaliticaID")}) 
    @Fetch(FetchMode.SELECT) 
    public Set<ContaContabilAnalitica> getContasCredito() 
    { 
        return this.contasCredito; 
    } 
 
    /**
     * 
     * @param lancamentoID
     */ 
    public void setLancamentoID(long lancamentoID) 
    { 
        this.lancamentoID = lancamentoID; 
    } 
 
    public void setDataCadastro(Calendar data) 
    {         
        this.dataCadastro = data; 
    } 
 
    /**
     * 
     * @param valor
     */ 
    public void setValor(float valor) 
    { 
        this.valor = valor; 
    } 
 
    /**
     * 
     * @param historico
     */ 
    public void setHistorico(String historico) 
    { 
        this.historico = historico; 
    } 
 
    /**
     * 
     * @param contasDebito
     */ 
    public void setContasDebito(Set<ContaContabilAnalitica> contasDebito) 
    { 
        this.contasDebito = contasDebito; 
    } 
 
    /**
     * 
     * @param contasCredito
     */ 
    public void setContasCredito(Set<ContaContabilAnalitica> contasCredito) 
    { 
        this.contasCredito = contasCredito; 
    } 
 
    /**
     * 
     * @param contaDebito
     */ 
    @Transient 
    public void adicionarContaDebito(ContaContabilAnalitica contaDebito) 
    { 
        if (!this.getContasDebito().contains(contaDebito)) 
        { 
            this.contasDebito.add(contaDebito); 
            contaDebito.adicionarLancamentoDebito(this); 
        } 
    } 
 
    /**
     * 
     * @param contaCredito
     */ 
    @Transient 
    public void adicionarContaCredito(ContaContabilAnalitica contaCredito) 
    { 
        if (!this.getContasCredito().contains(contaCredito)) 
        { 
            this.contasCredito.add(contaCredito); 
            contaCredito.adicionarLancamentoCredito(this); 
        } 
    } 
 
    /**
     * 
     * @param contaDebito
     */ 
    @Transient 
    public void removerContaDebito(ContaContabilAnalitica contaDebito) 
    { 
        if (!this.getContasDebito().contains(contaDebito)) 
        { 
            this.contasDebito.remove(contaDebito); 
            contaDebito.removerLancamentoDebito(this); 
        }   
    } 
 
    /**
     * 
     * @param contaCredito
     */ 
    @Transient 
    public void removerContaCredito(ContaContabilAnalitica contaCredito) 
    { 
        if (!this.getContasCredito().contains(contaCredito)) 
        { 
            this.contasCredito.remove(contaCredito); 
            contaCredito.removerLancamentoCredito(this); 
        }   
    } 
}