Author: Bavencoff Date: 2013-06-27 15:08:13 +0200 (Thu, 27 Jun 2013) New Revision: 3687 Url: http://chorem.org/projects/lima/repository/revisions/3687 Log: Classes d?\195?\169ffinissants les filtres sur les entit?\195?\169s m?\195?\169tiers Added: trunk/lima-callao/src/main/java/org/chorem/lima/Clause/ trunk/lima-callao/src/main/java/org/chorem/lima/Clause/AndClause.java trunk/lima-callao/src/main/java/org/chorem/lima/Clause/BooleanClause.java trunk/lima-callao/src/main/java/org/chorem/lima/Clause/Clause.java trunk/lima-callao/src/main/java/org/chorem/lima/Clause/DateClause.java trunk/lima-callao/src/main/java/org/chorem/lima/Clause/NotClause.java trunk/lima-callao/src/main/java/org/chorem/lima/Clause/NumberClause.java trunk/lima-callao/src/main/java/org/chorem/lima/Clause/OrClause.java trunk/lima-callao/src/main/java/org/chorem/lima/Clause/SetClause.java trunk/lima-callao/src/main/java/org/chorem/lima/Clause/StringClause.java trunk/lima-callao/src/main/java/org/chorem/lima/Clause/SubFilterClause.java trunk/lima-callao/src/main/java/org/chorem/lima/Clause/VisitorClause.java trunk/lima-callao/src/main/java/org/chorem/lima/Filter/ trunk/lima-callao/src/main/java/org/chorem/lima/Filter/AbstractFilter.java trunk/lima-callao/src/main/java/org/chorem/lima/Filter/AccountFilter.java trunk/lima-callao/src/main/java/org/chorem/lima/Filter/EntryBookFilter.java trunk/lima-callao/src/main/java/org/chorem/lima/Filter/EntryFilter.java trunk/lima-callao/src/main/java/org/chorem/lima/Filter/Filter.java trunk/lima-callao/src/main/java/org/chorem/lima/Filter/FilterGenerator.java trunk/lima-callao/src/main/java/org/chorem/lima/Filter/FinancialTransactionFilter.java trunk/lima-callao/src/main/java/org/chorem/lima/Filter/VisitorFilter.java Added: trunk/lima-callao/src/main/java/org/chorem/lima/Clause/AndClause.java =================================================================== --- trunk/lima-callao/src/main/java/org/chorem/lima/Clause/AndClause.java (rev 0) +++ trunk/lima-callao/src/main/java/org/chorem/lima/Clause/AndClause.java 2013-06-27 13:08:13 UTC (rev 3687) @@ -0,0 +1,14 @@ +package org.chorem.lima.Clause; + +import java.util.ArrayList; + +/** + * @author Sylvain Bavencoff <bavencoff@codelutin.com> + */ +public class AndClause extends ArrayList<Clause> implements Clause { + + @Override + public void accept(VisitorClause v) { + v.visitAndClause(this); + } +} Added: trunk/lima-callao/src/main/java/org/chorem/lima/Clause/BooleanClause.java =================================================================== --- trunk/lima-callao/src/main/java/org/chorem/lima/Clause/BooleanClause.java (rev 0) +++ trunk/lima-callao/src/main/java/org/chorem/lima/Clause/BooleanClause.java 2013-06-27 13:08:13 UTC (rev 3687) @@ -0,0 +1,26 @@ +package org.chorem.lima.Clause; + +/** + * @author Sylvain Bavencoff <bavencoff@codelutin.com> + */ +public class BooleanClause implements Clause { + + protected String property; + + public BooleanClause(String property) { + this.property = property; + } + + public String getProperty() { + return property; + } + + public void setProperty(String property) { + this.property = property; + } + + @Override + public void accept(VisitorClause v) { + v.visitBooleanClause(this); + } +} Added: trunk/lima-callao/src/main/java/org/chorem/lima/Clause/Clause.java =================================================================== --- trunk/lima-callao/src/main/java/org/chorem/lima/Clause/Clause.java (rev 0) +++ trunk/lima-callao/src/main/java/org/chorem/lima/Clause/Clause.java 2013-06-27 13:08:13 UTC (rev 3687) @@ -0,0 +1,11 @@ +package org.chorem.lima.Clause; + +/** + * @author Sylvain Bavencoff <bavencoff@codelutin.com> + */ +public interface Clause { + + public void accept(VisitorClause v); + + +} Added: trunk/lima-callao/src/main/java/org/chorem/lima/Clause/DateClause.java =================================================================== --- trunk/lima-callao/src/main/java/org/chorem/lima/Clause/DateClause.java (rev 0) +++ trunk/lima-callao/src/main/java/org/chorem/lima/Clause/DateClause.java 2013-06-27 13:08:13 UTC (rev 3687) @@ -0,0 +1,57 @@ +package org.chorem.lima.Clause; + +import java.util.Date; + +/** + * @author Sylvain Bavencoff <bavencoff@codelutin.com> + */ +public class DateClause implements Clause { + + protected String property; + + protected Date value; + + protected Operand operand; + + public DateClause(String property) { + this.property = property; + operand = Operand.SAME; + } + + public String getProperty() { + return property; + } + + public void setProperty(String property) { + this.property = property; + } + + public Date getValue() { + return value; + } + + public void setValue(Date value) { + this.value = value; + } + + public Operand getOperand() { + return operand; + } + + public void setOperand(Operand operand) { + this.operand = operand; + } + + @Override + public void accept(VisitorClause v) { + v.visitDateClause(this); + } + + public enum Operand { + SAME, + AFTER, + PREVIOUS, + DIFFERENT; + } + +} Added: trunk/lima-callao/src/main/java/org/chorem/lima/Clause/NotClause.java =================================================================== --- trunk/lima-callao/src/main/java/org/chorem/lima/Clause/NotClause.java (rev 0) +++ trunk/lima-callao/src/main/java/org/chorem/lima/Clause/NotClause.java 2013-06-27 13:08:13 UTC (rev 3687) @@ -0,0 +1,22 @@ +package org.chorem.lima.Clause; + +/** + * @author Sylvain Bavencoff <bavencoff@codelutin.com> + */ +public class NotClause implements Clause { + + protected Clause clause; + + @Override + public void accept(VisitorClause v) { + v.visitNotClause(this); + } + + public Clause getClause() { + return clause; + } + + public void setClause(Clause clause) { + this.clause = clause; + } +} Added: trunk/lima-callao/src/main/java/org/chorem/lima/Clause/NumberClause.java =================================================================== --- trunk/lima-callao/src/main/java/org/chorem/lima/Clause/NumberClause.java (rev 0) +++ trunk/lima-callao/src/main/java/org/chorem/lima/Clause/NumberClause.java 2013-06-27 13:08:13 UTC (rev 3687) @@ -0,0 +1,56 @@ +package org.chorem.lima.Clause; + +/** + * @author Sylvain Bavencoff <bavencoff@codelutin.com> + */ +public class NumberClause implements Clause { + + protected String property; + + protected Operand operand; + + protected Number value; + + public NumberClause(String property) { + this.property = property; + setOperand(Operand.EQUAL); + } + + public String getProperty() { + return property; + } + + public void setProperty(String property) { + this.property = property; + } + + public Operand getOperand() { + return operand; + } + + public void setOperand(Operand operand) { + this.operand = operand; + } + + public Number getValue() { + return value; + } + + public void setValue(Number value) { + this.value = value; + } + + @Override + public void accept(VisitorClause v) { + v.visitNumberClause(this); + } + + public enum Operand { + EQUAL, + NOT_EQUAL, + UPPER, + UPPER_OR_EQUAL, + LOWER, + LOWER_OR_EQUAL; + } +} Added: trunk/lima-callao/src/main/java/org/chorem/lima/Clause/OrClause.java =================================================================== --- trunk/lima-callao/src/main/java/org/chorem/lima/Clause/OrClause.java (rev 0) +++ trunk/lima-callao/src/main/java/org/chorem/lima/Clause/OrClause.java 2013-06-27 13:08:13 UTC (rev 3687) @@ -0,0 +1,13 @@ +package org.chorem.lima.Clause; + +import java.util.ArrayList; + +/** + * @author Sylvain Bavencoff <bavencoff@codelutin.com> + */ +public class OrClause extends ArrayList<Clause> implements Clause { + @Override + public void accept(VisitorClause v) { + v.visitOrClause(this); + } +} Added: trunk/lima-callao/src/main/java/org/chorem/lima/Clause/SetClause.java =================================================================== --- trunk/lima-callao/src/main/java/org/chorem/lima/Clause/SetClause.java (rev 0) +++ trunk/lima-callao/src/main/java/org/chorem/lima/Clause/SetClause.java 2013-06-27 13:08:13 UTC (rev 3687) @@ -0,0 +1,46 @@ +package org.chorem.lima.Clause; + +import java.util.HashSet; + +/** + * @author Sylvain Bavencoff <bavencoff@codelutin.com> + */ +public class SetClause<T> extends HashSet<T> implements Clause { + + protected String property; + + protected Operand operand; + + public SetClause(String property) { + this.property = property; + setOperand(Operand.IN); + } + + public String getProperty() { + return property; + } + + public void setProperty(String property) { + this.property = property; + } + + public Operand getOperand() { + return operand; + } + + public void setOperand(Operand operand) { + this.operand = operand; + } + + @Override + public void accept(VisitorClause v) { + v.visitSetClause(this); + } + + public enum Operand { + IN, + NOT_IN; + } + + +} Added: trunk/lima-callao/src/main/java/org/chorem/lima/Clause/StringClause.java =================================================================== --- trunk/lima-callao/src/main/java/org/chorem/lima/Clause/StringClause.java (rev 0) +++ trunk/lima-callao/src/main/java/org/chorem/lima/Clause/StringClause.java 2013-06-27 13:08:13 UTC (rev 3687) @@ -0,0 +1,66 @@ +package org.chorem.lima.Clause; + +/** + * @author Sylvain Bavencoff <bavencoff@codelutin.com> + */ +public class StringClause implements Clause { + + protected String property; + + protected Operand operand; + + protected String value; + + protected boolean sensitiveCase; + + public StringClause(String property) { + this.property = property; + setOperand(Operand.EQUAL); + setSensitiveCase(true); + } + + public String getProperty() { + return property; + } + + public void setProperty(String property) { + this.property = property; + } + + public Operand getOperand() { + return operand; + } + + public void setOperand(Operand operand) { + this.operand = operand; + } + + public String getValue() { + return value; + } + + public void setValue(String value) { + this.value = value; + } + + public boolean isSensitiveCase() { + return sensitiveCase; + } + + public void setSensitiveCase(boolean sensitiveCase) { + this.sensitiveCase = sensitiveCase; + } + + @Override + public void accept(VisitorClause v) { + v.visitStringClause(this); + } + + public enum Operand { + EQUAL, + NOT_EQUAL, + BEGIN, + ENDING, + CONTAIN; + } +} Added: trunk/lima-callao/src/main/java/org/chorem/lima/Clause/SubFilterClause.java =================================================================== --- trunk/lima-callao/src/main/java/org/chorem/lima/Clause/SubFilterClause.java (rev 0) +++ trunk/lima-callao/src/main/java/org/chorem/lima/Clause/SubFilterClause.java 2013-06-27 13:08:13 UTC (rev 3687) @@ -0,0 +1,56 @@ +package org.chorem.lima.Clause; + +import org.chorem.lima.Filter.Filter; + +/** + * @author Sylvain Bavencoff <bavencoff@codelutin.com> + */ +public class SubFilterClause implements Clause { + + protected String property; + + protected Multiplicity multiplicity; + + protected Filter subFilter; + + public SubFilterClause(String property, Filter subFilter, Multiplicity multiplicity) { + this.property = property; + this.subFilter = subFilter; + this.multiplicity = multiplicity; + } + + public String getProperty() { + return property; + } + + public void setProperty(String property) { + this.property = property; + } + + public Filter getSubFilter() { + return subFilter; + } + + public void setSubFilter(Filter subFilter) { + this.subFilter = subFilter; + } + + @Override + public void accept(VisitorClause v) { + v.visitSubFilterClause(this); + } + + public Multiplicity getMultiplicity() { + return multiplicity; + } + + public void setMultiplicity(Multiplicity multiplicity) { + this.multiplicity = multiplicity; + } + + public enum Multiplicity { + ONE, + MANY; + } + +} Added: trunk/lima-callao/src/main/java/org/chorem/lima/Clause/VisitorClause.java =================================================================== --- trunk/lima-callao/src/main/java/org/chorem/lima/Clause/VisitorClause.java (rev 0) +++ trunk/lima-callao/src/main/java/org/chorem/lima/Clause/VisitorClause.java 2013-06-27 13:08:13 UTC (rev 3687) @@ -0,0 +1,25 @@ +package org.chorem.lima.Clause; + +/** + * @author Sylvain Bavencoff <bavencoff@codelutin.com> + */ +public interface VisitorClause { + + public void visitDateClause(DateClause dateClause); + + public void visitAndClause(AndClause andClause); + + public void visitBooleanClause(BooleanClause booleanClause); + + public void visitNumberClause(NumberClause numberClause); + + public void visitOrClause(OrClause orClause); + + public void visitNotClause(NotClause notClause); + + public void visitSetClause(SetClause setClause); + + public void visitStringClause(StringClause stringClause); + + public void visitSubFilterClause(SubFilterClause subFilterClause); +} Added: trunk/lima-callao/src/main/java/org/chorem/lima/Filter/AbstractFilter.java =================================================================== --- trunk/lima-callao/src/main/java/org/chorem/lima/Filter/AbstractFilter.java (rev 0) +++ trunk/lima-callao/src/main/java/org/chorem/lima/Filter/AbstractFilter.java 2013-06-27 13:08:13 UTC (rev 3687) @@ -0,0 +1,19 @@ +package org.chorem.lima.Filter; + +import org.chorem.lima.Clause.Clause; + +/** + * @author Sylvain Bavencoff <bavencoff@codelutin.com> + */ +public abstract class AbstractFilter implements Filter { + + protected Clause clause; + + public Clause getClause() { + return clause; + } + + public void setClause(Clause clause) { + this.clause = clause; + } +} Added: trunk/lima-callao/src/main/java/org/chorem/lima/Filter/AccountFilter.java =================================================================== --- trunk/lima-callao/src/main/java/org/chorem/lima/Filter/AccountFilter.java (rev 0) +++ trunk/lima-callao/src/main/java/org/chorem/lima/Filter/AccountFilter.java 2013-06-27 13:08:13 UTC (rev 3687) @@ -0,0 +1,33 @@ +package org.chorem.lima.Filter; + +import org.chorem.lima.Clause.StringClause; +import org.chorem.lima.entity.Account; + +/** + * @author Sylvain Bavencoff <bavencoff@codelutin.com> + */ +public class AccountFilter extends AbstractFilter { + + public StringClause newLabelClause() { + return new StringClause(Account.PROPERTY_LABEL); + } + + public StringClause newAccountNumberClause() { + return new StringClause(Account.PROPERTY_ACCOUNT_NUMBER); + } + + public StringClause newThirdPartyClause() { + return new StringClause(Account.PROPERTY_THIRD_PARTY); + } + + + @Override + public void accept(VisitorFilter v) { + v.visitAccountFilter(this); + } + + @Override + public Class getEntityClass() { + return Account.class; + } +} Added: trunk/lima-callao/src/main/java/org/chorem/lima/Filter/EntryBookFilter.java =================================================================== --- trunk/lima-callao/src/main/java/org/chorem/lima/Filter/EntryBookFilter.java (rev 0) +++ trunk/lima-callao/src/main/java/org/chorem/lima/Filter/EntryBookFilter.java 2013-06-27 13:08:13 UTC (rev 3687) @@ -0,0 +1,29 @@ +package org.chorem.lima.Filter; + +import org.chorem.lima.Clause.StringClause; +import org.chorem.lima.entity.EntryBook; + +/** + * @author Sylvain Bavencoff <bavencoff@codelutin.com> + */ +public class EntryBookFilter extends AbstractFilter { + + public StringClause newLabelClause() { + return new StringClause(EntryBook.PROPERTY_LABEL); + } + + public StringClause newCodeClause() { + return new StringClause(EntryBook.PROPERTY_CODE); + } + + @Override + public void accept(VisitorFilter v) { + v.visitEntryBookFilter(this); + } + + @Override + public Class getEntityClass() { + return EntryBook.class; + } + +} Added: trunk/lima-callao/src/main/java/org/chorem/lima/Filter/EntryFilter.java =================================================================== --- trunk/lima-callao/src/main/java/org/chorem/lima/Filter/EntryFilter.java (rev 0) +++ trunk/lima-callao/src/main/java/org/chorem/lima/Filter/EntryFilter.java 2013-06-27 13:08:13 UTC (rev 3687) @@ -0,0 +1,68 @@ +package org.chorem.lima.Filter; + +import org.chorem.lima.Clause.BooleanClause; +import org.chorem.lima.Clause.NumberClause; +import org.chorem.lima.Clause.SetClause; +import org.chorem.lima.Clause.StringClause; +import org.chorem.lima.Clause.SubFilterClause; +import org.chorem.lima.entity.Entry; + +/** + * @author Sylvain Bavencoff <bavencoff@codelutin.com> + */ +public class EntryFilter extends AbstractFilter { + + public NumberClause newAmountClause() { + return new NumberClause(Entry.PROPERTY_AMOUNT); + } + + public BooleanClause newDebitClause() { + return new BooleanClause(Entry.PROPERTY_DEBIT); + } + + public StringClause newDetailClause() { + return new StringClause(Entry.PROPERTY_AMOUNT); + } + + public StringClause newPositionClause() { + return new StringClause(Entry.PROPERTY_POSITION); + } + + public StringClause newVoucherClause() { + return new StringClause(Entry.PROPERTY_VOUCHER); + } + + public StringClause newDescriptionClause() { + return new StringClause(Entry.PROPERTY_DESCRIPTION); + } + + public StringClause newLetteringClause() { + return new StringClause(Entry.PROPERTY_LETTERING); + } + + public SubFilterClause newAccountFilterClause() { + return new SubFilterClause(Entry.PROPERTY_ACCOUNT, new AccountFilter(), SubFilterClause.Multiplicity.ONE); + } + + public SetClause newAccountSetClause() { + return new SetClause(Entry.PROPERTY_ACCOUNT); + } + + public SubFilterClause newFinancialTransactionFilterClause() { + return new SubFilterClause(Entry.PROPERTY_FINANCIAL_TRANSACTION, new FinancialTransactionFilter(), SubFilterClause.Multiplicity.ONE); + } + + public SetClause newFinancialTransactionSetClause() { + return new SetClause(Entry.PROPERTY_FINANCIAL_TRANSACTION); + } + + @Override + public void accept(VisitorFilter v) { + v.visitEntryFilter(this); + } + + @Override + public Class getEntityClass() { + return Entry.class; + } +} Added: trunk/lima-callao/src/main/java/org/chorem/lima/Filter/Filter.java =================================================================== --- trunk/lima-callao/src/main/java/org/chorem/lima/Filter/Filter.java (rev 0) +++ trunk/lima-callao/src/main/java/org/chorem/lima/Filter/Filter.java 2013-06-27 13:08:13 UTC (rev 3687) @@ -0,0 +1,16 @@ +package org.chorem.lima.Filter; + +import org.chorem.lima.Clause.Clause; + +/** + * @author Sylvain Bavencoff <bavencoff@codelutin.com> + */ +public interface Filter { + + public void accept(VisitorFilter v); + + public Clause getClause(); + + public Class getEntityClass(); + +} Added: trunk/lima-callao/src/main/java/org/chorem/lima/Filter/FilterGenerator.java =================================================================== --- trunk/lima-callao/src/main/java/org/chorem/lima/Filter/FilterGenerator.java (rev 0) +++ trunk/lima-callao/src/main/java/org/chorem/lima/Filter/FilterGenerator.java 2013-06-27 13:08:13 UTC (rev 3687) @@ -0,0 +1,351 @@ +package org.chorem.lima.Filter; + +import org.chorem.lima.Clause.AndClause; +import org.chorem.lima.Clause.BooleanClause; +import org.chorem.lima.Clause.Clause; +import org.chorem.lima.Clause.DateClause; +import org.chorem.lima.Clause.NotClause; +import org.chorem.lima.Clause.NumberClause; +import org.chorem.lima.Clause.OrClause; +import org.chorem.lima.Clause.SetClause; +import org.chorem.lima.Clause.StringClause; +import org.chorem.lima.Clause.SubFilterClause; +import org.chorem.lima.beans.AbstractBigDecimalCondition; +import org.chorem.lima.beans.AbstractStringCondition; +import org.chorem.lima.beans.AccountCondition; +import org.chorem.lima.beans.Condition; +import org.chorem.lima.beans.CreditCondition; +import org.chorem.lima.beans.DateCondition; +import org.chorem.lima.beans.DateIntervalCondition; +import org.chorem.lima.beans.DebitCondition; +import org.chorem.lima.beans.DescriptionCondition; +import org.chorem.lima.beans.EntryBookCondition; +import org.chorem.lima.beans.FinancialPeriodCondition; +import org.chorem.lima.beans.FinancialTransactionCondition; +import org.chorem.lima.beans.FiscalPeriodCondition; +import org.chorem.lima.beans.LetteringCondition; +import org.chorem.lima.beans.VisitorCondition; +import org.chorem.lima.beans.VoucherCondition; +import org.chorem.lima.entity.Account; +import org.chorem.lima.entity.FinancialPeriod; +import org.chorem.lima.entity.FiscalPeriod; + +import java.util.ArrayList; +import java.util.List; + +/** + * @author Sylvain Bavencoff <bavencoff@codelutin.com> + */ +public class FilterGenerator implements VisitorCondition { + + protected List<Clause> clauses; + protected List<Clause> entryClauses; + protected FinancialTransactionFilter filter; + protected EntryFilter entryFilter; + + public FilterGenerator() { + clauses = new ArrayList<Clause>(); + entryClauses = new ArrayList<Clause>(); + } + + + @Override + public void visitFinancialTransactionCondition(FinancialTransactionCondition condition) { + + filter = new FinancialTransactionFilter(); + for (Condition subCondition : condition.getConditions()) { + subCondition.accept(this); + } + if (clauses.size() == 1 ) { + filter.setClause(clauses.get(0)); + } else if (clauses.size() > 1) { + if (condition.isAllConditions()) { + AndClause clause = new AndClause(); + clause.addAll(clauses); + filter.setClause(clause); + } else { + OrClause clause = new OrClause(); + clause.addAll(clauses); + filter.setClause(clause); + } + } + + if (entryClauses.size() == 1 ) { + entryFilter.setClause(entryClauses.get(0)); + } else if (entryClauses.size() > 1) { + if (condition.isAllConditions()) { + AndClause clause = new AndClause(); + clause.addAll(entryClauses); + entryFilter.setClause(clause); + } else { + OrClause clause = new OrClause(); + clause.addAll(entryClauses); + entryFilter.setClause(clause); + } + } + } + + @Override + public void visitDateCondition(DateCondition condition) { + DateClause dateClause = getFilter().newTransactionDateClause(); + switch (condition.getOperand()) { + case SAME: + dateClause.setOperand(DateClause.Operand.SAME); + break; + case AFTER: + dateClause.setOperand(DateClause.Operand.AFTER); + break; + case PREVIOUS: + dateClause.setOperand(DateClause.Operand.PREVIOUS); + break; + case DIFFERENT: + dateClause.setOperand(DateClause.Operand.DIFFERENT); + break; + } + dateClause.setValue(condition.getDate()); + clauses.add(dateClause); + } + + @Override + public void visitDateIntervalCondition(DateIntervalCondition condition) { + AndClause andClause = new AndClause(); + + DateClause beginDateClause = getFilter().newTransactionDateClause(); + beginDateClause.setOperand(DateClause.Operand.AFTER); + beginDateClause.setValue(condition.getBeginDate()); + andClause.add(beginDateClause); + + DateClause endDateClause = getFilter().newTransactionDateClause(); + endDateClause.setOperand(DateClause.Operand.PREVIOUS); + endDateClause.setValue(condition.getEndDate()); + andClause.add(endDateClause); + + clauses.add(andClause); + } + + @Override + public void visitEntryBookCondition(EntryBookCondition condition) { + + SetClause setClause = getFilter().newEntryBookSetClause(); + setClause.addAll(condition.getEntryBooks()); + clauses.add(setClause); + } + + @Override + public void visitFinancialPeriodCondition(FinancialPeriodCondition condition) { + OrClause orClause = new OrClause(); + for (FinancialPeriod period : condition.getFinancialPeriods()) { + AndClause andClause = new AndClause(); + + DateClause beginDateClause = getFilter().newTransactionDateClause(); + beginDateClause.setOperand(DateClause.Operand.AFTER); + beginDateClause.setValue(period.getBeginDate()); + andClause.add(beginDateClause); + + DateClause endDateClause = getFilter().newTransactionDateClause(); + endDateClause.setOperand(DateClause.Operand.PREVIOUS); + endDateClause.setValue(period.getEndDate()); + andClause.add(endDateClause); + + orClause.add(andClause); + } + if (orClause.size() == 1) { + clauses.add(orClause.get(0)); + } else { + clauses.add(orClause); + } + } + + @Override + public void visitFiscalPeriodCondition(FiscalPeriodCondition condition) { + OrClause orClause = new OrClause(); + for (FiscalPeriod period : condition.getFiscalPeriods()) { + AndClause andClause = new AndClause(); + + DateClause beginDateClause = getFilter().newTransactionDateClause(); + beginDateClause.setOperand(DateClause.Operand.AFTER); + beginDateClause.setValue(period.getBeginDate()); + andClause.add(beginDateClause); + + DateClause endDateClause = getFilter().newTransactionDateClause(); + endDateClause.setOperand(DateClause.Operand.PREVIOUS); + endDateClause.setValue(period.getEndDate()); + andClause.add(endDateClause); + + orClause.add(andClause); + } + if (orClause.size() == 1) { + clauses.add(orClause.get(0)); + } else { + clauses.add(orClause); + } + } + + protected EntryFilter getEntryFilter() { + if (entryFilter == null) { + SubFilterClause subFilterClause = filter.newEntryFilterClause(); + clauses.add(subFilterClause); + entryFilter = (EntryFilter) subFilterClause.getSubFilter(); + } + return entryFilter; + } + + protected StringClause.Operand getStringClauseOperand(AbstractStringCondition.Operand operand) { + StringClause.Operand result; + switch (operand) { + case NOT_EQUAL: + result = StringClause.Operand.NOT_EQUAL; + break; + case BEGIN: + result = StringClause.Operand.BEGIN; + break; + case ENDING: + result = StringClause.Operand.ENDING; + break; + case CONTAIN: + result = StringClause.Operand.CONTAIN; + break; + case EQUAL: + default: + result = StringClause.Operand.EQUAL; + break; + } + return result; + } + + @Override + public void visitDescriptionCondition(DescriptionCondition descriptionCondition) { + getEntryFilter(); + StringClause stringClause = entryFilter.newDescriptionClause(); + + AbstractStringCondition.Operand operand = descriptionCondition.getOperand(); + StringClause.Operand stringClauseOperand = getStringClauseOperand(operand); + stringClause.setOperand(stringClauseOperand); + + stringClause.setValue(descriptionCondition.getValue()); + + stringClause.setSensitiveCase(descriptionCondition.isSensitiveCase()); + + entryClauses.add(stringClause); + } + + @Override + public void visitVoucherCondition(VoucherCondition voucherCondition) { + getEntryFilter(); + StringClause stringClause = entryFilter.newVoucherClause(); + + AbstractStringCondition.Operand operand = voucherCondition.getOperand(); + StringClause.Operand stringClauseOperand = getStringClauseOperand(operand); + stringClause.setOperand(stringClauseOperand); + + stringClause.setValue(voucherCondition.getValue()); + + stringClause.setSensitiveCase(voucherCondition.isSensitiveCase()); + + entryClauses.add(stringClause); + } + + @Override + public void visitLetteringCondition(LetteringCondition letteringCondition) { + getEntryFilter(); + StringClause stringClause = entryFilter.newLetteringClause(); + + AbstractStringCondition.Operand operand = letteringCondition.getOperand(); + StringClause.Operand stringClauseOperand = getStringClauseOperand(operand); + stringClause.setOperand(stringClauseOperand); + + stringClause.setValue(letteringCondition.getValue()); + + stringClause.setSensitiveCase(letteringCondition.isSensitiveCase()); + + entryClauses.add(stringClause); + } + + @Override + public void visitAccountCondition(AccountCondition accountCondition) { + getEntryFilter(); + SubFilterClause subFilterClause = entryFilter.newAccountFilterClause(); + AccountFilter accountFilter = (AccountFilter) subFilterClause.getSubFilter(); + StringClause stringClause = accountFilter.newAccountNumberClause(); + stringClause.setOperand(StringClause.Operand.BEGIN); + Account account = accountCondition.getAccount(); + stringClause.setValue(account.getAccountNumber()); + + accountFilter.setClause(stringClause); + entryClauses.add(subFilterClause); + } + + protected NumberClause.Operand getNumberClauseOperand(AbstractBigDecimalCondition.Operand operand) { + NumberClause.Operand result; + switch (operand) { + case NOT_EQUAL: + result = NumberClause.Operand.NOT_EQUAL; + break; + case LOWER: + result = NumberClause.Operand.LOWER; + break; + case LOWER_OR_EQUAL: + result = NumberClause.Operand.LOWER_OR_EQUAL; + break; + case UPPER: + result = NumberClause.Operand.UPPER; + break; + case UPPER_OR_EQUAL: + result = NumberClause.Operand.UPPER_OR_EQUAL; + break; + case EQUAL: + default: + result = NumberClause.Operand.EQUAL; + break; + } + return result; + } + + @Override + public void visitDebitCondition(DebitCondition debitCondition) { + getEntryFilter(); + + BooleanClause debitClause = entryFilter.newDebitClause(); + + NumberClause amountClause = entryFilter.newAmountClause(); + + AbstractBigDecimalCondition.Operand operand = debitCondition.getOperand(); + NumberClause.Operand clauseOperand = getNumberClauseOperand(operand); + amountClause.setOperand(clauseOperand); + + amountClause.setValue(debitCondition.getValue()); + + AndClause andClause = new AndClause(); + andClause.add(debitClause); + andClause.add(amountClause); + + entryClauses.add(andClause); + } + + @Override + public void visitCreditCondition(CreditCondition creditCondition) { + getEntryFilter(); + + BooleanClause debitClause = entryFilter.newDebitClause(); + NotClause creditClause = new NotClause(); + creditClause.setClause(debitClause); + + NumberClause amountClause = entryFilter.newAmountClause(); + + AbstractBigDecimalCondition.Operand operand = creditCondition.getOperand(); + NumberClause.Operand clauseOperand = getNumberClauseOperand(operand); + amountClause.setOperand(clauseOperand); + + amountClause.setValue(creditCondition.getValue()); + + AndClause andClause = new AndClause(); + andClause.add(creditClause); + andClause.add(amountClause); + + entryClauses.add(andClause); + } + + public FinancialTransactionFilter getFilter() { + return filter; + } +} Added: trunk/lima-callao/src/main/java/org/chorem/lima/Filter/FinancialTransactionFilter.java =================================================================== --- trunk/lima-callao/src/main/java/org/chorem/lima/Filter/FinancialTransactionFilter.java (rev 0) +++ trunk/lima-callao/src/main/java/org/chorem/lima/Filter/FinancialTransactionFilter.java 2013-06-27 13:08:13 UTC (rev 3687) @@ -0,0 +1,38 @@ +package org.chorem.lima.Filter; + +import org.chorem.lima.Clause.DateClause; +import org.chorem.lima.Clause.SetClause; +import org.chorem.lima.Clause.SubFilterClause; +import org.chorem.lima.entity.FinancialTransaction; + +/** + * @author Sylvain Bavencoff <bavencoff@codelutin.com> + */ +public class FinancialTransactionFilter extends AbstractFilter { + + public DateClause newTransactionDateClause() { + return new DateClause(FinancialTransaction.PROPERTY_TRANSACTION_DATE); + } + + public SubFilterClause newEntryBookFilterClause() { + return new SubFilterClause(FinancialTransaction.PROPERTY_ENTRY_BOOK, new EntryBookFilter(), SubFilterClause.Multiplicity.ONE); + } + + public SetClause newEntryBookSetClause() { + return new SetClause(FinancialTransaction.PROPERTY_ENTRY_BOOK); + } + + public SubFilterClause newEntryFilterClause () { + return new SubFilterClause(FinancialTransaction.PROPERTY_ENTRY, new EntryFilter(), SubFilterClause.Multiplicity.MANY); + } + + @Override + public void accept(VisitorFilter v) { + v.visitFinancialTransactionFilter(this); + } + + @Override + public Class getEntityClass() { + return FinancialTransaction.class; + } +} Added: trunk/lima-callao/src/main/java/org/chorem/lima/Filter/VisitorFilter.java =================================================================== --- trunk/lima-callao/src/main/java/org/chorem/lima/Filter/VisitorFilter.java (rev 0) +++ trunk/lima-callao/src/main/java/org/chorem/lima/Filter/VisitorFilter.java 2013-06-27 13:08:13 UTC (rev 3687) @@ -0,0 +1,15 @@ +package org.chorem.lima.Filter; + +/** + * @author Sylvain Bavencoff <bavencoff@codelutin.com> + */ +public interface VisitorFilter { + + public void visitAccountFilter(AccountFilter accountFilter); + + public void visitEntryBookFilter(EntryBookFilter entryBookFilter); + + public void visitEntryFilter(EntryFilter entryFilter); + + public void visitFinancialTransactionFilter(FinancialTransactionFilter financialTransactionFilter); +}