Author: echatellier Date: 2010-05-12 17:08:48 +0200 (Wed, 12 May 2010) New Revision: 53 Url: http://nuiton.org/repositories/revision/wikitty/53 Log: Refactor package name to org.nuiton Added: trunk/wikitty-api/src/main/java/org/nuiton/ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/AbstractWikittyService.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/BusinessEntity.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/BusinessEntityBean.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/BusinessEntityWikitty.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/Criteria.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/ExtensionFactory.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/FacetTopic.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/FieldFactory.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/FieldType.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/JobState.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/Package.html trunk/wikitty-api/src/main/java/org/nuiton/wikitty/PagedResult.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/Tree.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/UpdateResponse.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/Wikitty.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyDAO.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyException.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyExtension.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyExtensionMigration.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyExtensionMigrationRename.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyExtensionStorage.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyProxy.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittySearchEngin.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyService.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyServiceInMemory.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyStorage.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyTransaction.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyUtil.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/ trunk/wikitty-api/src/main/resources/org/nuiton/ trunk/wikitty-api/src/test/java/org/nuiton/ trunk/wikitty-api/src/test/java/org/nuiton/wikitty/ trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/ trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/api/ trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/conform/ trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/memory/ trunk/wikitty-generators/src/main/java/org/nuiton/ trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/ trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/ trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/BusinessEntityBeanGenerator.java trunk/wikitty-hbase-impl/src/main/java/org/nuiton/ trunk/wikitty-hbase-impl/src/main/java/org/nuiton/wikitty/ trunk/wikitty-hbase-impl/src/main/java/org/nuiton/wikitty/hbase/ trunk/wikitty-hbase-impl/src/test/java/org/nuiton/ trunk/wikitty-hbase-impl/src/test/java/org/nuiton/wikitty/ trunk/wikitty-hbase-impl/src/test/java/org/nuiton/wikitty/hbase/ trunk/wikitty-hbase-impl/src/test/java/org/nuiton/wikitty/hbase/test/ trunk/wikitty-jdbc-impl/src/main/java/org/nuiton/ trunk/wikitty-jdbc-impl/src/main/java/org/nuiton/wikitty/ trunk/wikitty-jdbc-impl/src/main/java/org/nuiton/wikitty/jdbc/ trunk/wikitty-jdbc-impl/src/test/java/org/nuiton/ trunk/wikitty-jdbc-impl/src/test/java/org/nuiton/wikitty/ trunk/wikitty-jdbc-impl/src/test/java/org/nuiton/wikitty/jdbc/ trunk/wikitty-jdbc-impl/src/test/java/org/nuiton/wikitty/jdbc/test/ trunk/wikitty-jms-impl/src/main/java/org/nuiton/ trunk/wikitty-jms-impl/src/main/java/org/nuiton/wikitty/ trunk/wikitty-jms-impl/src/main/java/org/nuiton/wikitty/jms/ trunk/wikitty-jms-impl/src/test/java/org/nuiton/ trunk/wikitty-jms-impl/src/test/java/org/nuiton/wikitty/ trunk/wikitty-jms-impl/src/test/java/org/nuiton/wikitty/jms/ trunk/wikitty-jms-impl/src/test/java/org/nuiton/wikitty/jms/test/ trunk/wikitty-jpa-impl/src/main/java/org/nuiton/ trunk/wikitty-jpa-impl/src/main/java/org/nuiton/wikitty/ trunk/wikitty-jpa-impl/src/main/java/org/nuiton/wikitty/jpa/ trunk/wikitty-jpa-impl/src/test/java/org/nuiton/ trunk/wikitty-jpa-impl/src/test/java/org/nuiton/wikitty/ trunk/wikitty-jpa-impl/src/test/java/org/nuiton/wikitty/jpa/ trunk/wikitty-jpa-impl/src/test/java/org/nuiton/wikitty/jpa/test/ trunk/wikitty-multistorage-impl/src/main/java/org/nuiton/ trunk/wikitty-multistorage-impl/src/main/java/org/nuiton/wikitty/ trunk/wikitty-multistorage-impl/src/main/java/org/nuiton/wikitty/multistorage/ trunk/wikitty-multistorage-impl/src/test/java/org/nuiton/ trunk/wikitty-multistorage-impl/src/test/java/org/nuiton/wikitty/ trunk/wikitty-multistorage-impl/src/test/java/org/nuiton/wikitty/multistorage/ trunk/wikitty-multistorage-impl/src/test/java/org/nuiton/wikitty/multistorage/test/ trunk/wikitty-solr-impl/src/main/java/org/nuiton/ trunk/wikitty-solr-impl/src/main/java/org/nuiton/wikitty/ trunk/wikitty-solr-impl/src/main/java/org/nuiton/wikitty/solr/ trunk/wikitty-solr-impl/src/test/java/org/nuiton/ trunk/wikitty-solr-impl/src/test/java/org/nuiton/wikitty/ trunk/wikitty-solr-impl/src/test/java/org/nuiton/wikitty/solr/ trunk/wikitty-solr-impl/src/test/java/org/nuiton/wikitty/solr/test/ Removed: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/AbstractWikittyService.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/BusinessEntity.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/BusinessEntityBean.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/BusinessEntityWikitty.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/Criteria.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/ExtensionFactory.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/FacetTopic.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/FieldFactory.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/FieldType.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/JobState.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/Package.html trunk/wikitty-api/src/main/java/org/sharengo/wikitty/PagedResult.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/Tree.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/UpdateResponse.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/Wikitty.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyDAO.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyException.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyExtension.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyExtensionMigration.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyExtensionMigrationRename.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyExtensionStorage.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyProxy.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittySearchEngin.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyService.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyServiceInMemory.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyStorage.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyTransaction.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyUtil.java trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/ trunk/wikitty-api/src/main/resources/org/sharengo/ trunk/wikitty-api/src/test/java/org/sharengo/wikitty/test/api/ trunk/wikitty-api/src/test/java/org/sharengo/wikitty/test/conform/ trunk/wikitty-api/src/test/java/org/sharengo/wikitty/test/memory/ trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/BusinessEntityBeanGenerator.java trunk/wikitty-generators/src/main/java/org/sharengo/wikitty/generator/ trunk/wikitty-hbase-impl/src/main/java/org/sharengo/wikitty/hbase/ trunk/wikitty-hbase-impl/src/test/java/org/sharengo/wikitty/hbase/test/ trunk/wikitty-jdbc-impl/src/main/java/org/sharengo/wikitty/jdbc/ trunk/wikitty-jdbc-impl/src/test/java/org/sharengo/wikitty/jdbc/test/ trunk/wikitty-jms-impl/src/main/java/org/sharengo/wikitty/jms/ trunk/wikitty-jms-impl/src/test/java/org/sharengo/wikitty/jms/test/ trunk/wikitty-jpa-impl/src/main/java/org/sharengo/wikitty/jpa/ trunk/wikitty-jpa-impl/src/test/java/org/sharengo/wikitty/jpa/test/ trunk/wikitty-multistorage-impl/src/main/java/org/sharengo/wikitty/multistorage/ trunk/wikitty-multistorage-impl/src/test/java/org/sharengo/wikitty/multistorage/test/ trunk/wikitty-solr-impl/src/main/java/org/sharengo/wikitty/solr/ trunk/wikitty-solr-impl/src/test/java/org/sharengo/wikitty/solr/test/ Modified: trunk/wikitty-api/pom.xml trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/And.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/AssociatedRestriction.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Between.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/BinaryOperator.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Contains.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Element.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/EndsWith.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Equals.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Greater.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/GreaterOrEqual.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/In.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Keyword.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Less.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/LessOrEqual.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Like.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Not.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/NotEquals.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Or.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Restriction.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/RestrictionHelper.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/RestrictionName.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Search.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/SearchOperand.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/StartsWith.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/SubSearch.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Unlike.java trunk/wikitty-api/src/main/uml/wikitty-api/wikitty-api.uml trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/api/AbstractTestApi.java trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/api/CommonTest.java trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/api/ExtensionFactoryTest.java trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/api/SearchCriteriaTest.java trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/api/WikittyUtilTest.java trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/conform/AbstractTestConformance.java trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/conform/ImportExportTest.java trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/conform/PerformanceTest.java trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/conform/SearchTest.java trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/conform/StorageTest.java trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/memory/InMemoryStorageTest.java trunk/wikitty-api/src/test/resources/META-INF/spring/wikitty-test.xml trunk/wikitty-api/src/test/resources/log4j.properties trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/BusinessEntityGenerator.java trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/BusinessEntityInterfaceGenerator.java trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/EnumGenerator.java trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/EugengoConstants.java trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/EugengoUtils.java trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/InterfaceGenerator.java trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikengoCommonGenerator.java trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyMetaGenerator.java trunk/wikitty-hbase-impl/src/main/java/org/nuiton/wikitty/hbase/WikittyExtensionStorageHBase.java trunk/wikitty-hbase-impl/src/main/java/org/nuiton/wikitty/hbase/WikittyHBaseUtil.java trunk/wikitty-hbase-impl/src/main/java/org/nuiton/wikitty/hbase/WikittyServiceHBase.java trunk/wikitty-hbase-impl/src/main/java/org/nuiton/wikitty/hbase/WikittyStorageHBase.java trunk/wikitty-hbase-impl/src/test/java/org/nuiton/wikitty/hbase/test/AbstractTestHbase.java trunk/wikitty-hbase-impl/src/test/java/org/nuiton/wikitty/hbase/test/HBaseConnectorTest.java trunk/wikitty-hbase-impl/src/test/java/org/nuiton/wikitty/hbase/test/ServiceFactory.java trunk/wikitty-hbase-impl/src/test/java/org/nuiton/wikitty/hbase/test/StandAloneServer.java trunk/wikitty-hbase-impl/src/test/java/org/nuiton/wikitty/hbase/test/StorageHbaseTest.java trunk/wikitty-hbase-impl/src/test/resources/META-INF/spring/wikitty-test.xml trunk/wikitty-hbase-impl/src/test/resources/log4j.properties trunk/wikitty-jdbc-impl/src/main/java/org/nuiton/wikitty/jdbc/WikittyExtensionStorageJDBC.java trunk/wikitty-jdbc-impl/src/main/java/org/nuiton/wikitty/jdbc/WikittyJDBCUtil.java trunk/wikitty-jdbc-impl/src/main/java/org/nuiton/wikitty/jdbc/WikittyServiceJDBC.java trunk/wikitty-jdbc-impl/src/main/java/org/nuiton/wikitty/jdbc/WikittyStorageJDBC.java trunk/wikitty-jdbc-impl/src/test/java/org/nuiton/wikitty/jdbc/test/StorageJDBCTest.java trunk/wikitty-jdbc-impl/src/test/resources/META-INF/spring/wikitty-test.xml trunk/wikitty-jdbc-impl/src/test/resources/log4j.properties trunk/wikitty-jms-impl/src/main/java/org/nuiton/wikitty/jms/WikittyActionMessage.java trunk/wikitty-jms-impl/src/main/java/org/nuiton/wikitty/jms/WikittyBrokerFactory.java trunk/wikitty-jms-impl/src/main/java/org/nuiton/wikitty/jms/WikittyExtensionStorageJMS.java trunk/wikitty-jms-impl/src/main/java/org/nuiton/wikitty/jms/WikittyExtensionSubscriberJMS.java trunk/wikitty-jms-impl/src/main/java/org/nuiton/wikitty/jms/WikittyJMSUtil.java trunk/wikitty-jms-impl/src/main/java/org/nuiton/wikitty/jms/WikittyStorageJMS.java trunk/wikitty-jms-impl/src/main/java/org/nuiton/wikitty/jms/WikittyStorageSubscriberJMS.java trunk/wikitty-jms-impl/src/main/resources/META-INF/services/org/apache/activemq/broker/wikitty trunk/wikitty-jms-impl/src/test/java/org/nuiton/wikitty/jms/test/TopicSendReceiveTCPTest.java trunk/wikitty-jms-impl/src/test/java/org/nuiton/wikitty/jms/test/TopicSendReceiveTestSupport.java trunk/wikitty-jms-impl/src/test/java/org/nuiton/wikitty/jms/test/TopicSendReceiveVMTest.java trunk/wikitty-jms-impl/src/test/java/org/nuiton/wikitty/jms/test/WikittyExtensionStorageAdapter.java trunk/wikitty-jms-impl/src/test/java/org/nuiton/wikitty/jms/test/WikittyStorageAdapter.java trunk/wikitty-jms-impl/src/test/resources/log4j.properties trunk/wikitty-jpa-impl/src/main/java/org/nuiton/wikitty/jpa/JBossTMFactoryBean.java trunk/wikitty-jpa-impl/src/main/java/org/nuiton/wikitty/jpa/JBossUTFactoryBean.java trunk/wikitty-jpa-impl/src/main/java/org/nuiton/wikitty/jpa/JtaPersistenceUnitPostProcessor.java trunk/wikitty-jpa-impl/src/main/java/org/nuiton/wikitty/jpa/TransactionManagerLookup.java trunk/wikitty-jpa-impl/src/main/java/org/nuiton/wikitty/jpa/WikittyExtensionStorageJPA.java trunk/wikitty-jpa-impl/src/main/java/org/nuiton/wikitty/jpa/WikittyJPAUtil.java trunk/wikitty-jpa-impl/src/main/java/org/nuiton/wikitty/jpa/WikittyServiceJPA.java trunk/wikitty-jpa-impl/src/main/java/org/nuiton/wikitty/jpa/WikittyStorageJPA.java trunk/wikitty-jpa-impl/src/main/resources/META-INF/orm.xml trunk/wikitty-jpa-impl/src/main/resources/META-INF/persistence.xml trunk/wikitty-jpa-impl/src/test/java/org/nuiton/wikitty/jpa/test/StorageJPATest.java trunk/wikitty-jpa-impl/src/test/java/org/nuiton/wikitty/jpa/test/TestJTA.java trunk/wikitty-jpa-impl/src/test/java/org/nuiton/wikitty/jpa/test/TestJTAWithSync.java trunk/wikitty-jpa-impl/src/test/resources/META-INF/spring/wikitty-test.xml trunk/wikitty-jpa-impl/src/test/resources/log4j.properties trunk/wikitty-multistorage-impl/src/main/java/org/nuiton/wikitty/multistorage/MultiStorageConfiguration.java trunk/wikitty-multistorage-impl/src/main/java/org/nuiton/wikitty/multistorage/WikittyExtensionMultiStorage.java trunk/wikitty-multistorage-impl/src/main/java/org/nuiton/wikitty/multistorage/WikittyMultiStorage.java trunk/wikitty-multistorage-impl/src/main/java/org/nuiton/wikitty/multistorage/WikittyServiceMultiStorage.java trunk/wikitty-multistorage-impl/src/test/java/org/nuiton/wikitty/multistorage/test/MultiStorageTest.java trunk/wikitty-multistorage-impl/src/test/resources/log4j.properties trunk/wikitty-solr-impl/src/main/java/org/nuiton/wikitty/solr/Restriction2Solr.java trunk/wikitty-solr-impl/src/main/java/org/nuiton/wikitty/solr/WikittyQueryParser.java trunk/wikitty-solr-impl/src/main/java/org/nuiton/wikitty/solr/WikittySearchEnginSolr.java trunk/wikitty-solr-impl/src/main/resources/solrconfig.xml trunk/wikitty-solr-impl/src/test/java/org/nuiton/wikitty/solr/test/AbstractTestSolr.java trunk/wikitty-solr-impl/src/test/java/org/nuiton/wikitty/solr/test/SolrSearchTest.java trunk/wikitty-solr-impl/src/test/java/org/nuiton/wikitty/solr/test/SolrServerTest.java trunk/wikitty-solr-impl/src/test/java/org/nuiton/wikitty/solr/test/TreeTest.java trunk/wikitty-solr-impl/src/test/java/org/nuiton/wikitty/solr/test/WikittyServiceSolr.java trunk/wikitty-solr-impl/src/test/resources/META-INF/spring/wikitty-test.xml trunk/wikitty-solr-impl/src/test/resources/log4j.properties Modified: trunk/wikitty-api/pom.xml =================================================================== --- trunk/wikitty-api/pom.xml 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/pom.xml 2010-05-12 15:08:48 UTC (rev 53) @@ -174,10 +174,10 @@ <phase>generate-sources</phase> <!--<configuration> <inputs>src/main/uml/wikitty-api:**\/*.uml</inputs> - <fullPackagePath>org.sharengo.wikitty</fullPackagePath> - <defaultPackage>org.sharengo.wikitty</defaultPackage> - <extractedPackages>org.sharengo.wikitty</extractedPackages> - <templates>org.sharengo.wikitty.generator.WikittyMetaGenerator</templates> + <fullPackagePath>org.nuiton.wikitty</fullPackagePath> + <defaultPackage>org.nuiton.wikitty</defaultPackage> + <extractedPackages>org.nuiton.wikitty</extractedPackages> + <templates>org.nuiton.wikitty.generator.WikittyMetaGenerator</templates> </configuration> <goals> <goal>smart-generate</goal> @@ -188,10 +188,10 @@ <input>${maven.src.dir}/main/uml/wikitty-api</input> </zargoResources> <includes>**/*.objectmodel</includes> - <templates>org.sharengo.wikitty.generator.WikittyMetaGenerator</templates> - <defaultPackage>org.sharengo.wikitty</defaultPackage> - <extractedPackages>org.sharengo.wikitty</extractedPackages> - <generatedPackages>org.sharengo.wikitty</generatedPackages> + <templates>org.nuiton.wikitty.generator.WikittyMetaGenerator</templates> + <defaultPackage>org.nuiton.wikitty</defaultPackage> + <extractedPackages>org.nuiton.wikitty</extractedPackages> + <generatedPackages>org.nuiton.wikitty</generatedPackages> </configuration> <goals> <goal>zargo2xmi</goal> Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/AbstractWikittyService.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/AbstractWikittyService.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/AbstractWikittyService.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/AbstractWikittyService.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,1233 @@ +/* *##% + * Copyright (c) 2009 poussin. All rights reserved. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + *##%*/ + +package org.nuiton.wikitty; + +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; +import java.io.InputStreamReader; +import java.io.Reader; +import java.io.StringReader; +import java.io.StringWriter; +import java.io.Writer; +import java.net.URL; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Date; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.UUID; +import java.util.AbstractMap.SimpleEntry; +import java.util.Map.Entry; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.FutureTask; + +import org.apache.commons.lang.StringEscapeUtils; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.nuiton.wikitty.search.Search; +import org.nuiton.wikitty.LabelImpl; +import org.nuiton.wikitty.TreeNode; +import org.nuiton.wikitty.TreeNodeBean; +import org.nuiton.wikitty.TreeNodeImpl; +import org.xmlpull.v1.XmlPullParser; +import org.xmlpull.v1.XmlPullParserFactory; + +/** + * Abstract class that new implementation must extends. + * New implementation only have three method to implement: + * <li>getSearchEngin + * <li>getExtensionStorage + * <li>getWikittyStorage + * + * @author poussin + * @version $Revision$ + * + * Last update: $Date$ + * by : $Author$ + */ +public abstract class AbstractWikittyService implements WikittyService { + + /** to use log facility, just put in your code: log.info(\"...\"); */ + static private Log log = LogFactory.getLog(AbstractWikittyService.class); + + // FIXME poussin 20090902 next 3 variables must be read from configuration file + /** number of thread used to import/export task */ + protected int MAX_IMPORT_EXPORT_THREAD = 1; + /** directory path where export asynchronous file are stored */ + protected String EXPORT_DIRECTORY = "/tmp/"; + /** url used by client to retrieve export file when job is ended */ + protected String EXPORT_URL = "file:///tmp/"; + + /** Executor that do import export task */ + protected ExecutorService importExportExecutor = + // TODO poussin 20090902 do thread number configurable + Executors.newFixedThreadPool(MAX_IMPORT_EXPORT_THREAD); + /** contains all import or export task, key is job id send to client */ + protected Map<String, Future<String>> importExportTask = + new HashMap<String, Future<String>>(); + + /** Default migration use to migrate a wikitty in last extension version */ + protected WikittyExtensionMigration defaultExtensionMigration = + new WikittyExtensionMigrationRename(); + + abstract protected WikittySearchEngin getSearchEngin(); + abstract protected WikittyExtensionStorage getExtensionStorage(); + abstract protected WikittyStorage getWikittyStorage(); + + protected UpdateResponse store(WikittyTransaction transaction, + Collection<Wikitty> wikitties, boolean disableAutoVersionIncrement) { + // update/store extension if necessary + Set<WikittyExtension> allExtensions = new HashSet<WikittyExtension>(); + for (Wikitty w : wikitties) { + // collect all extensions used by all wikitties + allExtensions.addAll(w.getExtensions()); + } + + // try to commit command + UpdateResponse extUpdate = getExtensionStorage().store(transaction, allExtensions); + UpdateResponse wikUpdate = getWikittyStorage().store(transaction, wikitties, disableAutoVersionIncrement); + UpdateResponse indexUpdate = getSearchEngin().store(transaction, wikitties); + + UpdateResponse result = new UpdateResponse(); + // prepare update client response + result.add(extUpdate); + result.add(wikUpdate); + result.add(indexUpdate); + + return result; + } + + /** + * Store and index wikitty object + * @param wikitty + */ + @Override + public UpdateResponse store(Wikitty wikitty) { + if (wikitty != null) { + WikittyTransaction transaction = new WikittyTransaction(); + try { + transaction.begin(); + + List<Wikitty> wikitties = Arrays.asList(wikitty); + UpdateResponse result = store(transaction, wikitties, false); + + transaction.commit(); + return result; + } catch (Exception eee) { + transaction.rollback(); + throw new WikittyException(eee); + } + } else { + throw new WikittyException("You can't store null wikitty object"); + } + } + + /** + * Store and index wikitties object + * @param wikitty + */ + @Override + public UpdateResponse store(Collection<Wikitty> wikitties) { + WikittyTransaction transaction = new WikittyTransaction(); + try { + transaction.begin(); + + UpdateResponse result = store(transaction, wikitties, false); + + transaction.commit(); + return result; + } catch (Exception eee) { + transaction.rollback(); + throw new WikittyException(eee); + } + } + + /** + * Store and index wikitties object + * @param wikitty + */ + @Override + public UpdateResponse store(Collection<Wikitty> wikitties, boolean disableAutoVersionIncrement) { + WikittyTransaction transaction = new WikittyTransaction(); + try { + transaction.begin(); + + UpdateResponse result = store(transaction, wikitties, disableAutoVersionIncrement); + + transaction.commit(); + return result; + } catch (Exception eee) { + transaction.rollback(); + throw new WikittyException(eee); + } + } + + @Override + public List<String> getAllExtensionIds() { + WikittyTransaction transaction = new WikittyTransaction(); + try { + transaction.begin(); + + List<String> result = getExtensionStorage().getAllExtensionIds(transaction); + + transaction.commit(); + return result; + } catch (Exception eee) { + transaction.rollback(); + throw new WikittyException(eee); + } + } + + @Override + public List<String> getAllExtensionsRequires(String extensionName) { + WikittyTransaction transaction = new WikittyTransaction(); + try { + transaction.begin(); + + List<String> result = getExtensionStorage() + .getAllExtensionsRequires(transaction, extensionName); + + transaction.commit(); + return result; + } catch (Exception eee) { + transaction.rollback(); + throw new WikittyException(eee); + } + } + + protected UpdateResponse storeExtension(WikittyTransaction transaction, Collection<WikittyExtension> exts) { + UpdateResponse result = getExtensionStorage().store(transaction, exts); + return result; + } + + /** + * Save just one extension + * @param ext + * @throws java.io.IOException + */ + @Override + public UpdateResponse storeExtension(Collection<WikittyExtension> exts) { + WikittyTransaction transaction = new WikittyTransaction(); + try { + transaction.begin(); + + UpdateResponse result = storeExtension(transaction, exts); + + transaction.commit(); + return result; + } catch (Exception eee) { + transaction.rollback(); + throw new WikittyException(eee); + } + } + + @Override + public UpdateResponse storeExtension(WikittyExtension ext) { + WikittyTransaction transaction = new WikittyTransaction(); + try { + transaction.begin(); + + UpdateResponse result = storeExtension(transaction, Arrays.asList(ext)); + + transaction.commit(); + return result; + } catch (Exception eee) { + transaction.rollback(); + throw new WikittyException(eee); + } + } + + protected WikittyExtension restoreExtension(WikittyTransaction transaction, String id) { + //split the id to ensure that version is normalized + String name = WikittyExtension.computeName(id); + String version = WikittyExtension.computeVersion(id); + + WikittyExtension result = getExtensionStorage().restore(transaction, name, version); + return result; + } + /** + * Load extension from id. Id is 'name[version]' + * @param id + * @return + */ + @Override + public WikittyExtension restoreExtension(String id) { + WikittyTransaction transaction = new WikittyTransaction(); + try { + transaction.begin(); + + WikittyExtension result = restoreExtension(transaction, id); + + transaction.commit(); + return result; + } catch (Exception eee) { + transaction.rollback(); + throw new WikittyException(eee); + } + + } + + protected WikittyExtension restoreExtensionLastVersion(WikittyTransaction transaction, String name) { + String version = getExtensionStorage().getLastVersion(transaction, name); + if(version == null) { + return null; + } + + WikittyExtension result = getExtensionStorage().restore(transaction, name, version); + return result; + } + + @Override + public WikittyExtension restoreExtensionLastVersion(String name) { + WikittyTransaction transaction = new WikittyTransaction(); + try { + transaction.begin(); + + WikittyExtension result = restoreExtensionLastVersion(transaction, name); + + transaction.commit(); + return result; + } catch (Exception eee) { + transaction.rollback(); + throw new WikittyException(eee); + } + } + + protected Wikitty restore(WikittyTransaction transaction, String id) { + if (!getWikittyStorage().exists(transaction, id)) { + // object doesn't exist, we return null + return null; + } + + if (getWikittyStorage().isDeleted(transaction, id)) { + // object deleted, we return null + return null; + } + Wikitty result = getWikittyStorage().restore(transaction, id); + if(result != null) { + result = upgradeData(transaction, result); + } + return result; + } + + protected List<Wikitty> restore(WikittyTransaction transaction, List<String> ids) { + List<Wikitty> result = new ArrayList<Wikitty>(); + for(String id : ids) { + Wikitty w = restore(transaction, id); + if (w != null) { + result.add(w); + } + } + return result; + } + + @Override + public List<Wikitty> restore(List<String> ids) { + WikittyTransaction transaction = new WikittyTransaction(); + try { + transaction.begin(); + + List<Wikitty> result = restore(transaction, ids); + + transaction.commit(); + return result; + } catch (Exception eee) { + transaction.rollback(); + throw new WikittyException(eee); + } + } + + @Override + public Wikitty restore(String id) { + WikittyTransaction transaction = new WikittyTransaction(); + try { + transaction.begin(); + + Wikitty result = restore(transaction, id); + + transaction.commit(); + return result; + } catch (Exception eee) { + transaction.rollback(); + throw new WikittyException(eee); + } + } + + protected Wikitty upgradeData(WikittyTransaction transaction, Wikitty wikitty) { + Wikitty result = wikitty; + + Collection<WikittyExtension> extensions = wikitty.getExtensions(); + for (WikittyExtension extension : extensions) { + String extensionName = extension.getName(); + log.debug("extensionName=" + extensionName); + + WikittyExtension currentExtension = extension; + String currentExtensionVersion = currentExtension.getVersion(); + + WikittyExtension lastExtension = restoreExtensionLastVersion(transaction, extensionName); + String lastExtensionVersion = lastExtension.getVersion(); + log.debug("lastExtensionVersion=" + lastExtensionVersion); + + WikittyExtensionMigration migration = WikittyExtensionMigration.migrationRegistry.get(extensionName); + if (migration == null) { + migration = defaultExtensionMigration; + } + + // Loop on between extension in wikitty and last version + while(WikittyUtil.versionGreaterThan(lastExtensionVersion, currentExtensionVersion)) { + + // Get extension after the current version + String nextExtensionVersion = WikittyUtil.incrementMajorRevision(currentExtensionVersion); + String nextExtensionId = WikittyExtension.computeId(extensionName, nextExtensionVersion); + WikittyExtension nextExtension = restoreExtension(transaction, nextExtensionId); + + log.debug("currentExtensionVersion=" + currentExtensionVersion); + log.debug("nextExtensionVersion=" + nextExtensionVersion); + + // Test if extension is never use in this version + if(nextExtension != null) { + result = migration.migrate(this, transaction, result, currentExtension, nextExtension); + currentExtension = nextExtension; + } + + // Follow + currentExtensionVersion = nextExtensionVersion; + } + } + + return result; + } + + protected void delete(WikittyTransaction transaction, Collection<String> ids) throws WikittyException { + // work only on valid id + Collection<Wikitty> storedWikitties = new ArrayList<Wikitty>(); + List<String> idList = new LinkedList<String>(ids); + for (Iterator<String> i = idList.iterator(); i.hasNext();) { + String id = i.next(); + // test if wikitty exists + if (!getWikittyStorage().exists(transaction, id)) { + // don't exist, remove this id in id list + i.remove(); + } + if (getWikittyStorage().isDeleted(transaction, id)) { + // already deleted, remove this id in id list + i.remove(); + } + + // Store node with have deleted node as parent + Criteria criteria = Search.query().eq(TreeNode.FQ_FIELD_PARENT, id).criteria(); + List<Wikitty> wikittyNodes = findAllByCriteria(transaction, criteria).getAll(); + for (Wikitty wikittyNode : wikittyNodes) { + String wikittyNodeId = wikittyNode.getId(); + if(!ids.contains(wikittyNodeId)) { + TreeNode treeNode = new TreeNodeImpl(wikittyNode); + treeNode.setParent(null); + storedWikitties.add(wikittyNode); + } + } + + // Store node with have deleted child + criteria = Search.query().eq(TreeNode.FQ_FIELD_CHILDREN, id).criteria(); + wikittyNodes = findAllByCriteria(transaction, criteria).getAll(); + for (Wikitty wikittyNode : wikittyNodes) { + String wikittyNodeId = wikittyNode.getId(); + if(!ids.contains(wikittyNodeId)) { + TreeNode treeNode = new TreeNodeImpl(wikittyNode); + treeNode.removeChildren(id); + storedWikitties.add(wikittyNode); + } + } + } + + getWikittyStorage().delete(transaction, ids); + getSearchEngin().delete(transaction, ids); + + store(transaction, storedWikitties, false); + } + + @Override + public void delete(String id) { + WikittyTransaction transaction = new WikittyTransaction(); + try { + transaction.begin(); + + List<String> ids = Arrays.asList(id); + delete(transaction, ids); + + transaction.commit(); + } catch (Exception eee) { + transaction.rollback(); + throw new WikittyException(eee); + } + } + + @Override + public void delete(Collection<String> ids){ + WikittyTransaction transaction = new WikittyTransaction(); + try { + transaction.begin(); + + delete(transaction, ids); + + transaction.commit(); + } catch (Exception eee) { + transaction.rollback(); + throw new WikittyException(eee); + } + } + + /** + * Use with caution : It will delete ALL indexes from search engine ! + * This operation should be disabled in production environment. + */ + @Override + public void clear() { + WikittyTransaction transaction = new WikittyTransaction(); + try { + transaction.begin(); + + getSearchEngin().clear(transaction); + getWikittyStorage().clear(transaction); + getExtensionStorage().clear(transaction); + + transaction.commit(); + } catch (Exception eee) { + transaction.rollback(); + throw new WikittyException(eee); + } + } + + /** + * Assume that this PagedResult contains wikitty id as result and + * return new PagedResult with Wikitty instance + */ + protected PagedResult<Wikitty> findAllByCriteria(WikittyTransaction transaction, Criteria criteria) { + PagedResult<String> resultIds = getSearchEngin().findAllByCriteria(transaction, criteria); + List<String> ids = resultIds.getAll(); + List<Wikitty> wikitties = restore(transaction, ids); + PagedResult<Wikitty> result = new PagedResult<Wikitty>( + resultIds.getFirstIndice(), + resultIds.getNumFound(), + resultIds.getQueryString(), + resultIds.getFacets(), + wikitties); + return result; + } + + @Override + public PagedResult<Wikitty> findAllByCriteria(Criteria criteria) { + WikittyTransaction transaction = new WikittyTransaction(); + try { + transaction.begin(); + + PagedResult<Wikitty> result = findAllByCriteria(transaction, criteria); + + transaction.commit(); + return result; + } catch (Exception eee) { + transaction.rollback(); + throw new WikittyException(eee); + } + } + + protected Wikitty findByCriteria(WikittyTransaction transaction, Criteria criteria) { + criteria.setFirstIndex(0).setEndIndex(1); + PagedResult<Wikitty> pages = findAllByCriteria(transaction, criteria); + + Wikitty result = null; + if (pages.size() > 0) { + result = pages.getFirst(); + } + + return result; + } + + @Override + public Wikitty findByCriteria(Criteria criteria) { + WikittyTransaction transaction = new WikittyTransaction(); + try { + transaction.begin(); + + Wikitty result = findByCriteria(transaction, criteria); + + transaction.commit(); + return result; + } catch (Exception eee) { + transaction.rollback(); + throw new WikittyException(eee); + } + } + + @Override + public void addLabel(String wikittyId, String label) { + WikittyTransaction transaction = new WikittyTransaction(); + try { + transaction.begin(); + + Wikitty w = restore(transaction, wikittyId); + w.addExtension(LabelImpl.extensions); + LabelImpl l = new LabelImpl(w); + l.addLabels(label); + store(transaction, Arrays.asList(w), false); + + transaction.commit(); + } catch (Exception eee) { + transaction.rollback(); + throw new WikittyException(eee); + } + } + + + @Override + public PagedResult<Wikitty> findAllByLabel(String label, int firstIndex, int endIndex) { + WikittyTransaction transaction = new WikittyTransaction(); + try { + transaction.begin(); + + LabelImpl l = new LabelImpl(); + l.addLabels(label); + Criteria criteria = Search.query(l.getWikitty()).criteria() + .setFirstIndex(firstIndex).setEndIndex(endIndex); + PagedResult<Wikitty> result = findAllByCriteria(transaction, criteria); + + transaction.commit(); + return result; + } catch (Exception eee) { + transaction.rollback(); + throw new WikittyException(eee); + } + } + + + @Override + public Wikitty findByLabel(String label) { + WikittyTransaction transaction = new WikittyTransaction(); + try { + transaction.begin(); + + LabelImpl l = new LabelImpl(); + l.addLabels(label); + Criteria criteria = Search.query(l.getWikitty()).criteria(); + Wikitty result = findByCriteria(transaction, criteria); + + transaction.commit(); + return result; + } catch (Exception eee) { + transaction.rollback(); + throw new WikittyException(eee); + } + } + + + @Override + public Set<String> findAllAppliedLabels(String wikittyId) { + WikittyTransaction transaction = new WikittyTransaction(); + try { + transaction.begin(); + + Wikitty w = restore(transaction, wikittyId); + LabelImpl l = new LabelImpl(w); + Set<String> result = l.getLabels(); + + transaction.commit(); + return result; + } catch (Exception eee) { + transaction.rollback(); + throw new WikittyException(eee); + } + } + + + protected Tree restoreTree(WikittyTransaction transaction, String wikittyId) { + Wikitty w = restore(transaction, wikittyId); + if(w == null) { + return null; + } + + if ( !w.hasExtension(TreeNode.EXT_TREENODE) ) { + throw new WikittyException(String.format( + "Wikitty '%s' do not handle extension %s", + wikittyId, TreeNode.EXT_TREENODE )); + } + Tree tree = new Tree(); + TreeNode node = AbstractWikittyService.toBean(new TreeNodeImpl(w)); + tree.setNode(node); + + TreeNodeImpl exempleNode = new TreeNodeImpl(); + exempleNode.setParent(wikittyId); + + Criteria criteria = Search.query(exempleNode.getWikitty()).criteria() + .setFirstIndex(0).setEndIndex(Criteria.ALL_ELEMENTS); + PagedResult<Wikitty> childNodes = findAllByCriteria(transaction, criteria); + for( Wikitty childNode : childNodes.getAll() ) { + tree.addChild(restoreTree(transaction, childNode.getId())); + } + + return tree; + } + + @Override + public Tree restoreTree(String wikittyId) { + WikittyTransaction transaction = new WikittyTransaction(); + try { + transaction.begin(); + + Tree tree = restoreTree(transaction, wikittyId); + + transaction.commit(); + return tree; + } catch (Exception eee) { + transaction.rollback(); + throw new WikittyException(eee); + } + } + + @Override + public Map.Entry<TreeNode, Integer> restoreNode(String wikittyId, Criteria filter) { + WikittyTransaction transaction = new WikittyTransaction(); + try { + transaction.begin(); + + Wikitty w = restore(transaction, wikittyId); + if(w == null) { + transaction.commit(); + return null; + } + + if ( !w.hasExtension(TreeNode.EXT_TREENODE) ) { + throw new WikittyException(String.format( + "Wikitty '%s' do not handle extension %s", + wikittyId, TreeNode.EXT_TREENODE )); + } + + TreeNode node = AbstractWikittyService.toBean(new TreeNodeImpl(w)); + Integer count = getSearchEngin().findNodeCount(transaction, w, filter); + + HashMap.SimpleEntry<TreeNode, Integer> result = + new SimpleEntry<TreeNode, Integer>(node, count); + + transaction.commit(); + return result; + } catch (Exception eee) { + transaction.rollback(); + throw new WikittyException(eee); + } + } + + @Override + public Map<TreeNode, Integer> restoreChildren(String wikittyId, Criteria filter) { + WikittyTransaction transaction = new WikittyTransaction(); + try { + transaction.begin(); + + Wikitty w = restore(transaction, wikittyId); + if(w == null) { + transaction.commit(); + return null; + } + + if ( !w.hasExtension(TreeNode.EXT_TREENODE) ) { + throw new WikittyException(String.format( + "Wikitty '%s' do not handle extension %s", + wikittyId, TreeNode.EXT_TREENODE )); + } + + Map<TreeNode, Integer> result = new LinkedHashMap<TreeNode, Integer>(); + + Map<String, Integer> search = getSearchEngin().findAllChildrenCount(transaction, w, filter); + Set<Entry<String, Integer>> children = search.entrySet(); + for (Entry<String, Integer> child : children) { + Integer count = child.getValue(); + + String id = child.getKey(); + Wikitty wikitty = restore(transaction, id); + TreeNode node = AbstractWikittyService.toBean(new TreeNodeImpl(wikitty)); + + result.put(node, count); + } + + transaction.commit(); + return result; + } catch (Exception eee) { + transaction.rollback(); + throw new WikittyException(eee); + } + } + + @Override + public Wikitty restoreVersion(String wikittyId, String version) { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public UpdateResponse syncEngin() { + final WikittyTransaction transaction = new WikittyTransaction(); + try { + final int numberForCommit = 1000; + final WikittySearchEngin searchEngin = getSearchEngin(); + final UpdateResponse result = new UpdateResponse(); + final List<Wikitty> wikitties = new ArrayList<Wikitty>(numberForCommit); + + transaction.begin(); + searchEngin.clear(transaction); + transaction.commit(); + transaction.begin(); + + getWikittyStorage().scanWikitties(transaction, new WikittyStorage.Scanner() { + int count = 0; + + @Override + public void scan(Wikitty wikitty) { + Date deleteDate = wikitty.getDeleteDate(); + if(deleteDate == null) { + count ++; + wikitties.add(wikitty); + + if(count == numberForCommit) { + // Reindex + UpdateResponse response = searchEngin.store(transaction, wikitties); + result.add(response); + transaction.commit(); + // Reinit + count = 0; + wikitties.clear(); + transaction.begin(); + } + } + } + }); + + // Last wikitties + UpdateResponse response = searchEngin.store(transaction, wikitties); + result.add(response); + + transaction.commit(); + return result; + } catch (Exception eee) { + transaction.rollback(); + throw new WikittyException(eee); + } + } + + /** + * Class used for import process, this class retain numberForCommit object + * before to send it to storage. + */ + static protected class WikittyBatchUpdate { + // TODO poussin 20090902 do configurable numberForCommit + protected int numberForCommit = 1000; + protected int currentAdded = 0; + protected Map<String, WikittyExtension> exts = new HashMap<String, WikittyExtension>(); + protected List<Wikitty> wikitties = new LinkedList<Wikitty>(); + + protected AbstractWikittyService ws; + protected WikittyTransaction transaction; + + public WikittyBatchUpdate(AbstractWikittyService ws, WikittyTransaction transaction) { + this.ws = ws; + this.transaction = transaction; + } + + public void addExtension(WikittyExtension ext) { + exts.put(ext.getId(), ext); + inc(); + } + + public void addWikitty(Wikitty w) { + wikitties.add(w); + inc(); + } + + /** + * search extension in local extension list and if missed restore + * extension from internal WikittyService + * @param id + * @return + */ + public WikittyExtension getExtension(WikittyTransaction transaction, String id) { + WikittyExtension result = exts.get(id); + if (result == null) { + result = ws.restoreExtension(transaction, id); + } + return result; + } + + public void flush() { + ws.storeExtension(transaction, exts.values()); + ws.store(transaction, wikitties, true); + + exts.clear(); + wikitties.clear(); + currentAdded = 0; + } + + protected void inc() { + currentAdded++; + if (currentAdded >= numberForCommit) { + flush(); + } + } + } + + + @Override + public void syncImportFromXml(String xml) { + Reader reader = new StringReader(xml); + ImportTask task = new ImportTask(this, reader); + task.run(); + } + + + @Override + public void syncImportFromUri(String uri) { + try { + URL url = new URL(uri); + Reader reader = new InputStreamReader(url.openStream()); + ImportTask task = new ImportTask(this, reader); + task.run(); + } catch (Exception eee) { + throw new WikittyException(eee); + } + } + + + @Override + public String asyncImportFromUri(String uri) { + try { + URL url = new URL(uri); + Reader reader = new InputStreamReader(url.openStream()); + ImportTask task = new ImportTask(this, reader); + FutureTask<String> future = new FutureTask<String>(task, null); + importExportExecutor.submit(future); + + String jobId = UUID.randomUUID().toString(); + importExportTask.put(jobId, future); + return jobId; + } catch (Exception eee) { + throw new WikittyException(eee); + } + } + + + static public class ImportTask implements Runnable { + protected AbstractWikittyService ws; + protected WikittyTransaction transaction; + protected Reader reader; + + public ImportTask(AbstractWikittyService ws, Reader reader) { + this.ws = ws; + this.reader = reader; + this.transaction = new WikittyTransaction(); + } + + @Override + public void run() { + try { + transaction.begin(); + XmlPullParserFactory factory = XmlPullParserFactory.newInstance( + System.getProperty(XmlPullParserFactory.PROPERTY_NAME), null); + factory.setNamespaceAware(true); + XmlPullParser xpp = factory.newPullParser(); + xpp.setInput(reader); + + WikittyExtension ext = null; + Wikitty w = null; + String CDATA = null; + + WikittyBatchUpdate batchUpdate = new WikittyBatchUpdate(ws, transaction); + + long time = System.currentTimeMillis(); + + int eventType = xpp.getEventType(); + do { + String objectVersion = null; + if (eventType == xpp.START_DOCUMENT) { + log.info("start XML import at " + new Date()); + } else if (eventType == xpp.END_DOCUMENT) { + time = System.currentTimeMillis() - time; + log.info("XML import in (ms)" + time); + } else if (eventType == xpp.START_TAG) { + String name = xpp.getName(); + if ("extension".equals(name)) { + String extName = xpp.getAttributeValue(null, "name"); + String version = xpp.getAttributeValue(null, "version"); + String requires = xpp.getAttributeValue(null, "requires"); + ext = new WikittyExtension(extName, version, requires, new LinkedHashMap<String, FieldType>()); + } else if ("object".equals(name)) { + String id = xpp.getAttributeValue(null, "id"); + objectVersion = xpp.getAttributeValue(null, "version"); + String extensions = xpp.getAttributeValue(null, "extensions"); + w = new Wikitty(id); + String[] extensionList = extensions.split(","); + for (String extId : extensionList) { + String extName = WikittyExtension.computeName(extId); + String extVersion = WikittyExtension.computeVersion(extId); + extId = WikittyExtension.computeId(extName, extVersion); + WikittyExtension e = batchUpdate.getExtension(transaction, extId); + if(e == null) { + throw new WikittyException("Extension not found : " + extId); + } + w.addExtension(e); + } + } + } else if (eventType == xpp.END_TAG) { + String name = xpp.getName(); + if ("extension".equals(name)) { + batchUpdate.addExtension(ext); + ext = null; + } else if ("object".equals(name)) { + w.setVersion(objectVersion); + batchUpdate.addWikitty(w); + w = null; + } else if (ext != null && "field".equals(name)) { + FieldType type = new FieldType(); + String fieldName = WikittyUtil.parseField(CDATA, type); + ext.addField(fieldName, type); + } else if (ext != null && "tagvalues".equals(name)) { + Map<String, String> tagValues = WikittyUtil.tagValuesToMap(CDATA); + ext.setTagValues(tagValues); + } else if (w != null) { + String[] fq = name.split("\\."); + String extensionName = fq[0]; + String fieldName = fq[1]; + FieldType fieldType = w.getFieldType(name); + if(fieldType.isCollection()) { + w.addToField(extensionName, fieldName, CDATA); + } else { + w.setField(extensionName, fieldName, CDATA); + } + } + } else if (eventType == xpp.TEXT) { + CDATA = xpp.getText(); + } + eventType = xpp.next(); + } while (eventType != xpp.END_DOCUMENT); + + // don't forget to flush batchUpdate :) + batchUpdate.flush(); + transaction.commit(); + } catch (Exception eee) { + transaction.rollback(); + throw new WikittyException(eee); + } + } + } // end ImportTask + + @Override + public String asyncExportAllByCriteria(Criteria criteria) { + try { + String jobId = UUID.randomUUID().toString(); + + File file = new File(EXPORT_DIRECTORY, jobId); + String url = EXPORT_URL + jobId; + Writer result = new FileWriter(file); + ExportTask task = new ExportTask(this, criteria, result); + FutureTask<String> future = new FutureTask<String>(task, url); + importExportExecutor.submit(future); + + importExportTask.put(jobId, future); + return jobId; + } catch (Exception eee) { + throw new WikittyException(eee); + } + } + + + @Override + public String syncExportAllByCriteria(Criteria criteria) { + StringWriter result = new StringWriter(); + ExportTask task = new ExportTask(this, criteria, result); + task.run(); + return result.toString(); + } + + + static public class ExportTask implements Runnable { + protected AbstractWikittyService ws; + protected WikittyTransaction transaction; + + protected Criteria criteria; + protected Writer result; + + public ExportTask(AbstractWikittyService ws, Criteria criteria, Writer result) { + this.ws = ws; + this.transaction = new WikittyTransaction(); + this.criteria = criteria; + this.result = result; + } + + @Override + public void run() { + try { + transaction.begin(); + PagedResult<Wikitty> pageResult = ws.findAllByCriteria(transaction, criteria); + + // keep extension already done + Set<String> extDone = new HashSet<String>(); + result.write("<wikengo>\n"); + for (Wikitty w : pageResult.getAll()) { + String extensionList = ""; + for (WikittyExtension ext : w.getExtensions()) { + String id = ext.getId(); + extensionList += "," + id; + if (!extDone.contains(id)) { + extDone.add(id); + result.write(" <extension name='" + ext.getName() + + "' version='" + ext.getVersion() + + (ext.getRequires() != null ? "' requires='" + ext.getRequires() : "") + + "'>\n"); + Map<String, String> tagValues = ext.getTagValues(); + result.write(" <tagvalues>" + WikittyUtil.tagValuesToString(tagValues) + "</tagvalues>\n"); + for (String fieldName : ext.getFieldNames()) { + String def = ext.getFieldType(fieldName).toDefinition(fieldName); + result.write(" <field>" + def + "</field>\n"); + } + result.write(" </extension>\n"); + } + } + if (!"".equals(extensionList)) { + // delete first ',' + extensionList = extensionList.substring(1); + } + result.write(" <object id='" + w.getId() + "' version='" + w.getVersion() + "' extensions='" + extensionList + "'>\n"); + for (String fieldName : w.fieldNames()) { + FieldType type = w.getFieldType(fieldName); + if (type.isCollection()) { + Object fqField = w.getFqField(fieldName); + if (fqField != null) { + for (Object o : (Collection) fqField) { + String fqFieldValue = WikittyUtil.toString(type, o); + if (fqFieldValue != null) { + fqFieldValue = StringEscapeUtils.escapeXml(fqFieldValue); + result.write(" <" + fieldName + ">" + fqFieldValue + "</" + fieldName + ">\n"); + } + } + } + } else { + String fqFieldValue = WikittyUtil.toString(type, w.getFqField(fieldName)); + if (fqFieldValue != null) { + fqFieldValue = StringEscapeUtils.escapeXml(fqFieldValue); + result.write(" <" + fieldName + ">" + fqFieldValue + "</" + fieldName + ">\n"); + } + } + } + result.write(" </object>\n"); + } + result.write("</wikengo>\n"); + transaction.commit(); + } catch (IOException eee) { + transaction.rollback(); + throw new WikittyException(eee); + } + } + } // end ExportTask + + + @Override + public JobState infoJob(String jobId) { + try { + Future<String> future = importExportTask.get(jobId); + JobState result = new JobState(); + if (future.isDone()) { + result.status = "done"; + result.resourceUri = future.get(); + } else if (future.isCancelled()) { + result.status = "cancelled"; + } else { + result.status = "inProgress"; + } + return result; + } catch (Exception eee) { + throw new WikittyException(eee); + } + } + + + @Override + public void cancelJob(String jobId) { + Future future = importExportTask.get(jobId); + future.cancel(true); // true to kill process, perhaps to strong ? + } + + + @Override + public void freeJobResource(String jobId) { + Future<String> future = importExportTask.remove(jobId); + if (future != null) { + File file = new File(EXPORT_DIRECTORY, jobId); + file.delete(); + } + } + + /** + * Method copied from eugengo-0.7 generators + * + * @param bean + * @return + */ + /*public static TreeNodeImpl toImpl(TreeNode bean) { + if (bean == null) return null; + TreeNodeImpl impl = new TreeNodeImpl(bean); + return impl; + }*/ + + /** + * Method copied from eugengo-0.7 generators + * + * @param bean + * @return + */ + protected static void fillBeanAttributes(TreeNode fromBean, TreeNodeBean toBean) { + String beanId = fromBean.getWikittyId(); + toBean.id = beanId; + + String beanVersion = fromBean.getWikittyVersion(); + toBean.setWikittyVersion(beanVersion); + + toBean.setName(fromBean.getName()); + toBean.setParent(fromBean.getParent()); + // WARNING: Copy collection to other collection to not manipulate storage collection directly + Collection<String> treeNodeChildren = fromBean.getChildren(); + if(treeNodeChildren != null) { + toBean.TreeNode$children = new HashSet<String>(treeNodeChildren); + } + } + + /** + * Method copied from eugengo-0.7 generators + * + * @param impl + * @return + */ + public static TreeNode toBean(TreeNodeImpl impl) { + if (impl == null) return null; + TreeNodeBean bean = new TreeNodeBean(); + AbstractWikittyService.fillBeanAttributes(impl, bean); + return bean; + } +} Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/BusinessEntity.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/BusinessEntity.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/BusinessEntity.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/BusinessEntity.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,81 @@ +/* *##% + * Copyright (c) 2009 Sharengo, Guillaume Dufrene, Benjamin POUSSIN. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + *##%*/ + +package org.nuiton.wikitty; + +import java.io.Serializable; +import java.util.Collection; + +/** + * Used as parent interface to all Business class + * + * @author poussin + * @version $Revision$ + * + * Last update: $Date$ + * by : $Author$ + */ +public interface BusinessEntity extends Serializable, Cloneable { + + public String getWikittyId(); + public String getWikittyVersion(); + /** + * Only framework can use this method + * @param version + */ + public void setWikittyVersion(String version); + + /** + * Return list of all extension for this object + * @return + */ + public Collection<String> getExtensionNames(); + + /** + * Return list of all field for this object + * @param ext + * @return + */ + public Collection<String> getExtensionFields(String ext); + + /** + * Return field value for the specifique extension and field + * @param ext + * @param fieldName + * @return + */ + public Object getField(String ext, String fieldName); + + /** + * set field value for the specifique extension and field. + * This method don't check the type of value for this field. + * @param ext + * @param fieldName + * @param value + * @return + */ + public void setField(String ext, String fieldName, Object value); + + /** + * Return the field type + * @param ext + * @param fieldName + * @return + */ + public FieldType getFieldType(String ext, String fieldName); + +} Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/BusinessEntityBean.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/BusinessEntityBean.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/BusinessEntityBean.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/BusinessEntityBean.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,92 @@ +/* *##% + * Copyright (c) 2009 poussin. All rights reserved. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + *##%*/ + +package org.nuiton.wikitty; + +import java.util.Collection; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.Map; + +/** + * + * @author poussin + * @version $Revision$ + * + * Last update: $Date$ + * by : $Author$ + */ +public class BusinessEntityBean implements BusinessEntity { + + private static final long serialVersionUID = 1L; + + protected String id; + protected String version; + + /** + * Map is LinkedHashMap to maintains order like user want + * key: extension name + * value: extension definition + */ + protected Map<String, WikittyExtension> extensions = + new LinkedHashMap<String, WikittyExtension>(); + /** + * key: field name prefixed by extension name (dot separator) + * value: value of field + */ + protected Map<String, Object> fieldValue = new HashMap<String, Object>(); + + public String getWikittyId() { + return id; + } + + public String getWikittyVersion() { + return version; + } + + public void setWikittyVersion(String version) { + this.version = version; + } + + + public Collection<String> getExtensionNames() { + Collection<String> result = extensions.keySet(); + return result; + } + + public Collection<String> getExtensionFields(String ext) { + WikittyExtension extension = extensions.get(ext); + Collection<String> result = extension.getFieldNames(); + return result; + } + + public Object getField(String ext, String fieldName) { + String key = ext + "$" + fieldName; + Object result = fieldValue.get(key); + return result; + } + + public void setField(String ext, String fieldName, Object value) { + String key = ext + "$" + fieldName; + fieldValue.put(key, value); + } + + public FieldType getFieldType(String ext, String fieldName) { + throw new UnsupportedOperationException("Not supported yet."); + } + +} Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/BusinessEntityWikitty.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/BusinessEntityWikitty.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/BusinessEntityWikitty.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/BusinessEntityWikitty.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,101 @@ +/* *##% + * Copyright (c) 2009 Sharengo, Guillaume Dufrene, Benjamin POUSSIN. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + *##%*/ + +package org.nuiton.wikitty; + +import java.util.Collection; +import java.util.Collections; + +/** + * + * @author poussin + * @version $Revision$ + * + * Each business object will inherit of this class. + * + * Last update: $Date$ + * by : $Author$ + */ +public class BusinessEntityWikitty implements BusinessEntity { + + private static final long serialVersionUID = 1L; + + protected Wikitty wikitty; + + public BusinessEntityWikitty(Wikitty wi) { + setWikitty(wi); + } + + public BusinessEntityWikitty() { + setWikitty(new Wikitty()); + } + + public String getWikittyId() { + String result = getWikitty().getId(); + return result; + } + + public String getWikittyVersion() { + String result = getWikitty().getVersion(); + return result; + } + + public void setWikittyVersion(String version) { + getWikitty().setVersion(version); + } + + public void setWikitty(Wikitty wikitty) { + if(wikitty != null) { + for (WikittyExtension ext : getStaticExtensions()) { + wikitty.addExtension(ext); + } + } + this.wikitty = wikitty; + } + + public Wikitty getWikitty() { + return wikitty; + } + + public Collection<String> getExtensionNames() { + Collection<String> result = getWikitty().getExtensionNames(); + return result; + } + + public Collection<String> getExtensionFields(String ext) { + Collection<String> result = getWikitty().getExtension(ext).getFieldNames(); + return result; + } + + public FieldType getFieldType(String ext, String fieldName) { + FieldType result = getWikitty().getExtension(ext).getFieldType(fieldName); + return result; + } + + public Object getField(String ext, String fieldName) { + Object result = getWikitty().getFieldAsObject(ext, fieldName); + return result; + } + + public void setField(String ext, String fieldName, Object value) { + getWikitty().setField(ext, fieldName, value); + } + + public Collection<WikittyExtension> getStaticExtensions() { + return Collections.emptyList(); + } +} Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/Criteria.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/Criteria.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/Criteria.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/Criteria.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,236 @@ +/* *##% + * Copyright (c) 2009 Sharengo, Guillaume Dufrene, Benjamin POUSSIN. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + *##%*/ + +package org.nuiton.wikitty; + +import java.beans.XMLDecoder; +import java.beans.XMLEncoder; +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.InputStream; +import java.io.OutputStream; +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.nuiton.wikitty.search.Restriction; + +/** + * Criteria represent the search on the wikitty with restriction on field and + * informations on facet, paggination and sortting. + *<p> + * For search multiple extension use ALL_EXTENSIONS as extension name and + * specify field type. + * <p> + * Example : Criteria.ALL_EXTENSIONS + Criteria.SEPARATOR + <fieldName> + Criteria.SEPARATOR + FieldType.TYPE.<fieldType> + * + * @author poussin + * @version $Revision$ + * + * Last update: $Date$ + * by : $Author$ + */ +public class Criteria implements Serializable { + + /** serialVersionUID. */ + private static final long serialVersionUID = 2590223960861630283L; + + /** to use log facility, just put in your code: log.info(\"...\"); */ + static private Log log = LogFactory.getLog(Criteria.class); + + /** Use to not limit result */ + static public int ALL_ELEMENTS = -1; + + /** Search on all extension */ + static public String ALL_EXTENSIONS = "*"; + + /** Search on all values */ + static public String ALL_VALUES = "*"; + + /** Separator between extension name, field name and type */ + static public String SEPARATOR = "."; + + /** + * Criteria can have name this help for presentation and is very + * useful for facet created by criteria + */ + protected String name; + + /** All restriction on fields */ + private Restriction restriction; + + /** First index to get result */ + private int firstIndex = 0; + /** Last index to get result */ + private int endIndex = ALL_ELEMENTS; + + /** Facet on criteria */ + private List<Criteria> facetCriteria; + /** Facet on field */ + private List<String> facetField; + + /** Sort ascending on fields */ + private List<String> sortAscending; + /** Sort descending on fields */ + private List<String> sortDescending; + + /** + * Default constuctor + */ + public Criteria() { + } + + /** + * Create named criteria + * @param name + */ + public Criteria(String name) { + this.name = name; + } + + /** + * Deserialize xml to criteria + * @param xml + * @return criteria + */ + public static Criteria fromXML(String xml) { + InputStream inputStream = new ByteArrayInputStream(xml.getBytes()); + XMLDecoder decoder = new XMLDecoder(inputStream); + Criteria criteria = (Criteria) decoder.readObject(); + return criteria; + } + + /** + * Serialize criteria to xml + * @param criteria + * @return xml string + */ + public static String toXML(Criteria criteria) { + OutputStream outputStream = new ByteArrayOutputStream(); + XMLEncoder encoder = new XMLEncoder(outputStream); + encoder.writeObject(criteria); + encoder.close(); + String result = outputStream.toString(); + return result; + } + + public Restriction getRestriction() { + return restriction; + } + + public void setRestriction(Restriction restriction) { + this.restriction = restriction; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public int getFirstIndex() { + return firstIndex; + } + + public Criteria setFirstIndex(int firstIndex) { + this.firstIndex = firstIndex; + return this; + } + + public int getEndIndex() { + return endIndex; + } + + public Criteria setEndIndex(int endIndex) { + this.endIndex = endIndex; + return this; + } + + public List<Criteria> getFacetCriteria() { + return facetCriteria; + } + + public Criteria addFacetCriteria(Criteria criteria) { + if (facetCriteria == null) { + facetCriteria = new ArrayList<Criteria>(); + } + facetCriteria.add(criteria); + return this; + } + + public Criteria setFacetCriteria(Criteria[] facetCriteria) { + this.facetCriteria = Arrays.asList(facetCriteria); + return this; + } + + public List<String> getFacetField() { + return facetField; + } + + public Criteria addFacetField(String field) { + if (facetField == null) { + facetField = new ArrayList<String>(); + } + facetField.add(field); + return this; + } + + public Criteria setFacetField(String[] facetField) { + this.facetField = Arrays.asList(facetField); + return this; + } + + public List<String> getSortAscending() { + return sortAscending; + } + + public Criteria addSortAscending(String field) { + if(sortAscending == null) { + sortAscending = new ArrayList<String>(); + } + sortAscending.add(field); + return this; + } + + public Criteria setSortAscending(String[] sortAscending) { + this.sortAscending = Arrays.asList(sortAscending); + return this; + } + + public List<String> getSortDescending() { + return sortDescending; + } + + public Criteria addSortDescending(String field) { + if(sortDescending == null) { + sortDescending = new ArrayList<String>(); + } + sortDescending.add(field); + return this; + } + + public Criteria setSortDescending(String[] sortDescending) { + this.sortDescending = Arrays.asList(sortDescending); + return this; + } + +} Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/ExtensionFactory.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/ExtensionFactory.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/ExtensionFactory.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/ExtensionFactory.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,38 @@ +package org.nuiton.wikitty; + +import java.util.LinkedHashMap; + +import org.nuiton.wikitty.FieldType.TYPE; + +public class ExtensionFactory { + + private String name; + private String version; + private String requiredExtension; + + private LinkedHashMap<String, FieldType> fields; + + private ExtensionFactory(String name, String version) { + this.name = name; + this.version = version; + this.fields = new LinkedHashMap<String, FieldType>(); + } + + public static ExtensionFactory create(String name, String version) { + return new ExtensionFactory(name, version); + } + + public FieldFactory addField(String name, TYPE fieldType) { + return new FieldFactory(this, name, fieldType); + } + + public WikittyExtension extension() { + WikittyExtension ext = new WikittyExtension(name, version, requiredExtension, fields); + return ext; + } + + protected void add(String fieldName, FieldType fieldType) { + fields.put(fieldName, fieldType); + } + +} Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/FacetTopic.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/FacetTopic.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/FacetTopic.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/FacetTopic.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,62 @@ +/* *##% + * Copyright (c) 2009 poussin. All rights reserved. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + *##%*/ + +package org.nuiton.wikitty; + + +import java.io.Serializable; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +/** + * + * @author poussin + * @version $Revision$ + * + * Last update: $Date$ + * by : $Author$ + */ +public class FacetTopic implements Serializable { + + /** to use log facility, just put in your code: log.info(\"...\"); */ + static private Log log = LogFactory.getLog(FacetTopic.class); + + private static final long serialVersionUID = 1L; + + protected String facetName; + protected String topicName; + protected int count; + + public FacetTopic(String facetName, String topicName, int count) { + this.facetName = facetName; + this.topicName = topicName; + this.count = count; + } + + public String getFacetName() { + return facetName; + } + + public String getTopicName() { + return topicName; + } + + public int getCount() { + return count; + } + +} Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/FieldFactory.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/FieldFactory.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/FieldFactory.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/FieldFactory.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,63 @@ +package org.nuiton.wikitty; + +import java.util.HashMap; +import java.util.Map; + +import org.nuiton.wikitty.FieldType.TYPE; + +public class FieldFactory { + + private ExtensionFactory parentFactory; + private String fieldName; + private TYPE type; + private int minOccur = 0, maxOccur = 1; + private boolean unique = false; + private Map<String, String> tagValues = new HashMap<String, String>(); + + public FieldFactory(ExtensionFactory parentFactory, String fieldName, TYPE type) { + this.parentFactory = parentFactory; + this.fieldName = fieldName; + this.type = type; + } + + public FieldFactory addField(String name, TYPE type) { + append(); + return parentFactory.addField(name, type); + } + + public WikittyExtension extension() { + append(); + return parentFactory.extension(); + } + + private void append() { + FieldType fieldType = new FieldType(type, minOccur, maxOccur, unique, minOccur > 0); + for (Map.Entry<String, String> entry : tagValues.entrySet()) { + String tag = entry.getKey(); + String value = entry.getValue(); + fieldType.addTagValue(tag, value); + } + parentFactory.add(fieldName, fieldType); + } + + public FieldFactory maxOccur(int max) { + maxOccur = max; + return this; + } + + public FieldFactory minOccur(int min) { + minOccur = min; + return this; + } + + public FieldFactory unique() { + unique = true; + return this; + } + + public FieldFactory addTagValue(String tag, String value) { + tagValues.put(tag, value); + return this; + } + +} Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/FieldType.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/FieldType.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/FieldType.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/FieldType.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,234 @@ +/* *##% + * Copyright (c) 2009 Sharengo, Guillaume Dufrene, Benjamin POUSSIN. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + *##%*/ + +package org.nuiton.wikitty; + + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.LinkedHashSet; +import java.util.Map; +import java.util.Set; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +/** + * + * @author poussin + * @version $Revision$ + * + * Last update: $Date$ + * by : $Author$ + */ +public class FieldType implements Serializable { + + static public enum TYPE { + BOOLEAN, DATE, NUMERIC, STRING, WIKITTY; + + /** + * convert string to TYPE, this methode accept not trimed and not well + * cased string (difference with valueOf) + * @param name + * @return TYPE else exception is throw + */ + public static TYPE parse(String name) { + TYPE result = valueOf(name.trim().toUpperCase()); + return result; + } + } + + /** to use log facility, just put in your code: log.info(\"...\"); */ + static private Log log = LogFactory.getLog(FieldType.class); + + private static final long serialVersionUID = 1L; + + public static final int NOLIMIT = Integer.MAX_VALUE; + + TYPE type; + int lowerBound; + int upperBound; + boolean unique = false; + boolean notNull = false; + + /** used to store tag/value used by client side ex: editor=xhtml */ + Map<String, String> tagValues = new HashMap<String, String>(); + + public FieldType() { + } + + public FieldType(TYPE type, int lowerBound, int upperBound) { + this.type = type; + this.lowerBound = lowerBound; + this.upperBound = upperBound; + } + + public FieldType(TYPE type, int lowerBound, int upperBound, boolean unique, boolean notNull) { + this.type = type; + this.lowerBound = lowerBound; + this.upperBound = upperBound; + this.unique = unique; + this.notNull = notNull; + } + + public void addTagValue(String tag, String value) { + tagValues.put(tag, value); + } + + public String getTagValue(String tag) { + String result = tagValues.get(tag); + return result; + } + + public Set<String> getTagNames() { + return tagValues.keySet(); + } + + public Map<String, String> getTagValues() { + return tagValues; + } + + public void setTagValues(Map<String, String> tagValues) { + this.tagValues = tagValues; + } + + /** + * Return true if this field have upperBound > 1 + * @return + */ + public boolean isCollection() { + return upperBound > 1; + } + + /** + * Return string definition for this field + * @param name field name used for definition + * @return + */ + public String toDefinition(String name) { + String result = type + " " + name; + if (lowerBound != 0 || upperBound != 0) { + if (upperBound != NOLIMIT) { + result += "[" + lowerBound + "-" + upperBound + "]"; + } else { + result += "[" + lowerBound + "-*]"; + } + } + if (isUnique()) { + result += " unique"; + } + if (isNotNull()) { + result += " not null"; + } + result += WikittyUtil.tagValuesToString(tagValues); + return result; + } + + /** + * Convert value in argument in right type for this FieldType. Don't support + * collection + * + * @param value value to convert + * @return object in type of this FieldType + */ + protected Object getContainedValidObject( Object value ) { + Object result = null; + switch (type) { + case DATE: + result = WikittyUtil.toDate(value); break; + case NUMERIC: + result = WikittyUtil.toBigDecimal(value); break; + case BOOLEAN: + result = WikittyUtil.toBoolean(value); break; + case STRING: + result = WikittyUtil.toString(value); break; + default: + // if type is not found then type is business type + // and is wikity object + result = WikittyUtil.toWikitty(value); break; + } + return result; + } + + /** + * Return a valid value for this field. + * @param value is casted if possible to an actual correct value. + * @return + */ + public Object getValidValue( Object value ) throws WikittyException { + if (value == null && isNotNull()) { + throw new WikittyException("Value can't be null for this field"); + } + + Object result; + if (value == null) { + result = null; + } else if (isCollection()) { + if ( !(value instanceof Collection) ) { + throw new WikittyException( "A collection is expected for type " + + type.name() + "[" + lowerBound + " - " + upperBound + "]" ); + } + Collection<Object> col; + if (isUnique()) { + col = new LinkedHashSet<Object>(); + } else { + col = new ArrayList<Object>(); + } + + // copy all value in new collections + for ( Object o : (Collection) value ) { + col.add( getContainedValidObject(o) ); + } + result = col; + } else { + result = getContainedValidObject(value); + } + return result; + } + + /** + * test if value in argument is valide for this field type + * @param value to test + * @return true if value is valid + */ + public boolean isValidValue(Object value) { + return getValidValue(value) != null; + } + + public TYPE getType() { + return type; + } + + public int getLowerBound() { + return lowerBound; + } + + public int getUpperBound() { + return upperBound; + } + + public boolean isUnique() { + return unique; + } + + public boolean isNotNull() { + return notNull; + } + +} Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/JobState.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/JobState.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/JobState.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/JobState.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,41 @@ +/* *##% + * Copyright (c) 2009 Sharengo, Guillaume Dufrene, Benjamin POUSSIN. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + *##%*/ + +package org.nuiton.wikitty; + + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +/** + * + * @author poussin + * @version $Revision$ + * + * Last update: $Date$ + * by : $Author$ + */ +public class JobState { + + /** to use log facility, just put in your code: log.info(\"...\"); */ + static private Log log = LogFactory.getLog(JobState.class); + + String status; // or enum + /** if is an export, resourceUri is not null when job is ended */ + String resourceUri; // generated resource URI on that job + +} Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/Package.html (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/Package.html) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/Package.html (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/Package.html 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,203 @@ +<h1>Wikitty API documentation</h1> + +<h2>Extensions version management</h2> + +The extension version number have to be managed by the developer who writes or +modify the extension. + +When we modify an extension in a model, a developer have to remember to update +the version tag/value. + +<h2>Objects deletion management</h2> + +The objects deleted are only marked as deleted, like that it will be possible to +restore a deleted object in future implementations. + +The deleted objects are not indexed anymore (and so do not appear in search +results). + +If we try to get a deleted object by its id, null is returned. + +We cannot save a deleted object until we do a undelete on it. + +<h2>Wikitties attributes</h2> + +It is possible to define several things for a wikitty field : + +<ul> + <li>its type (String)</li> + <li>its name (String)</li> + <li>its cardinality ([1-n])</li> + <li>if it is unique (unique), for the lists it will be reprensted by a Set, for + not-list objects it means that two objects cannot have the same value for + this field (constraint not implemented for now). + </li> + <li>if it has to be not null, there is no mean, in the modeler to indicate it, + and so it is not possible to generate it. + </li> + <li>Tag/values (tag=value). It is possible to create as many tag/values as we + want. You can then get them by FieldType.getTagValue(tagName). This can be + useful to put a tag 'editor' used by UI and that allows to put a specific + editor for a field (e.g. a html editor for a String field) + </li> +</ul> + +<h2>PropertyChangeListener</h2> + +The field modification listeners management is diretly done by the wikitty +object. The name of the field is the concatenation of the extension name and the +field name ([extName].[fieldName]). + +<h2>Search API</h2> + +<h3>General points</h3> + +The search are made by example (a model dto), or from a search 'Criteria' object. + +This criteria contains restrictions that will be turned into searhc request. + +The criteria can be built from the utility class 'Search' that allows to express, +via instructions, all the restrictions. + +The Search operations return a reference to an object of the same type allowing +to continue expressing other criteria. + +This allows to write quickly and easily search expressions with the Search API's +help (and auto-completion will help even more). + +The Search operations names are really short and syntaxically close to bash +conditional expressions... + +<h3>List of criteria operations</h3> +We will find : <ul> + <li> eq : to express equality</li> + <li> neq : to express difference (not equals)</li> + <li> le, lt : respectively for inclusive and exclusive inferiority operations + (less than, less or equals)</li> + <li> ge, gt : respectively for inclusive and exclusive superiority operations + (greater than, greater or equals)</li> + <li> sw : to express an expression beginning (start with)</li> + <li> ew : to express an expression ending (end with)</li> + <li> in : to express a list of possible values</li> +</ul> + +<h3>Disjunction operation, disjunction group</h3> +By default, each restrictions express by the above expressions are added to a +list of conjunctions (logical AND). + +It is possible to express disjunctions (logical OR) using the or operation. + +The restriction following the or is then in disjunction with the one preceding +it. + +If other restrictions are added after that, they are attached to the previous +conjunction. + +To express a group of disjunction, we can call the or operation between each +restriction or call the group operation with the 'OR' type. + +In this last case, you will need to close the groupe by calling the end operation. + +<h3>Associative search</h3> +It is possible to express associative search, i.e. search for which some criteria +are based on objects linked by a reference (link or foreign key notion). + +Then, the associated (fieldName) operation allows to +Il est possible d'exprimer des recherches associatives, c'est à dire des recherches pour lesquelles certains critères portent sur un objet lié par une référence (notion de lien, ou de clé étrangère).<br> +Ainsi, l'opération associated( fieldName ) permet de faire porter les critères suivant cette opération sur les objets lié via ce champ.<br> +Le résultat sera une conjonction (ET) entre les critères exprimés avant l'opération associated sur l'objet 'principal' (il peut ne pas y en avoir), et dont la ou les références associée répondent aux critères exprimés après le associated.<br> +Tout cela est beaucoup plus clair par l'exemple ;-)<br> + +I want to find all paints between 15 and 25 euros in the Hardware section. + +This search can be expressed ina more concrete way using API via : + +"I search all products wich price is between 15 and 25 euros, which name starts +by 'Paint', and which associated section, using the 'section' field, have the +name 'Hardware'". + +It is built using the following operations : + +<pre> + RestrictionDto dto = Search.query() + .bw( "Product.selling_price", "15", "25") + .sw( "Produit.article_name", "Paint") + .associated( "Product.section" ) + .eq( "Section.name", "Hardware" ) + .criteria(); +</pre> + + +<h2>Data migration</h2> + +When the list of wikitty extensions is modified, either: +<ul> + <li>we deleted an extension, the data stays in the wikitty</li> + <li>we added an extension, nothing is done but we can add data for the new + fields</li> + <li>we modified an extension + <li>deleted an extension field : the data stays but are no more + accessible</li> + <li>added a field to the extension : nothing is done but we can add data + for the new field</li> + <li>modified a field type: + <ul> + <li>API knows how to convert it, nothing to do (e.g. int->String)</li> + <li>The type has been deeply modified (e.g. String->List<int<): + you have to implement an extension migration sub-class + (WikittyExtensionMigration) and save it so that it is used when + necessary.</li> + </ul> + </li> +</ul> + +<p>An object is converted when it is loaded in its BusinessEntity, but is is not + automatically save, it is saved only if a store is called on the client side. +</p> + +<p>It is also possible to force the migration searching all the objects with the +modified extension, load them in WikittyDtos and save them.</p> +<pre> +Wikitty w = new Wikitty(); +w.addExtension(myModifiedExtension); +WikittyDto dto = new WikittyDto(w); +PagedResult<WikittyDto> result = proxy.findAllByExample(dto, 0, Proxy.ALL_ELEMENTS); +proxy.store(result.getAll()); +</pre> + +<h2>Import Wikitties</h2> + +When importing XML file, if an object has a version nmber, then if in the +database there is no object or if the object has a version number less or equal +than the imported version number, the xml file data overwrite the database data. + +If the database version number is greater than the imported version number, the +imported object is rejected and an exception is thrown. + +If the imported object had no version number, in all cases, it overwrite the +database data and the object version number is incremented if it was present in +database. + +Modifications to do on implementation : +<ul> + <li>During xml file reading and loading into wikitty object, if there is no + version number in xml flux, the version number is null instead of + defaultversion.</li> + <li>Take into account that during wikitty save, the version number can be + null, do the appropriate treatment</li> +</ul> + +If an object in database was deleted and we try to import it, we throw an +exception. + +<h2>TODO</h2> +<ul> +<li>while generating BusinessEntity, if 2 extensions have the same method, + suffix the next ones with xxxxxxForExtensionName</li> +<li>Think about object search problem if its extensions have been modified. + If you do a search by example, we add the extension list in the request, the + new BusinessEntity has more extensions, we do not find the old objects. If + we do a search by criteria/example, the criterie field cannot exist in the + index and so the object is not returned in results even if we put '*' as + field value.</li> +</ul> \ No newline at end of file Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/PagedResult.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/PagedResult.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/PagedResult.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/PagedResult.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,189 @@ +/* *##% + * Copyright (c) 2009 Sharengo, Guillaume Dufrene, Benjamin POUSSIN. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + *##%*/ + +package org.nuiton.wikitty; + + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.Map; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +/** + * + * @author poussin + * @version $Revision$ + * + * Last update: $Date$ + * by : $Author$ + */ +public class PagedResult<T> implements Serializable { + + /** to use log facility, just put in your code: log.info(\"...\"); */ + static private Log log = LogFactory.getLog(PagedResult.class); + + private static final long serialVersionUID = 1L; + + /** indice element in global search result */ + protected int firstIndice; + /** total number of result if we call the query for all possible result */ + protected int numFound; + /** query really executed */ + protected String queryString; + /** list of result in the wanted interval */ + protected List<T> results; + /** facet asked or null if no facet */ + protected Map<String, List<FacetTopic>> facets; + + public PagedResult(int FirstIndice, int numFound, String queryString, + Map<String, List<FacetTopic>> facets, List<T> results) { + this.firstIndice = FirstIndice; + this.numFound = numFound; + this.queryString = queryString; + this.facets = facets; + this.results = Collections.unmodifiableList(results); + } + + /** + * Converte all result to the wanted type and return new PagedResult with + * this new result list. If some result don't have the right extension (clazz) + * this extension is automatically added if autoconvert is true. Else + * an exception is throwed when result without extension is found. + * + * When you used autoconvert = false, you have a potentialy probleme when + * you have modified a BusinessEntity to have new extension and all your + * wikitty object are not uptodate in database. + * + * @param clazz + * @param autoconvert + * @return + */ + public <E extends BusinessEntityWikitty> PagedResult<E> cast( + WikittyService wikittyService, Class<E> clazz, boolean autoconvert) { + List<E> castedResult = new ArrayList<E>(results.size()); + E sample = WikittyUtil.newInstance(clazz); + Collection<WikittyExtension> wantedExtension = sample.getStaticExtensions(); + for (T t : results) { + if (t == null) { + castedResult.add(null); + } else { + Wikitty w = null; + if (t instanceof Wikitty) { + w = (Wikitty)t; + } else if (t instanceof BusinessEntityWikitty) { + w = ((BusinessEntityWikitty) t).getWikitty(); + } else { + throw new WikittyException(String.format( + "Illegal object result class '%s' can't convert it to wikitty", + t.getClass().getName(), clazz.getName())); + } + + Collection<WikittyExtension> wikittyExtension = w.getExtensions(); + if (autoconvert || wikittyExtension.containsAll(wantedExtension)) { + E e = WikittyUtil.newInstance(wikittyService, clazz, (Wikitty) t); + castedResult.add(e); + } else { + throw new WikittyException(String.format( + "Illegal object result class '%s' can't convert it to '%s'" + + "there is no same extension %s != %s", + t.getClass().getName(), clazz.getName(), + wikittyExtension, wantedExtension)); + } + } + } + PagedResult<E> result = new PagedResult<E>( + firstIndice, numFound, queryString, facets, castedResult); + return result; + } + + public int getFirstIndice() { + return firstIndice; + } + + public int getNumFound() { + return numFound; + } + + public String getQueryString() { + return queryString; + } + + /** + * Return name of all facet used in query + * @return + */ + public Collection<String> getFacetNames() { + Collection<String> result = facets.keySet(); + return result; + } + + /** + * Return all topic for the specified facet + * @param facetName name of the wanted facet + * @return + */ + public List<FacetTopic> getTopic(String facetName) { + List<FacetTopic> result = facets.get(facetName); + return result; + } + + /** + * Get map represent facets + * @return + */ + public Map<String, List<FacetTopic>> getFacets() { + return facets; + } + + /** + * Return the firstIndice element in result or throw an exception if no element + * available + * @return + */ + public T getFirst() { + T result = get(0); + return result; + } + + public T get(int i) { + T result = results.get(i); + return result; + } + + /** + * Return unmodifiable list of all result + * @return + */ + public List<T> getAll() { + return results; + } + + /** + * Return the number of result in this object + * @return + */ + public int size() { + int result = results.size(); + return result; + } + +} Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/Tree.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/Tree.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/Tree.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/Tree.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,32 @@ +package org.nuiton.wikitty; + +import java.util.ArrayList; +import java.util.List; +import java.util.Set; + +import org.nuiton.wikitty.TreeNode; + +public class Tree { + + TreeNode node; + List<Tree> children; + + public void setNode(TreeNode node) { + this.node = node; + } + + public void addChild(Tree tree) { + getChildren().add( tree ); + } + + public List<Tree> getChildren() { + if ( children == null ) { + children = new ArrayList<Tree>(); + } + return children; + } + + public String getName() { + return node.getName(); + } +} Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/UpdateResponse.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/UpdateResponse.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/UpdateResponse.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/UpdateResponse.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,75 @@ +package org.nuiton.wikitty; + +import java.util.Date; +import java.util.HashMap; +import java.util.Map; + +public class UpdateResponse { + + protected Map<String, String> idVersionMap = new HashMap<String, String>(); + protected Map<String, Date> idDeletionDateMap = new HashMap<String, Date>(); + + public UpdateResponse() { + super(); + idVersionMap = new HashMap<String, String>(); + } + + /** + * Merge all update passed in argument in local update list + * @param update + */ + public void add(UpdateResponse update) { + idVersionMap.putAll(update.idVersionMap); + idDeletionDateMap.putAll(update.idDeletionDateMap); + } + + public void addVersionUpdate( String id, String version ) { + idVersionMap.put(id, version); + } + + public void addDeletionDateUpdate(String id, Date date) { + idDeletionDateMap.put(id, date); + } + + public void update(BusinessEntity e) { + if (e instanceof BusinessEntityWikitty) { + update((BusinessEntityWikitty) e); + } else if (e instanceof BusinessEntityBean) { + update((BusinessEntityBean) e); + } + } + + public void update(BusinessEntityBean e) { + // update version + String id = e.getWikittyId(); + String version = idVersionMap.get(id); + if (version != null) { + e.setWikittyVersion(version); + } + } + + public void update(BusinessEntityWikitty e) { + update(e.getWikitty()); + } + + /** + * Update data directly in object passed in argument. + * Actualy only version and deletion date are updated. + * And internaly wikitty object is marked clean (not dirty) + * @param e + */ + public void update(Wikitty e) { + // update version + String id = e.getId(); + String version = idVersionMap.get(id); + if (version != null) { + e.setVersion(version); + } + Date date = idDeletionDateMap.get(id); + if (date != null) { + e.setDeleteDate(date); + } + e.clearDirty(); + } + +} Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/Wikitty.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/Wikitty.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/Wikitty.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/Wikitty.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,636 @@ +/* *##% + * Copyright (c) 2009 Sharengo, Guillaume Dufrene, Benjamin POUSSIN. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + *##%*/ + +package org.nuiton.wikitty; + +import java.beans.PropertyChangeListener; +import java.beans.PropertyChangeSupport; +import java.io.Serializable; +import java.math.BigDecimal; +import java.util.AbstractList; +import java.util.AbstractSet; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Date; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; + +/** + * + * @author poussin + * @version $Revision$ + * + * Last update: $Date$ + * by : $Author$ + */ +public class Wikitty implements Serializable { + + private static final long serialVersionUID = 1L; + + /** + * technical id for this wikitty object. id must be never null + */ + protected String id; + /** current version of this wikitty object */ + protected String version = WikittyUtil.DEFAULT_VERSION; + /** if not null, date of deletion, if date this object is marked as deleted */ + protected Date deleteDate = null; + + /** used to add property change support to wikitty object */ + protected transient PropertyChangeSupport propertyChange = new PropertyChangeSupport(this); + + /** + * key: field name prefixed by extension name (dot separator) + * value: value of field + */ + protected HashMap<String, Object> fieldValue = new HashMap<String, Object>(); + /** + * all field name currently modified (field name = extension . fieldname) + */ + protected Set<String> fieldDirty = new HashSet<String>(); + /** + * Map is LinkedHashMap to maintains order like user want + * key: extension name + * value: extension definition + */ + protected Map<String, WikittyExtension> extensions = + new LinkedHashMap<String, WikittyExtension>(); + + + public Wikitty() { + this(null); + } + + public Wikitty(String id){ + if(id == null) { + this.id = WikittyUtil.genUID(); + } else { + this.id = id; + } + } + + public synchronized void addPropertyChangeListener( + PropertyChangeListener listener) { + propertyChange.addPropertyChangeListener(listener); + } + + + public synchronized void removePropertyChangeListener( + PropertyChangeListener listener) { + propertyChange.removePropertyChangeListener(listener); + } + + + public synchronized void addPropertyChangeListener(String propertyName, + PropertyChangeListener listener) { + propertyChange.addPropertyChangeListener(propertyName, listener); + } + + + public synchronized void removePropertyChangeListener(String propertyName, + PropertyChangeListener listener) { + propertyChange.removePropertyChangeListener(propertyName, listener); + } + + public String getId() { + return id; + } + + public boolean isDeleted() { + boolean result = deleteDate != null; + return result; + } + + public Date getDeleteDate() { + return deleteDate; + } + + /** + * Server only used + * @param delete + */ + public void setDeleteDate(Date delete) { + this.deleteDate = delete; + } + + /** + * mark field as dirty + * @param ext + * @param fieldName + */ + protected void setFieldDirty(String ext, String fieldName, + Object oldValue, Object newValue) { + String key = ext + "." + fieldName; + fieldDirty.add(key); + version = WikittyUtil.incrementMinorRevision(version); + propertyChange.firePropertyChange(key, oldValue, newValue); + } + + public void addExtension(WikittyExtension ext) { + String required = ext.getRequires(); + if (required != null && !required.isEmpty() && + !extensions.containsKey(required)) { + throw new WikittyException(String.format( + "You try to add extension '%s' that" + + " required not available extension '%s' in this wikitty", + ext.getName(), required)); + } + extensions.put(ext.name, ext); + } + + public void addExtension(List<WikittyExtension> exts) { + for (WikittyExtension ext : exts) { + extensions.put(ext.name, ext); + } + } + + public boolean hasExtension(String extName) { + return extensions.containsKey(extName); + } + + public boolean hasField(String extName, String fieldName) { + boolean result = false; + WikittyExtension ext = extensions.get(extName); + if (ext != null) { + result = ext.getFieldType(fieldName) != null; + } + return result; + } + + public WikittyExtension getExtension(String ext) { + WikittyExtension result = extensions.get(ext); + return result; + } + + public Collection<String> getExtensionNames() { + Collection<String> result = extensions.keySet(); + return result; + } + + public Collection<WikittyExtension> getExtensions() { + Collection<WikittyExtension> result = extensions.values(); + return result; + } + + public Collection<WikittyExtension> getExtensionDependencies(String ext, boolean recursively) { + Collection<WikittyExtension> result = new HashSet<WikittyExtension>(); + Collection<WikittyExtension> all = extensions.values(); + for (WikittyExtension dependency : all) { + String requires = dependency.getRequires(); + if(requires != null && !requires.isEmpty() && requires.equals(ext)) { + result.add(dependency); + if(recursively) { + String dependencyName = dependency.getName(); + Collection<WikittyExtension> dependencies = getExtensionDependencies(dependencyName, recursively); + result.addAll(dependencies); + } + } + } + return result; + } + + /** + * return field type for the given fieldName. + * @param fieldName fully qualified fieldName extension.fieldname + * @return field type + */ + public FieldType getFieldType(String fqfieldName) { + try { + String[] field = fqfieldName.split("\\."); + WikittyExtension ext = getExtension(field[0]); + if (ext == null) { + throw new WikittyException(String.format( + "extension '%s' doesn't exists", field[0])); + } else { + String fieldName = field[1]; + int crochet = fieldName.indexOf("["); + if (crochet != -1) { + fieldName = fieldName.substring(0, crochet); + } + FieldType result = ext.getFieldType(fieldName); + if (result == null) { + throw new WikittyException(String.format( + "field '%s' doesn't exists on extension '%s'", fieldName, field[0])); + + } + return result; + } + } catch (Exception eee) { + throw new WikittyException( + String.format("Field %s is not a fully qualified field name", fqfieldName), + eee + ); + } + } + + public void setField(String ext, String fieldName, Object value) { + if (! hasField(ext, fieldName)) { + String def = ""; + for ( WikittyExtension extension : extensions.values() ) { + def += extension.toDefinition() + "\n"; + } + throw new WikittyException(String.format( + "field '%s' is not valid, extensions definition : %s", ext + "." + fieldName, def)); + } + String key = ext + "." + fieldName; + + // take old value if needed + Object oldValue = null; + if (propertyChange.hasListeners(key)) { + oldValue = fieldValue.get(key); + } + + // put new value + FieldType fieldType = getExtension(ext).getFieldType(fieldName); + Object validValue = fieldType.getValidValue(value); + fieldValue.put(key, validValue); + + // mark field dirty and call listener + setFieldDirty(ext, fieldName, oldValue, validValue); + } + + public Object getFieldAsObject(String ext, String fieldName) { + if (!hasField(ext, fieldName)) { + throw new WikittyException(String.format( + "field '%s' is not a valid field", + ext + "." + fieldName)); + } + String key = ext + "." + fieldName; + Object result = fieldValue.get(key); + return result; + } + + public boolean getFieldAsBoolean(String ext, String fieldName) { + Object value = getFieldAsObject(ext, fieldName); + try { + boolean result = WikittyUtil.toBoolean(value); + return result; + } catch (WikittyException eee) { + throw new WikittyException(String.format( + "field '%s' is not a valid boolean", + ext + "." + fieldName), eee); + } + } + + public BigDecimal getFieldAsBigDecimal(String ext, String fieldName) { + Object value = getFieldAsObject(ext, fieldName); + try { + BigDecimal result = WikittyUtil.toBigDecimal(value); + return result; + } catch (WikittyException eee) { + throw new WikittyException(String.format( + "field '%s' is not a valid numeric", + ext + "." + fieldName), eee); + } + } + + public int getFieldAsInt(String ext, String fieldName) { + try { + BigDecimal value = getFieldAsBigDecimal(ext, fieldName); + int result = value.intValue(); + return result; + } catch (WikittyException eee) { + throw new WikittyException(String.format( + "field '%s' is not a valid int", + ext + "." + fieldName), eee); + } + } + + public long getFieldAsLong(String ext, String fieldName) { + try { + BigDecimal value = getFieldAsBigDecimal(ext, fieldName); + long result = value.longValue(); + return result; + } catch (WikittyException eee) { + throw new WikittyException(String.format( + "field '%s' is not a valid int", + ext + "." + fieldName), eee); + } + } + + public float getFieldAsFloat(String ext, String fieldName) { + try { + BigDecimal value = getFieldAsBigDecimal(ext, fieldName); + float result = value.floatValue(); + return result; + } catch (WikittyException eee) { + throw new WikittyException(String.format( + "field '%s' is not a valid float", + ext + "." + fieldName), eee); + } + } + + public double getFieldAsDouble(String ext, String fieldName) { + try { + BigDecimal value = getFieldAsBigDecimal(ext, fieldName); + double result = value.doubleValue(); + return result; + } catch (WikittyException eee) { + throw new WikittyException(String.format( + "field '%s' is not a valid float", + ext + "." + fieldName), eee); + } + } + + public String getFieldAsString(String ext, String fieldName) { + Object value = getFieldAsObject(ext, fieldName); + try { + String result = WikittyUtil.toString(value); + return result; + } catch (WikittyException eee) { + throw new WikittyException(String.format( + "field '%s' is not a valid String", + ext + "." + fieldName), eee); + } + } + + public Date getFieldAsDate(String ext, String fieldName) { + Object value = getFieldAsObject(ext, fieldName); + try { + Date result = WikittyUtil.toDate(value); + return result; + } catch (WikittyException eee) { + throw new WikittyException(String.format( + "field '%s' is not a valid Date", + ext + "." + fieldName), eee); + } + } + + /** + * return wikitty id and not wikitty objet because this method can be call + * on server or client side and it's better to keep conversion between id + * and objet to the caller + * @param ext extension name where this field must to be + * @param fieldName the field name + * @return id of wikitty object or null + * @throws org.nuiton.wikitty.WikittyException + */ + public String getFieldAsWikitty(String ext, String fieldName) { + Object value = getFieldAsObject(ext, fieldName); + String result = WikittyUtil.toWikitty(value); + return result; + } + + /** + * If object is a set, it is automatically transform to list. + * @param <E> + * @param clazz + * @return unmodifiable list + */ + public <E> List<E> getFieldAsList(String ext, String fieldName, final Class<E> clazz) { + try { + final Collection<E> collection = (Collection<E>) getFieldAsObject(ext, fieldName); + if (collection != null) { + // return unmodiable collection that check type of element + return new AbstractList<E>() { + List<E> contained = new ArrayList<E>(collection); + @Override public E get(int index) { + return WikittyUtil.cast( contained.get(index), clazz ); + } + @Override public int size() { + return contained.size(); + } + }; + } + return null; + } catch (Exception eee) { + throw new WikittyException(String.format( + "Can't add value to field '%s'", + ext + "." + fieldName), eee); + } + } + + /** + * + * @param <E> + * @param clazz + * @return unmodifiable list + */ + public <E> Set<E> getFieldAsSet(String ext, String fieldName, final Class<E> clazz) { + try { + final Set<E> result = (Set<E>) getFieldAsObject(ext, fieldName); + if (result != null) { + // return unmodifable Set + return new AbstractSet<E>() { + Set<E> contained = result; + @Override public int size() { + return contained.size(); + } + @Override + public Iterator<E> iterator() { + return new Iterator<E>() { + Iterator containedIterator = contained.iterator(); + public boolean hasNext() { + return containedIterator.hasNext(); + } + + public E next() { + Object o = containedIterator.next(); + return WikittyUtil.cast(o, clazz); + } + + public void remove() { + throw new UnsupportedOperationException("Not supported operation"); + } + }; + + } + }; + } + return result; + } catch (Exception eee) { + throw new WikittyException(String.format( + "Can't add value to field '%s'", + ext + "." + fieldName), eee); + } + } + + public void addToField(String ext, String fieldName, Object value) { + try { + FieldType fieldType = getExtension(ext).getFieldType(fieldName); + Collection col = (Collection) getFieldAsObject(ext, fieldName); + if (col == null) { + if (fieldType.isUnique()) { + col = new HashSet(); + } else { + col = new ArrayList(); + } + col.add(value); + setField(ext, fieldName, col); + // no call dirty, because already done in setField + } else { + // check upper bound only if col exists, + // because ask upper bound == 0 is ridiculous + + if (fieldType.isUnique()) { + if (!col.contains(value)) { + // only add if not already in collection (unique) + if (col.size() + 1 > fieldType.getUpperBound()) { + // if upper bound reached, throw an exception + throw new WikittyException(String.format( + "Can't add value for field '%s', upper bound is reached", + ext + "." + fieldName)); + } + col.add(value); + setFieldDirty(ext, fieldName, null, col); + } + } else { + if (col.size() + 1 > fieldType.getUpperBound()) { + throw new WikittyException(String.format( + "Can't add value for field '%s', upper bound is reached", + ext + "." + fieldName)); + } + col.add(value); + setFieldDirty(ext, fieldName, null, col); + } + } + } catch (Exception eee) { + throw new WikittyException(String.format( + "Can't add value to field '%s'", + ext + "." + fieldName), eee); + } + } + + public void removeFromField(String ext, String fieldName, Object value) { + try { + Collection col = (Collection) getFieldAsObject(ext, fieldName); + if (col != null) { + FieldType type = getExtension(ext).getFieldType(fieldName); + if (col.contains(value)) { + if (col.size() - 1 < type.getLowerBound()) { + throw new WikittyException(String.format( + "Can't remove value for field '%s', lower bound is reached", + ext + "." + fieldName)); + } else { + if (col.remove(value)) { + // field is dirty only if remove is done + setFieldDirty(ext, fieldName, null, col); + } + } + } + } + } catch (Exception eee) { + throw new WikittyException(String.format( + "Can't remove value for field '%s'", + ext + "." + fieldName), eee); + } + } + + public void clearField(String ext, String fieldName) { + FieldType type = getExtension(ext).getFieldType(fieldName); + if (type.getLowerBound() > 0) { + throw new WikittyException(String.format( + "Can't clear values for field '%s', lower bound is > 0", + ext + "." + fieldName)); + } + try { + Collection col = (Collection) getFieldAsObject(ext, fieldName); + if (col != null) { + col.clear(); + setFieldDirty(ext, fieldName, null, col); + } + } catch (Exception eee) { + throw new WikittyException(String.format( + "Can't clear value for field '%s'", + ext + "." + fieldName), eee); + } + } + + @Override + public boolean equals(Object obj) { + boolean result = false; + if (obj instanceof Wikitty) { + Wikitty other = (Wikitty) obj; + result = id.equals(other.id); + } + return result; + } + + @Override + public int hashCode() { + if (id == null) { + return super.hashCode(); + } else { + return id.hashCode(); + } + } + + public Set<String> fieldNames() { + return fieldValue.keySet(); + } + + public Object getFqField(String fqFieldName) { + return fieldValue.get(fqFieldName); + } + + public String getVersion() { + return version; + } + + /** + * Server only used + * @param version + */ + public void setVersion(String version) { + this.version = version; + } + + /** + * Server only used + * @param version + */ + public void clearDirty() { + fieldDirty.clear(); + } + + /** + * Server only used + * @param fieldName fqn (ex: extensionName.fieldName) + * @param value new value + */ + public void setFqField(String fieldName, Object value) { + FieldType fieldType = getFieldType(fieldName); + Object validValue = fieldType.getValidValue(value); + fieldValue.put(fieldName, validValue); + } + + public boolean isEmpty() { + return fieldValue.isEmpty(); + } + + @Override + public String toString() { + boolean cr = true; + String str = "[" + getId() + ":" + getVersion() + "] {"; + for ( String extName : getExtensionNames() ) { + WikittyExtension ext = getExtension(extName); + str += (cr ? "\n" : "") + "\t<" + extName + ">\n"; + cr = false; + for ( String fieldName : ext.getFieldNames() ) { + str += "\t\t" + fieldName + " = " + getFieldAsString(extName, fieldName) + "\n"; + } + } + str += "}"; + return str; + } + +} Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyDAO.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyDAO.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyDAO.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyDAO.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,189 @@ +package org.nuiton.wikitty; + +import java.lang.reflect.ParameterizedType; +import java.util.Collection; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +public class WikittyDAO<E extends BusinessEntityWikitty> { + + protected static Log log = LogFactory.getLog( WikittyDAO.class ); + + private WikittyProxy proxy; + private Class<E> clazz; + + public WikittyDAO() { + clazz = getActualClassType(); + } + + private Class<E> getActualClassType() { + ParameterizedType type = (ParameterizedType)this.getClass().getGenericSuperclass(); + Class<E> clazz = (Class<E>)type.getActualTypeArguments()[0]; + return clazz; + } + + public void addLabel(String wikittyId, String label) { + proxy.addLabel(wikittyId, label); + } + + public String asyncExportAllByCriteria(Criteria criteria) { + return proxy.asyncExportAllByCriteria(criteria); + } + + public String asyncExportAllByExample(E e) { + return proxy.asyncExportAllByExample(e); + } + + public String asyncImportFromUri(String uri) { + return proxy.asyncImportFromUri(uri); + } + + public void cancelJob(String jobId) { + proxy.cancelJob(jobId); + } + + public void delete(Collection<String> ids) { + proxy.delete(ids); + } + + public void delete(String id) { + proxy.delete(id); + } + + public boolean equals(Object obj) { + return proxy.equals(obj); + } + + public Set<String> findAllAppliedLabels(String wikittyId) { + return proxy.findAllAppliedLabels(wikittyId); + } + + public PagedResult<E> findAll() { + return proxy.findAllByCriteria(clazz, null); + } + + public PagedResult<E> findAllByCriteria(Criteria criteria) { + return proxy.findAllByCriteria(clazz, criteria); + } + + public PagedResult<E> findAllByExample(E e, int firstIndex, int endIndex, String... fieldFacet) { + return proxy.findAllByExample(e, firstIndex, endIndex, fieldFacet); + } + + public PagedResult<Wikitty> findAllByLabel(String label, int firstIndex, int endIndex) { + return proxy.findAllByLabel(label, firstIndex, endIndex); + } + + public E findByCriteria(Criteria criteria) { + return proxy.findByCriteria(clazz, criteria); + } + + public E findByExample(E e) { + return proxy.findByExample(e); + } + + public Wikitty findByLabel(String label) { + return proxy.findByLabel(label); + } + + public void freeJobResource(String jobId) { + proxy.freeJobResource(jobId); + } + + public WikittyService getWikittyService() { + return proxy.getWikittyService(); + } + + public int hashCode() { + return proxy.hashCode(); + } + + public JobState infoJob(String jobId) { + return proxy.infoJob(jobId); + } + + public List<E> restore(List<String> id) { + return proxy.restore(clazz, id, true); + } + + public E restore(String id) { + return proxy.restore(clazz, id, true); + } + + public <E extends BusinessEntity> E restore(String id,Class<E> clazz ) { + return proxy.restore(clazz, id); + } + + public Tree restoreTree(String wikittyId) { + return proxy.restoreTree(wikittyId); + } + + public Map.Entry<E, Integer> restoreNode(String wikittyId) { + return restoreNode(wikittyId, null); + } + + public Map.Entry<E, Integer> restoreNode(String wikittyId, Criteria filter) { + Class<E> clazz = getActualClassType(); + return proxy.restoreNode(clazz, wikittyId, filter, true); + } + + public Map<E, Integer> restoreChildren(String wikittyId) { + return restoreChildren(wikittyId, null); + } + + public Map<E, Integer> restoreChildren(String wikittyId, Criteria filter) { + Class<E> clazz = getActualClassType(); + return proxy.restoreChildren(clazz, wikittyId, filter, true); + } + + public Wikitty restoreVersion(String wikittyId, String version) { + return proxy.restoreVersion(wikittyId, version); + } + + public boolean hasType(String wikittyId) { + Class<E> clazz = getActualClassType(); + return proxy.hasType(clazz, wikittyId); + } + + public void setWikittyService(WikittyService wikittyService) { + proxy.setWikittyService(wikittyService); + } + + public E store(E e) { + return proxy.store(e); + } + + public List<E> store(List<E> objets) { + return proxy.store(objets); + } + + public String syncExportAllByCriteria(Criteria criteria) { + return proxy.syncExportAllByCriteria(criteria); + } + + public String syncExportAllByExample(E e) { + return proxy.syncExportAllByExample(e); + } + + public void syncImportFromUri(String uri) { + proxy.syncImportFromUri(uri); + } + + public void syncImportFromXml(String xml) { + proxy.syncImportFromXml(xml); + } + + public String toString() { + return proxy.toString(); + } + + public void setProxy(WikittyProxy proxy) { + this.proxy = proxy; + } + + +} Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyException.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyException.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyException.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyException.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,44 @@ +/* *##% + * Copyright (c) 2009 Sharengo, Guillaume Dufrene, Benjamin POUSSIN. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + *##%*/ + +package org.nuiton.wikitty; + +/** + * + * @author poussin + * @version $Revision$ + * + * Last update: $Date$ + * by : $Author$ + */ +public class WikittyException extends RuntimeException { + + private static final long serialVersionUID = 1L; + + public WikittyException(String message) { + super(message); + } + + public WikittyException(Exception eee) { + super(eee); + } + + public WikittyException(String message, Exception eee) { + super(message, eee); + } + +} Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyExtension.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyExtension.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyExtension.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyExtension.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,242 @@ +/* *##% + * Copyright (c) 2009 Sharengo, Guillaume Dufrene, Benjamin POUSSIN. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + *##%*/ + +package org.nuiton.wikitty; + +import java.io.Serializable; +import java.util.Collection; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.Set; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +/** + * + * @author poussin + * @version $Revision$ + * + * Last update: $Date$ + * by : $Author$ + */ +public class WikittyExtension implements Serializable { + + /** to use log facility, just put in your code: log.info(\"...\"); */ + static private Log log = LogFactory.getLog(WikittyExtension.class); + + private static final long serialVersionUID = 1L; + + /** + * Name of this extension. + */ + protected String name; + + /** + * Name of other extension needed to put this extension to object. + * + * Warning : Multiples extensions are not supported yet. + * + * FIXME EC-20100420 multiples extensions need to work + */ + protected String requires; + + /** + * use to know version objet, when you change field number, type or other + * you must change version number. + */ + protected String version = WikittyUtil.DEFAULT_VERSION; + + /** used to store tag/value used by client side ex: updatedDate=101212 */ + Map<String, String> tagValues = new HashMap<String, String>(); + + /** + * fields use ordered map, to keep order insertion of field + * key: field name + * value: field type + */ + protected LinkedHashMap<String, FieldType> fields = new LinkedHashMap<String, FieldType>(); + + protected WikittyExtension() { + } + + public WikittyExtension(String name) { + if (name == null) { + throw new IllegalArgumentException("Name must not be null"); + } + this.name = name; + } + + public WikittyExtension(String name, String version, + String requires, LinkedHashMap<String, FieldType> fields) { + if (name == null) { + throw new IllegalArgumentException("Name must not be null"); + } + if (version == null) { + throw new IllegalArgumentException("Version must not be null"); + } + this.name = name; + this.version = WikittyUtil.normalizeVersion(version); + this.requires = requires; + if (fields != null) { + this.fields = fields; + } + } + + public WikittyExtension cloneForUpgrade() { + String nextRevision = WikittyUtil.incrementMajorRevision(getVersion()); + + LinkedHashMap<String, FieldType> nextFields = null; + if (fields != null) { + nextFields = new LinkedHashMap<String, FieldType>(); + for (Map.Entry<String, FieldType> entry : fields.entrySet()) { + FieldType type = entry.getValue(); + FieldType nextType = new FieldType(type.getType(), type.getLowerBound(), type.getUpperBound(), type.isUnique(), type.isNotNull()); + Set<String> tagNames = type.getTagNames(); + if (tagNames != null) { + for (String tagName : tagNames) { + String tagValue = type.getTagValue(tagName); + nextType.addTagValue(tagName, tagValue); + } + } + nextFields.put(entry.getKey(), nextType); + } + } + + WikittyExtension result = new WikittyExtension(name, nextRevision, requires, nextFields); + return result; + } + + /** + * compute id for extension name and version in argument + * @param name + * @param version + * @return + */ + static public String computeId(String name, String version) { + String result = name + "[" + version + "]"; + return result; + } + + static public String computeName(String id) { + int i = id.lastIndexOf("["); + String result = id; + if (i != -1) { + result = id.substring(0, i); + } + return result; + } + + static public String computeVersion(String id) { + int b = id.lastIndexOf("["); + int e = id.lastIndexOf("]"); + String result = null; + if (b != -1 && e != -1) { + result = id.substring(b+1, e); + } + result = WikittyUtil.normalizeVersion(result); + return result; + } + + public String getId() { + String result = computeId(getName(), getVersion()); + return result; + } + + public String getName() { + return name; + } + + public String getVersion() { + return version; + } + + public String getRequires() { + return requires; + } + + public FieldType getFieldType(String fieldName) { + return fields.get(fieldName); + } + + public Collection<String> getFieldNames() { + Collection<String> result = fields.keySet(); + return result; + } + + public void addField(String fieldName, FieldType type) { + fields.put(fieldName, type); + } + + public void removeField(String fieldName) { + fields.remove(fieldName); + } + + @Override + public int hashCode() { + return getId().hashCode(); + } + + public void addTagValue(String tag, String value) { + tagValues.put(tag, value); + } + + public String getTagValue(String tag) { + String result = tagValues.get(tag); + return result; + } + + public Set<String> getTagNames() { + return tagValues.keySet(); + } + + public Map<String, String> getTagValues() { + return tagValues; + } + + public void setTagValues(Map<String, String> tagValues) { + this.tagValues = tagValues; + } + + @Override + public boolean equals(Object obj) { + boolean result = false; + if (obj instanceof WikittyExtension) { + WikittyExtension other = (WikittyExtension)obj; + result = this.getId().equals(other.getId()); + } + return result; + } + + @Override + public String toString() { + return getId(); + } + + public String toDefinition() { + String result = "Extension " + getId(); + result += WikittyUtil.tagValuesToString(tagValues); + result += " {\n"; + for (String fieldName : fields.keySet()) { + result += fields.get(fieldName).toDefinition(fieldName) + "\n"; + } + result += "}"; + return result; + } + +} Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyExtensionMigration.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyExtensionMigration.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyExtensionMigration.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyExtensionMigration.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,59 @@ +/* *##% + * Copyright (c) 2009 poussin. All rights reserved. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + *##%*/ + +package org.nuiton.wikitty; + + +import java.util.HashMap; +import java.util.Map; + +/** + * Interface used to migrate Wikitty data from one WikittyExtension version + * to another version + * + * @author poussin + * @version $Revision$ + * + * Last update: $Date$ + * by : $Author$ + */ +public interface WikittyExtensionMigration { + + // TODO poussin 20090902 permit configuration of migrationRegistry by spring + /** + * use to put migration class for extension. + * key: extensionName, value: migration class + */ + static public Map<String, WikittyExtensionMigration> migrationRegistry = + new HashMap<String, WikittyExtensionMigration>(); + + /** + * Migrate wikitty data from oldExt version to newExt. + * + * @param service Wikitty service that do migration + * @param transaction current transaction to use + * @param wikitty Wikitty object that contains data in old version + * extension format + * @param oldExt old extension definition + * @param newExt new extension definition + * @return same wikitty as argument if nothing to do, or new wikitty + * if some modification is done + */ + public Wikitty migrate(AbstractWikittyService service, WikittyTransaction transaction, + Wikitty wikitty, WikittyExtension oldExt, WikittyExtension newExt); + +} Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyExtensionMigrationRename.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyExtensionMigrationRename.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyExtensionMigrationRename.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyExtensionMigrationRename.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,123 @@ +/* *##% + * Copyright (c) 2009 ruchaud. All rights reserved. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + *##%*/ + +package org.nuiton.wikitty; + +import java.util.Collection; +import java.util.Set; + +import org.apache.commons.lang.StringUtils; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +/** + * Basic extension migration use to manage rename field name. Order to detect a + * rename, not creation a new field, you should use tag value "renameFrom" with + * name of use in before extension. + * + * Since 1.5, this class also take care about extension order. + * + * @author ruchaud + */ +public class WikittyExtensionMigrationRename implements WikittyExtensionMigration { + + static private Log log = LogFactory.getLog(WikittyExtensionMigrationRename.class); + + public static String TAG_RENAME = "renameFrom"; + + /** + * Recursively add extension with requires ones (orderer). + * + * @param service service + * @param transaction current transaction to use + * @param wikitty wikitty to add extension to + * @param newExt extension to add + */ + protected void addExtension(AbstractWikittyService service, WikittyTransaction transaction, Wikitty wikitty, WikittyExtension newExt) { + + // manage requires before current + String requires = newExt.getRequires(); + if (StringUtils.isNotEmpty(requires)) { + for (String require : requires.split(",")) { + WikittyExtension newRequireExt = service.restoreExtensionLastVersion(transaction, require); + addExtension(service, transaction, wikitty, newRequireExt); + } + } + + // add current extension + wikitty.addExtension(newExt); + } + + @Override + public Wikitty migrate(AbstractWikittyService service, WikittyTransaction transaction, Wikitty wikitty, WikittyExtension oldExt, WikittyExtension newExt) { + + String wikittyId = wikitty.getId(); + String wikittyVersion = wikitty.getVersion(); + + Wikitty result = new Wikitty(wikittyId); + result.setVersion(wikittyVersion); + + // Add all extension and replace old by the new + for (WikittyExtension extension : wikitty.getExtensions()) { + // add one by one to manage require + + // during loop add new when old one is found + if (extension.equals(oldExt)) { + addExtension(service, transaction, result, newExt); + } + else { + addExtension(service, transaction, result, extension); + } + } + + // Copy other values + Set<String> fqFieldNames = wikitty.fieldNames(); + String extName = newExt.getName(); + for (String fieldName : fqFieldNames) { + if(!fieldName.startsWith(extName + ".")) { + Object value = wikitty.getFqField(fieldName); + log.debug("Value " + fieldName + "=" + value); + result.setFqField(fieldName, value); + } + } + + // Migrate field name + Collection<String> oldFieldNames = oldExt.getFieldNames(); + Collection<String> newFieldNames = newExt.getFieldNames(); + for (String fieldName : newFieldNames) { + FieldType fieldType = newExt.getFieldType(fieldName); + + String renameFrom = fieldType.getTagValue(TAG_RENAME); + log.debug("Scan rename migration on " + extName + "." + fieldName + ":" + TAG_RENAME + "=" + renameFrom); + + if(renameFrom != null && !renameFrom.isEmpty()) { + Object value = wikitty.getFieldAsObject(extName, renameFrom); + log.debug("Rename " + extName + "." + fieldName + "=" + value); + result.setField(extName, fieldName, value); + } else { + if(oldFieldNames.contains(fieldName)) { + Object value = wikitty.getFieldAsObject(extName, fieldName); + log.debug("Copy " + extName + "." + fieldName + "=" + value); + result.setField(extName, fieldName, value); + } + } + } + + return result; + } + +} Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyExtensionStorage.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyExtensionStorage.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyExtensionStorage.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyExtensionStorage.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,95 @@ +/* *##% + * Copyright (c) 2009 poussin. All rights reserved. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + *##%*/ + +package org.nuiton.wikitty; + +import java.util.Collection; +import java.util.List; + +/** + * + * @author poussin + * @version $Revision$ + * + * Last update: $Date$ + * by : $Author$ + */ +public interface WikittyExtensionStorage { + + /** + * Store extension in storage. + * + * @param transaction the current transaction + * @param extensions the extensions to store + * @return information usefull for client side update data + */ + UpdateResponse store(WikittyTransaction transaction, Collection<WikittyExtension> extensions); + + /** + * Return true if id exists in storage. + * + * @param transaction the current transaction + * @param id an extension id + * @return true if the extension exists + */ + boolean exists(WikittyTransaction transaction, String id); + + /** + * Return all extension ids. + * + * @param transaction the current transaction + * @return a list of extension ids + */ + List<String> getAllExtensionIds(WikittyTransaction transaction); + + /** + * Return all extension ids where the specified extensionName is required. + * + * @param transaction the current transaction + * @param extensionName the extension required + * @return a list of extension ids + */ + List<String> getAllExtensionsRequires(WikittyTransaction transaction, + String extensionName); + + /** + * return last version available for specified extension name. + * + * @param transaction the current transaction + * @param extName name of extension + * @return last version availble for this version, or null if extension + * doesn't exist + */ + String getLastVersion(WikittyTransaction transaction, String extName); + + /** + * Restore one extension from storage, if not found an exception is thrown. + * + * @param transaction the current transaction + * @param name extension name to restore + * @param version extension version to restore + * @return an extension + */ + WikittyExtension restore(WikittyTransaction transaction, String name, String version) + throws WikittyException; + + /** + * Remove all extensions + */ + public void clear(WikittyTransaction transaction); + +} Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyProxy.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyProxy.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyProxy.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyProxy.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,516 @@ +/* *##% + * Copyright (c) 2009 Sharengo, Guillaume Dufrene, Benjamin POUSSIN. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + *##%*/ + +package org.nuiton.wikitty; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; + +import org.nuiton.wikitty.search.Element; +import org.nuiton.wikitty.search.Search; +import org.nuiton.wikitty.TreeNode; + +/** + * + * @author poussin + * @version $Revision$ + * + * Last update: $Date$ + * by : $Author$ + */ +public class WikittyProxy { + + protected WikittyService wikittyService; + + public WikittyService getWikittyService() { + return wikittyService; + } + + public void setWikittyService(WikittyService wikittyService) { + this.wikittyService = wikittyService; + } + + public <E extends BusinessEntity> E store(E e) { + Wikitty w = WikittyUtil.beanToWikitty(e); + UpdateResponse resp = wikittyService.store(w); + resp.update(e); + return e; + } + + /** + * Store to WikittyService objects. + * @param objets list of BeanDto + * @return + */ + public <E extends BusinessEntity> List<E> store(List<E> objets) { + // prepare data to send to service + List<Wikitty> wikitties = new ArrayList<Wikitty>(objets.size()); + for (E e : objets) { + Wikitty w = WikittyUtil.beanToWikitty(e); + wikitties.add(w); + } + + // call the service with Wikitty + UpdateResponse resp = wikittyService.store(wikitties); + + // update object + for (E e : objets) { + resp.update(e); + } + return objets; + } + + /** + * Restore wikitty entity with specified id or {@code null} if entity can't be found. + * + * @param clazz entity class + * @param id entity id + * @param checkExtension if true check that Wikitty result has all extension + * declared in clazz + * @return wikitty entity with specified id or {@code null} if entity can't be found + */ + public <E extends BusinessEntity> E restore(Class<E> clazz, String id, boolean checkExtension) { + E result = null; + HashSet extNames = null; + try { + Wikitty wikitty = wikittyService.restore(id); + if(wikitty == null) { + return null; + } + + if (checkExtension) { + extNames = new HashSet<String>(wikitty.getExtensionNames()); + } + result = WikittyUtil.newInstance(wikittyService, clazz, wikitty); + } catch (Exception eee) { + throw new WikittyException(eee); + } + if (checkExtension) { + // WikittyUtil.newInstance instanciate only BusinessEntityWikittyImpl + BusinessEntityWikitty b = (BusinessEntityWikitty)result; + Collection<WikittyExtension> BusinessEntityStaticExtensions = b.getStaticExtensions(); + for (WikittyExtension ext : BusinessEntityStaticExtensions) { + String extensionName = ext.getName(); + if (!extNames.contains(extensionName)) { + // extension wanted by BusinessEntity (clazz) + // is not in wikitty, then wikitty is not good type + // for business + return null; + } + } + } + return result; + } + + /** + * Restore wikitty entity with specified id or {@code null} if entity can't be found. + * + * @param clazz entity class + * @param id entity id + * @return wikitty entity with specified id or {@code null} if entity can't be found + */ + public <E extends BusinessEntity> E restore(Class<E> clazz, String id) { + E result = restore(clazz, id, false); + return result; + } + + /** + * + * @param clazz + * @param id + * @param checkExtension if true check that Wikitty result has all extension + * @return + */ + public <E extends BusinessEntity> List<E> restore( + Class<E> clazz, List<String> id, boolean checkExtension) { + + List<Wikitty> wikitties = wikittyService.restore(id); + List<E> result = new ArrayList<E>(); + for (Wikitty w : wikitties) { + HashSet extNames = null; + if (checkExtension) { + extNames = new HashSet<String>(w.getExtensionNames()); + } + + E dto = WikittyUtil.newInstance(wikittyService, clazz, w); + if (checkExtension) { + // WikittyUtil.newInstance instanciate only BusinessEntityWikittyImpl + BusinessEntityWikitty b = (BusinessEntityWikitty) dto; + for (WikittyExtension ext : b.getStaticExtensions()) { + if (!extNames.contains(ext.getName())) { + // extension wanted by BusinessEntity (clazz) + // is not in wikitty, then wikitty is not good type + // for business + return null; + } + } + } + result.add(dto); + } + return result; + } + + public <E extends BusinessEntity> List<E> restore(Class<E> clazz, List<String> id) { + List<E> result = restore(clazz, id, false); + return result; + } + + public void delete(String id) { + wikittyService.delete(id); + } + + public void delete(Collection<String> ids) { + wikittyService.delete(ids); + } + + public <E extends BusinessEntityWikitty> PagedResult<E> findAllByExample(E e, + int firstIndex, int endIndex, String ... fieldFacet ) { + + Criteria criteria = Search.query(e.getWikitty()).criteria() + .setFirstIndex(firstIndex).setEndIndex(endIndex) + .setFacetField(fieldFacet); + + PagedResult<Wikitty> pagedResult = wikittyService.findAllByCriteria(criteria); + // we can use autoconvert = true because search by example add automaticaly + // restriction on extension + PagedResult<E> result = (PagedResult<E>)pagedResult.cast(wikittyService, e.getClass(), true); + return result; + } + + public <E extends BusinessEntityWikitty> E findByExample(E e) { + Criteria criteria = Search.query(e.getWikitty()).criteria(); + + Wikitty w = wikittyService.findByCriteria(criteria); + E result = (E)WikittyUtil.newInstance(wikittyService, e.getClass(), w); + return result; + } + + /** + * Search object that correspond to criteria and that have all extension + * needed by BusinessEntity (clazz). If criteria is null, find all extensions + * else if crtiteria is empty return nothing. + * @param clazz + * @param criteria + * @param firstIndex + * @param endIndex + * @return + */ + public <E extends BusinessEntity> PagedResult<E> findAllByCriteria( + Class<E> clazz, Criteria criteria) { + + // newInstance only return BusinessEntityWikittyImpl + BusinessEntityWikitty sample = + (BusinessEntityWikitty)WikittyUtil.newInstance(clazz); + + Wikitty wikitty = sample.getWikitty(); + Collection<String> extensions = wikitty.getExtensionNames(); + + Criteria serviceCriteria; + if(criteria == null) { + Search search = Search.query(); + search = search.eq(Element.ELT_EXTENSION, extensions); + + serviceCriteria = search.criteria(); + } else { + Search search = Search.query(criteria); + search = search.eq(Element.ELT_EXTENSION, extensions); + + serviceCriteria = search.criteria(criteria.getName()); + serviceCriteria.setFirstIndex(criteria.getFirstIndex()); + serviceCriteria.setEndIndex(criteria.getEndIndex()); + + List<String> facetField = criteria.getFacetField(); + if(facetField != null) { + String[] facetFieldTab = new String[facetField.size()]; + serviceCriteria.setFacetField(facetField.toArray(facetFieldTab)); + } + + List<Criteria> facetCriteria = criteria.getFacetCriteria(); + if(facetCriteria != null) { + Criteria[] facetCriteriaTab = new Criteria[facetCriteria.size()]; + serviceCriteria.setFacetCriteria(facetCriteria.toArray(facetCriteriaTab)); + } + + List<String> sortAscending = criteria.getSortAscending(); + if(sortAscending != null) { + String[] sortAscendingTab = new String[sortAscending.size()]; + serviceCriteria.setSortAscending(sortAscending.toArray(sortAscendingTab)); + } + + List<String> sortDescending = criteria.getSortDescending(); + if(sortDescending != null) { + String[] sortDescendingTab = new String[sortDescending.size()]; + serviceCriteria.setSortDescending(sortDescending.toArray(sortDescendingTab)); + } + } + + PagedResult<Wikitty> pagedResult = wikittyService.findAllByCriteria(serviceCriteria); + + // we can cast with autoconvert true because we have add restriction + // on extension + PagedResult<E> result = (PagedResult<E>)pagedResult.cast(wikittyService, sample.getClass(), true); + return result; + } + + public <E extends BusinessEntity> E findByCriteria(Class<E> clazz, Criteria criteria) { + BusinessEntityWikitty sample = + (BusinessEntityWikitty)WikittyUtil.newInstance(clazz); + + Wikitty wikitty = sample.getWikitty(); + Collection<String> extensions = wikitty.getExtensionNames(); + Search search = Search.query(criteria); + search = search.eq(Element.ELT_EXTENSION, extensions); + + criteria = search.criteria(criteria.getName()); + + Wikitty w = wikittyService.findByCriteria(criteria); + E result = WikittyUtil.newInstance(wikittyService, clazz, w); + return result; + } + + public void addLabel(String wikittyId, String label) { + wikittyService.addLabel(wikittyId, label); + } + + public PagedResult<Wikitty> findAllByLabel(String label, int firstIndex, int endIndex) { + PagedResult<Wikitty> result = wikittyService.findAllByLabel( + label, firstIndex, endIndex); + return result; + } + + public Wikitty findByLabel(String label) { + Wikitty result = wikittyService.findByLabel(label); + return result; + } + + public Set<String> findAllAppliedLabels(String wikittyId) { + Set<String> result = wikittyService.findAllAppliedLabels(wikittyId); + return result; + } + + public Tree restoreTree(String wikittyId) { + Tree result = wikittyService.restoreTree(wikittyId); + return result; + } + + public <E extends BusinessEntity> Map.Entry<E, Integer> restoreNode(Class<E> clazz, String wikittyId, Criteria filter) { + Entry<E, Integer> result = restoreNode(clazz, wikittyId, filter, false); + return result; + } + + public <E extends BusinessEntity> Map.Entry<E, Integer> restoreNode(Class<E> clazz, String wikittyId, Criteria filter, boolean checkExtension) { + Map.Entry<TreeNode, Integer> node = wikittyService.restoreNode(wikittyId, filter); + if(node == null) { + return null; + } + + E bean = restore(clazz, wikittyId, checkExtension); + if(bean == null) { + return null; + } + + Map.Entry<E, Integer> result = + new HashMap.SimpleEntry<E, Integer>(bean, node.getValue()); + return result; + } + + public <E extends BusinessEntity> Map<E, Integer> restoreChildren(Class<E> clazz, String wikittyId, Criteria filter) { + Map<E, Integer> result = restoreChildren(clazz, wikittyId, filter, false); + return result; + } + + public <E extends BusinessEntity> Map<E, Integer> restoreChildren(Class<E> clazz, String wikittyId, Criteria filter, boolean checkExtension) { + + Map<TreeNode, Integer> result = wikittyService.restoreChildren(wikittyId, filter); + if(result == null) { + return null; + } + + Map<E, Integer> convertedResult = new LinkedHashMap<E, Integer>(); + Set<Entry<TreeNode, Integer>> entries = result.entrySet(); + for (Entry<TreeNode, Integer> entry : entries) { + + TreeNode node = entry.getKey(); + + //TODO EC-20100420 was : String nodeId = node.getId(); + String nodeId = node.getWikittyId(); + + E businessEntity = null; + HashSet<String> extNames = null; + try { + Wikitty wikitty = wikittyService.restore(nodeId); + if(checkExtension) { + extNames = new HashSet<String>(wikitty.getExtensionNames()); + } + businessEntity = WikittyUtil.newInstance(wikittyService, clazz, wikitty); + } catch (Exception eee) { + throw new WikittyException(eee); + } + + boolean goodType = true; + if(checkExtension) { + // WikittyUtil.newInstance instanciate only BusinessEntityWikittyImpl + BusinessEntityWikitty businessEntityImpl = (BusinessEntityWikitty) businessEntity; + Collection<WikittyExtension> staticExtensions = businessEntityImpl.getStaticExtensions(); + + for (Iterator<WikittyExtension> iterator = staticExtensions.iterator(); iterator.hasNext() && goodType;) { + WikittyExtension ext = iterator.next(); + if (!extNames.contains(ext.getName())) { + // extension wanted by BusinessEntity (clazz) + // is not in wikitty, then wikitty is not good type + // for business + goodType = false; + } + } + } + + if(goodType) { + Integer nodeCount = entry.getValue(); + convertedResult.put(businessEntity, nodeCount); + } + } + return convertedResult; + } + + public Wikitty restoreVersion(String wikittyId, String version) { + Wikitty result = wikittyService.restoreVersion(wikittyId, version); + return result; + } + + public <E extends BusinessEntity> boolean hasType(Class<E> clazz, String wikittyId) { + E result = null; + HashSet<String> extNames = null; + try { + Wikitty wikitty = wikittyService.restore(wikittyId); + if(wikitty == null) { + return false; + } + extNames = new HashSet<String>(wikitty.getExtensionNames()); + result = WikittyUtil.newInstance(wikittyService, clazz, wikitty); + } catch (Exception eee) { + throw new WikittyException(eee); + } + // WikittyUtil.newInstance instanciate only BusinessEntityWikittyImpl + BusinessEntityWikitty b = (BusinessEntityWikitty)result; + for (WikittyExtension ext : b.getStaticExtensions()) { + if (!extNames.contains(ext.getName())) { + // extension wanted by BusinessEntity (clazz) + // is not in wikitty, then wikitty is not good type + // for business + return false; + } + } + return true; + } + + public void syncImportFromXml(String xml) { + wikittyService.syncImportFromXml(xml); + } + + public void syncImportFromUri(String uri) { + wikittyService.syncImportFromUri(uri); + } + + /** + * + * @param uri + * @return job id + */ + public String asyncImportFromUri(String uri) { + String result = wikittyService.asyncImportFromUri(uri); + return result; + } + + /** + * + * @param e + * @return job id + */ + public <E extends BusinessEntityWikitty> String asyncExportAllByExample(E e) { + Criteria criteria = Search.query(e.getWikitty()).criteria(); + String result = wikittyService.asyncExportAllByCriteria(criteria); + return result; + } + + /** + * + * @param e + * @return xml string + */ + public <E extends BusinessEntityWikitty> String syncExportAllByExample(E e) { + Criteria criteria = Search.query(e.getWikitty()).criteria(); + String result = wikittyService.syncExportAllByCriteria(criteria); + return result; + } + + /** + * + * @param criteria + * @return job id + */ + public String asyncExportAllByCriteria(Criteria criteria) { + String result = wikittyService.asyncExportAllByCriteria(criteria); + return result; + } + + /** + * + * @param criteria + * @return xml string + */ + public String syncExportAllByCriteria(Criteria criteria) { + String result = wikittyService.syncExportAllByCriteria(criteria); + return result; + } + + /** + * give the job state + * @param jobId + * @return + */ + public JobState infoJob(String jobId) { + JobState result = wikittyService.infoJob(jobId); + return result; + } + + /** + * cancel job you must call freeJobResource + * @param jobId + */ + public void cancelJob(String jobId) { + wikittyService.cancelJob(jobId); + } + + /** + * This method must be call when your job is done and you have result, or + * when you call cancelJob + * @param jobId + */ + public void freeJobResource(String jobId) { + wikittyService.freeJobResource(jobId); + } + + +} Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittySearchEngin.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittySearchEngin.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittySearchEngin.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittySearchEngin.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,83 @@ +/* *##% + * Copyright (c) 2009 poussin. All rights reserved. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + *##%*/ + +package org.nuiton.wikitty; + +import java.util.Collection; +import java.util.Map; + +/** + * WikittySearchEngin is used to abstract search engin used in WikittyService. + * + * + * @author poussin + * @version $Revision$ + * + * Last update: $Date$ + * by : $Author$ + */ +public interface WikittySearchEngin { + + /** + * Remove all data in index + */ + public void clear(WikittyTransaction transaction); + + /** + * Store wikitty in storage + * @return information usefull for client side update data + */ + public UpdateResponse store(WikittyTransaction transaction, + Collection<Wikitty> wikitties); + + /** + * Delete all object with idList argument. If id is not valid or don't exist. + * + * @param idList list of ids to delete + * @return <code>UpdateResponse</code>> + * @throws WikittyException + */ + public UpdateResponse delete(WikittyTransaction transaction, + Collection<String> idList) throws WikittyException; + + /** + * Delete all object with idList argument. idList is directly passed to search engine + * and is processed without any other kind of treatment. + * + * @param idList list of ids to delete + * @return <code>UpdateResponse</code>> + * @throws WikittyException + */ + public void delete(Collection<String> idList) throws WikittyException; + + public PagedResult<String> findAllByCriteria(WikittyTransaction transaction, Criteria criteria); + + /** + * Find count of child for a node + * @param w + * @return + */ + public Integer findNodeCount(WikittyTransaction transaction, Wikitty w, Criteria filter); + + /** + * Find all children ids with count for a node wikitty. + * @param w + * @return + */ + public Map<String, Integer> findAllChildrenCount(WikittyTransaction transaction, Wikitty w, Criteria filter); + +} Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyService.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyService.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyService.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyService.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,306 @@ +/* *##% + * Copyright (c) 2009 Sharengo, Guillaume Dufrene, Benjamin POUSSIN. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + *##%*/ + +package org.nuiton.wikitty; + +import java.util.Collection; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.nuiton.wikitty.TreeNode; + +/** + * + * @author poussin + * @version $Revision$ + * + * Last update: $Date$ + * by : $Author$ + */ +public interface WikittyService { + + /** + * Use {@link Criteria.ALL_ELEMENTS} + */ + @Deprecated + public static final int ALL_ELEMENTS = -1; + + /* + * Storage + */ + + /** + * Use with caution : It will delete ALL indexes from search engine ! + * This operation should be disabled in production environment. + */ + public void clear(); + + /** + * Manage Update and creation. + * + * @param wikitty contains an id all the time. + */ + UpdateResponse store(Wikitty wikitty); + + /** + * Manage Update and creation. + * + * @param wikitties list of wikitty to be persisted + */ + UpdateResponse store(Collection<Wikitty> wikitties); + + /** + * Manage Update and creation. + * + * @param wikitties list of wikitty to be persisted + * @param disableAutoVersionIncrement boolean to disable version increment + * on saved wikitty + */ + UpdateResponse store(Collection<Wikitty> wikitties, + boolean disableAutoVersionIncrement); + + /** + * Return all extension id (ex: "extName[version])") + * @return + */ + List<String> getAllExtensionIds(); + + /** + * Return all extension id (ex: "extName[version])") where extensionName is required. + * @return + */ + List<String> getAllExtensionsRequires(String extensionName); + + /** + * Manage Update and creation. + * + * @param wikitty extension to be persisted + */ + UpdateResponse storeExtension(WikittyExtension ext); + + /** + * Manage Update and creation. + * + * @param exts list of wikitty extension to be persisted + */ + UpdateResponse storeExtension(Collection<WikittyExtension> exts); + + /** + * + * @param id + * @return the corresponding object, exception if no such object found. + */ + public WikittyExtension restoreExtension(String id); + + /** + * Search extension with name in last version + * @param name + * @return the corresponding object, exception if no such object found. + */ + public WikittyExtension restoreExtensionLastVersion(String name); + + /** + * + * @param id object id to restore + * @return the corresponding object, or null if object doesn't exist or is + * deleted + */ + Wikitty restore( String id ); + + /** + * + * @param id list of wikitty ids to restore + * @return list of corresponding wikitty, if one id is not valid (no object + * or deleted) this id is skip and result list have less elements than + * collection argument + */ + List<Wikitty> restore( List<String> id ); + + /** + * delete object if id exists + * @param id object's id to remove + */ + void delete(String id); + + /** + * delete all object if id exists + * @param ids object's ids to remove + */ + void delete(Collection<String> ids); + + /** + * + * @param criteria + * @return + */ + public PagedResult<Wikitty> findAllByCriteria(Criteria criteria); + + /** + * Fist lonely (or first one) wikitty object that match criteria, if no wikitty found return null + * @param criteria + * @return + */ + public Wikitty findByCriteria(Criteria criteria); + + /* + * Labelisation + */ + + /** + * add new lable to the wikitty object + * @param wikittyId id of wikitty object to add label + * @param label label to add + */ + void addLabel(String wikittyId, String label); + + /** + * + * @param label + * @return + */ + PagedResult<Wikitty> findAllByLabel(String label, int firstIndex, int endIndex); + + /** + * + * @param addLabel + * @return + */ + Wikitty findByLabel(String label); + + /** + * retrieve all labels applied on a wikitty object + * @param wikittyId + * @return + */ + Set<String> findAllAppliedLabels(String wikittyId); + + + /* + * Classification + * Most of classification purpose is handle by extension mechanisms + */ + + /** + * Retrieve all wikitties children (recursively) of an other one + * Wikitty reference by wikittyId MUST include the 'Node' extension + * + * @param wikittyId + * @return + */ + Tree restoreTree(String wikittyId); + + /** + * Retrieve wikitty node with count. Wikitty reference by wikittyId MUST + * include the 'Node' extension + * @param wikittyId + * @return + */ + Map.Entry<TreeNode, Integer> restoreNode(String wikittyId, Criteria filter); + + /** + * Retrieve all wikitties children with count (no recursively) of an other one + * Wikitty reference by wikittyId MUST include the 'Node' extension + * + * @param wikittyId + * @return + */ + Map<TreeNode, Integer> restoreChildren(String wikittyId, Criteria filter); + + + /* + * history + */ + + /** + * + */ + Wikitty restoreVersion(String wikittyId, String version); + + /* + * admin + */ + + /** + * Synchronise search engine with wikitty strorage engine, i.e. clear and + * reindex all wikitties. + * @return + */ + UpdateResponse syncEngin(); + + /* + * Import / Export + */ + + + /** + * synchonous or not ? + * + * @param xmlData data to import + */ + void syncImportFromXml(String xml); + + /** + * + * @param uri + */ + void syncImportFromUri(String uri); + + /** + * + * @param uri + * @return a jobID + */ + String asyncImportFromUri(String uri); + + /** + * + * @param criteria + * @return + */ + String asyncExportAllByCriteria(Criteria criteria); + + /** + * + * @param criteria + * @return + */ + String syncExportAllByCriteria(Criteria criteria); + + /* + * Job Management + */ + + /** + * + * @param jobId + * @return + */ + JobState infoJob(String jobId); + + /** + * + * @param jobId + */ + void cancelJob(String jobId); + + /** + * delete job info and all resources associated to that job (files or other ...) + */ + void freeJobResource(String jobId); + +} Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyServiceInMemory.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyServiceInMemory.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyServiceInMemory.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyServiceInMemory.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,418 @@ +/* *##% + * Copyright (c) 2009 poussin. All rights reserved. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + *##%*/ + +package org.nuiton.wikitty; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Date; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.Map.Entry; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.nuiton.wikitty.FieldType.TYPE; +import org.nuiton.wikitty.search.And; +import org.nuiton.wikitty.search.BinaryOperator; +import org.nuiton.wikitty.search.Element; +import org.nuiton.wikitty.search.Restriction; + +/** + * In memory implementation of WikittyService, currently used for test only + * + * @author poussin + * @version $Revision$ + * + * Last update: $Date$ + * by : $Author$ + */ +public class WikittyServiceInMemory extends AbstractWikittyService { + + //FIXME InMemory implementation is not usable for production. Must be reviewed. + //FIXME The version increment must be done in 'prepare' method + + /** to use log facility, just put in your code: log.info(\"...\"); */ + static private Log log = LogFactory.getLog(WikittyServiceInMemory.class); + + public static class WikittyStorageInMemory implements WikittyStorage { + protected Map<String, Wikitty> wikitties = new LinkedHashMap<String, Wikitty>(); + + @Override + public UpdateResponse store(WikittyTransaction transaction, Collection<Wikitty> wikitties, boolean disableAutoVersionIncrement) { + UpdateResponse result = new UpdateResponse(); + for (Wikitty wikitty : wikitties) { + wikitty.version = WikittyUtil.incrementMajorRevision(wikitty.version); + wikitty.fieldDirty.clear(); + this.wikitties.put(wikitty.id, wikitty); + result.addVersionUpdate(wikitty.id, wikitty.version); + } + return result; + } + + @Override + public UpdateResponse delete(WikittyTransaction transaction, Collection<String> idList) throws WikittyException { + UpdateResponse result = new UpdateResponse(); + Date now = new Date(); + for (String id : idList) { + Wikitty w = restore(transaction, id); + w.setDeleteDate(now); + result.addDeletionDateUpdate(id, now); + } + return result; + } + + @Override + public boolean exists(WikittyTransaction transaction, String id) { + boolean result = wikitties.containsKey(id); + return result; + } + + @Override + public boolean isDeleted(WikittyTransaction transaction, String id) { + boolean result = false; + Wikitty w = wikitties.get(id); + if (w == null) { + throw new WikittyException(String.format("No wikitty with id '%s'", id)); + } else { + result = w.isDeleted(); + } + return result; + } + + @Override + public Wikitty restore(WikittyTransaction transaction, String id, String ... fqFieldName) throws WikittyException { + Wikitty result = wikitties.get(id); + if (result.isDeleted()) { + result = null; + } + if (result == null) { + throw new WikittyException(String.format("No wikitty with id '%s'", id)); + } + return result; + } + + @Override + public void scanWikitties(WikittyTransaction transaction, Scanner scanner) { + Collection<Wikitty> all = wikitties.values(); + for (Wikitty wikitty : all) { + scanner.scan(wikitty); + } + } + + @Override + public void clear(WikittyTransaction transaction) { + wikitties = new LinkedHashMap<String, Wikitty>(); + } + } + + public static class WikittyExtensionStorageInMemory implements WikittyExtensionStorage { + protected Map<String, WikittyExtension> extensions; + + public WikittyExtensionStorageInMemory() { + this.extensions = new HashMap<String, WikittyExtension>(); + } + + @Override + public UpdateResponse store(WikittyTransaction transaction, + Collection<WikittyExtension> exts) throws WikittyException { + for (WikittyExtension ext : exts) { + extensions.put(ext.getId(), ext); + } + // nothing to do in UpdateResponse + UpdateResponse result = new UpdateResponse(); + return result; + } + + @Override + public boolean exists(WikittyTransaction transaction, String id) { + boolean result = extensions.containsKey(id); + return result; + } + + @Override + public List<String> getAllExtensionIds(WikittyTransaction transaction) { + List<String> result = new ArrayList<String>(extensions.keySet()); + return result; + } + + @Override + public List<String> getAllExtensionsRequires(WikittyTransaction transaction, + String extensionName) { + ArrayList<String> ids = new ArrayList<String>(); + + Collection<WikittyExtension> values = extensions.values(); + if (values != null) { + for (WikittyExtension extension : values) { + if (extensionName.equals(extension.getRequires())) { + ids.add(extension.getId()); + } + } + } + + return ids; + } + + @Override + public String getLastVersion(WikittyTransaction transaction, String extName) { + String result = null; + Set<String> extensionIds = extensions.keySet(); + for (String extensionId : extensionIds) { + String extensionVersion = WikittyExtension.computeVersion(extensionId); + if(extensionId.startsWith(extName) && (result == null || + WikittyUtil.versionGreaterThan(extensionVersion, result))) { + result = extensionVersion; + } + } + return result; + } + + @Override + public WikittyExtension restore(WikittyTransaction transaction, String name, String version) + throws WikittyException { + String id = WikittyExtension.computeId(name, version); + WikittyExtension result = extensions.get(id); + if (result == null) { + throw new WikittyException(String.format("No extension with id '%s'", id)); + } + return result; + } + + @Override + public void clear(WikittyTransaction transaction) { + extensions = new HashMap<String, WikittyExtension>(); + } + } + + public static class WikittySearchEnginInMemory implements WikittySearchEngin { + + WikittyStorageInMemory wikittyStorage; + + public WikittySearchEnginInMemory(WikittyStorageInMemory wikittyStorage) { + this.wikittyStorage = wikittyStorage; + } + + @Override + public void clear(WikittyTransaction transaction) { + // do nothing + } + + @Override + public UpdateResponse store(WikittyTransaction transaction, + Collection<Wikitty> wikitties) { + // do nothing + return new UpdateResponse(); + } + + @Override + public UpdateResponse delete(WikittyTransaction transaction, + Collection<String> idList) throws WikittyException { + // do nothing + return new UpdateResponse(); + } + + + @Override + public void delete(Collection<String> idList) throws WikittyException { + } + + public boolean checkRestriction( Restriction restriction, Wikitty w ) { + if ( restriction instanceof BinaryOperator ) { + BinaryOperator binOp = (BinaryOperator) restriction; + + if ( binOp.getElement().equals(Element.ELT_EXTENSION) ) { + return w.hasExtension(binOp.getValue()); + } + + String fqfieldName = binOp.getElement().getName(); + if(Element.ELT_EXTENSION.equals(fqfieldName) || + Element.ELT_ID.equals(fqfieldName)) { + return true; // FIXME: 20091104 jru manage search on extension and id + } + Object o = w.getFqField( fqfieldName ); + FieldType t = w.getFieldType(fqfieldName); + Object value = t.getValidValue( binOp.getValue() ); + boolean checked = false; + switch( restriction.getName() ) { + case EQUALS: + checked = value.equals(o); + break; + case LESS: + checked = ((Comparable)o).compareTo( value ) < 0; + break; + case LESS_OR_EQUAL: + checked = ((Comparable)o).compareTo( value ) <= 0; + break; + case GREATER: + checked = ((Comparable)o).compareTo( value ) > 0; + break; + case GREATER_OR_EQUAL: + checked = ((Comparable)o).compareTo( value ) >= 0; + break; + case NOT_EQUALS: + checked = !value.equals(o); + break; + case ENDS_WITH: + if (t.getType() != TYPE.STRING) { + throw new WikittyException("Can't search for contents that 'ends with' on attribute type different of String. " + + "Attribute " + fqfieldName + " is " + t.getType().name() ); + } + checked = ((String) o).endsWith( (String) value ); + break; + case STARTS_WITH: + if (t.getType() != TYPE.STRING) { + throw new WikittyException("Can't search for contents that 'starts with' on attribute type different of String. " + + "Attribute " + fqfieldName + " is " + t.getType().name() ); + } + checked = ((String) o).startsWith( (String) value ); + break; + } + return checked; + } else if ( restriction instanceof And ) { + And and = (And) restriction; + for ( Restriction sub : and.getRestrictions() ) { + if (!checkRestriction(sub, w)) { + return false; + } + } + return true; + } else { + throw new UnsupportedOperationException( restriction.getName() + " Search Not yet implemented"); + } + } + + @Override + public PagedResult<String> findAllByCriteria(WikittyTransaction transaction, + Criteria criteria) { + // throw new UnsupportedOperationException("Not supported yet."); + + int firstIndex = criteria.getFirstIndex(); + int endIndex = criteria.getEndIndex(); + + List<String> ids = new LinkedList<String>(); + int currentIndex = 0; + + for( Entry<String, Wikitty> entry : wikittyStorage.wikitties.entrySet() ) { + Wikitty w = entry.getValue(); + String id = entry.getKey(); + Restriction dto = criteria.getRestriction(); + + if ( checkRestriction(dto, w) ) { + currentIndex++; + if (currentIndex > firstIndex) { + ids.add(id); + } + if (endIndex >= 0 && currentIndex >= endIndex) { + break; + } + } + + } + return new PagedResult<String>(firstIndex, endIndex, criteria.getRestriction().toString(), null, ids ); + } + + @Override + public Integer findNodeCount(WikittyTransaction transaction, Wikitty w, Criteria filter) { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public Map<String, Integer> findAllChildrenCount(WikittyTransaction transaction, Wikitty w, Criteria filter) { + throw new UnsupportedOperationException("Not supported yet."); + } + + } + + /** + * if persitenceFile is not null, serialize all data to disk during store + * operation and the file is reloaded during init + */ + protected File persitenceFile = null; + + protected WikittyStorage wikittyStorage; + protected WikittyExtensionStorage extensionStorage; + protected WikittySearchEngin searchEngin; + + public WikittyServiceInMemory() { + extensionStorage = new WikittyExtensionStorageInMemory(); + wikittyStorage = new WikittyStorageInMemory(); + searchEngin = new WikittySearchEnginInMemory((WikittyStorageInMemory)wikittyStorage); + } + + public WikittyServiceInMemory(File persitenceFile) { + this(); + this.persitenceFile = persitenceFile; + if (persitenceFile != null && persitenceFile.exists()) { + try { + ObjectInputStream in = new ObjectInputStream(new FileInputStream( + persitenceFile)); + ((WikittyExtensionStorageInMemory)extensionStorage).extensions = (Map) in.readObject(); + ((WikittyStorageInMemory)wikittyStorage).wikitties = (Map) in.readObject(); + in.close(); + } catch (Exception eee) { + log.error("Can't read data file " + persitenceFile, eee); + } + } + } + + @Override + protected WikittyStorage getWikittyStorage() { + return wikittyStorage; + } + + @Override + protected WikittyExtensionStorage getExtensionStorage() { + return extensionStorage; + } + + @Override + protected WikittySearchEngin getSearchEngin() { + return searchEngin; + } + + @Override + protected void finalize() throws Throwable { + saveToPersistenceFile(); + + super.finalize(); + } + + public void saveToPersistenceFile() { + if (persitenceFile != null) { + try { + ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream( + persitenceFile)); + out.writeObject(((WikittyExtensionStorageInMemory)extensionStorage).extensions); + out.writeObject(((WikittyStorageInMemory)wikittyStorage).wikitties); + out.close(); + } catch (IOException eee) { + log.error("Can't write data file " + persitenceFile, eee); + } + } + } + +} Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyStorage.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyStorage.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyStorage.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyStorage.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,90 @@ +/* *##% + * Copyright (c) 2009 poussin. All rights reserved. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + *##%*/ + +package org.nuiton.wikitty; + +import java.util.Collection; +import java.util.List; + +/** + * WikittyStorage is used to abstract data and extension storage in WikittyService. + * + * @author poussin + * @version $Revision$ + * + * Last update: $Date$ + * by : $Author$ + */ +public interface WikittyStorage { + + /** + * Store wikitty in storage + * @return information usefull for client side update data + */ + public UpdateResponse store(WikittyTransaction transaction, Collection<Wikitty> wikitties, boolean disableAutoVersionIncrement); + + /** + * Return true if id exists in storage + * @param id + * @return + */ + public boolean exists(WikittyTransaction transaction, String id); + + /** + * Return true if wikitty object with this id are marked deleted + * @param id + * @return + */ + public boolean isDeleted(WikittyTransaction transaction, String id); + + /** + * Restore list of wikitty object, if wikitty not found an exception is throw + * @param id list of wikitty id + * @param fqFieldName list of field that must be loaded, other fields + * can be not loaded + * @return + */ + public Wikitty restore(WikittyTransaction transaction, String id, + String ... fqFieldName) throws WikittyException; + + /** + * Delete all object with id argument. If id is not valid or don't exist + * throw an exception + * @param idList + * @return + */ + public UpdateResponse delete(WikittyTransaction transaction, Collection<String> idList) throws WikittyException; + + /** + * Scan all wikitties with specific scanner, even if the wikitty is deleted + * @param scanner scanner + */ + void scanWikitties(WikittyTransaction transaction, Scanner scanner); + + /** + * Call each time wikitty is scan + */ + public static interface Scanner { + void scan(Wikitty wikitty); + } + + /** + * Remove all wikitty + */ + public void clear(WikittyTransaction transaction); + +} Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyTransaction.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyTransaction.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyTransaction.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyTransaction.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,75 @@ +package org.nuiton.wikitty; + +import java.util.HashMap; +import java.util.Map; +import javax.transaction.Status; +import javax.transaction.TransactionManager; +import javax.transaction.UserTransaction; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +/*** + * Manage JTA transaction. You can store some information during execution. + */ +public class WikittyTransaction { + + /** to use log facility, just put in your code: log.info(\"...\"); */ + static private Log log = LogFactory.getLog(AbstractWikittyService.class); + + protected Map<Object, Object> tagValues; + + public WikittyTransaction() { + tagValues = new HashMap<Object, Object>(); + } + + public Object getTagValue(Object tag) { + return tagValues.get(tag); + } + + public void setTagValue(Object tag, Object value) { + tagValues.put(tag, value); + } + + public UserTransaction getUserTransaction() { + return com.arjuna.ats.jta.UserTransaction.userTransaction(); + } + + public TransactionManager getTransactionManager() { + return com.arjuna.ats.jta.TransactionManager.transactionManager(); + } + + public void begin() { + UserTransaction userTransaction = getUserTransaction(); + try { + log.debug("Begin transaction"); + userTransaction.setTransactionTimeout(3600); // FIXME: jru 20100115 error in service if call during lot of times + userTransaction.begin(); + } catch (Exception eee) { + throw new WikittyException("Error on begin JTA transaction", eee); + } + } + + public void commit() { + + UserTransaction userTransaction = getUserTransaction(); + try { + log.debug("Commit transaction"); + userTransaction.commit(); + } catch (Exception eee) { + throw new WikittyException("Error on commit JTA transaction", eee); + } + } + + public void rollback() { + UserTransaction userTransaction = getUserTransaction(); + try { + if(userTransaction.getStatus() != Status.STATUS_NO_TRANSACTION + && userTransaction.getStatus() != Status.STATUS_UNKNOWN) { + log.debug("Rollback transaction"); + userTransaction.rollback(); + } + } catch (Exception eee) { + throw new WikittyException("Error on roolback JTA transaction", eee); + } + } +} Copied: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyUtil.java (from rev 49, trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyUtil.java) =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyUtil.java (rev 0) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyUtil.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,897 @@ +/* *##% + * Copyright (c) 2009 poussin. All rights reserved. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + *##%*/ + +package org.nuiton.wikitty; + +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.math.BigDecimal; +import java.text.CharacterIterator; +import java.text.DateFormat; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.text.StringCharacterIterator; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Date; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.Set; +import java.util.TimeZone; +import java.util.UUID; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +/** + * + * Util static method for wikitty + * + * @author poussin + * @version $Revision$ + * + * Last update: $Date$ by : $Author$ + */ +public class WikittyUtil { + + public static final String DEFAULT_VERSION = "0.0"; + + public static final String DATE_FORMAT = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"; + + /** to use log facility, just put in your code: log.info(\"...\"); */ + static private Log log = LogFactory.getLog(WikittyUtil.class); + + /** used to format date for solr */ + protected static TimeZone CANONICAL_TZ = TimeZone.getTimeZone("UTC"); + protected static final Locale CANONICAL_LOCALE = Locale.US; + + static final public SimpleDateFormat solrDateFormat = new SolrDateFormat(); + + public static class SolrDateFormat extends SimpleDateFormat { + public SolrDateFormat() { + super(DATE_FORMAT, CANONICAL_LOCALE); + setTimeZone(CANONICAL_TZ); + } + } + + /** All date format parser used to convert string to date */ + static final protected DateFormat[] parserDateFormats = new DateFormat[] { + solrDateFormat, DateFormat.getInstance(), + // TODO poussin 20090813: add other date syntax + }; + + // TODO poussin 20090902 use spring configuration to add mapping in this + // variable + /** contains mapping between interface and concret class that must be used */ + static public Map<Class, Class> interfaceToClass = new HashMap<Class, Class>(); + + /** + * Pattern for tag value: tag="value" or tag=value. value can contains '"' + */ + static protected String tagValuesPatternString = "(\\w*)=(\".*?(?<!\\\\)\"|[^(\\p{Space})]+)"; + static protected Pattern tagValuesPattern = Pattern.compile( + tagValuesPatternString, Pattern.DOTALL); + /** + * Field pattern parser <li>group 1: type (string) <li>group 2: name + * (string) <li>group 3: lower bound (number) can be null <li>group 4: upper + * bound (number) can be null, mutualy exclusif with group 5 <li>group 5: + * upper bound (n or *) can be null <li>group 6: unique can be null <li> + * group 7: not null can be null <li>group 8: all tag/value (toto=titi + * tutu=tata;lala tata="truc bidulle") + */ + static protected Pattern fieldPattern = Pattern + .compile( + "\\s*(\\w+)\\s+(\\w+)(?:\\s*\\[(\\d+)-(?:(\\d+)|([\\*n]))\\])?(?:\\s+(unique))?(?:\\s+(not null))?((?:\\s+" + + tagValuesPatternString + ")*)", Pattern.DOTALL); + + /** + * parse FieldType definition and return field name. All field information + * are stored in fieldType object passed in argument + * + * @param def + * string field definition + * @param fieldType + * object used to put parsed information + * @return field name parsed in definition + */ + static public String parseField(String def, FieldType fieldType) { + Matcher match = fieldPattern.matcher(def); + if (match.matches()) { + fieldType.type = FieldType.TYPE.parse(match.group(1)); + String name = match.group(2); + String lower = match.group(3); + if (lower != null) { + fieldType.lowerBound = Integer.parseInt(lower); + } + + String upper = match.group(4); + if (upper != null) { + fieldType.upperBound = Integer.parseInt(upper); + } + String noupper = match.group(5); + if (noupper != null) { + fieldType.upperBound = FieldType.NOLIMIT; + } + String uniqueString = match.group(6); + fieldType.unique = uniqueString != null; + + String notNullString = match.group(7); + fieldType.notNull = notNullString != null; + + String tagValues = match.group(8); + Map<String, String> tagValuesMap = tagValuesToMap(tagValues); + fieldType.setTagValues(tagValuesMap); + + return name; + } else { + throw new WikittyException(String.format( + "Bad FieldType definition '%s'", def)); + } + } + + + /** + * Serialize tagValues to string + * + * @param tagValues tagValues as map + * @return string represent tagValues + */ + public static String tagValuesToString(Map<String, String> tagValues) { + String result = ""; + if(tagValues != null) { + for (String tag : tagValues.keySet()) { + String value = tagValues.get(tag); + // replace " in string with \" + value = value.replaceAll("\"", "\\\\\""); + // quote value with "..." + result += " " + tag + "=\"" + tagValues.get(tag) +"\""; + } + } + return result; + } + + /** + * Deserialize tagValues to map + * + * @param tagValues tagValues as string + * @return map represent tagValues + */ + public static Map<String, String> tagValuesToMap(String tagValues) { + Map<String, String> result = new HashMap<String, String>(); + if (tagValues != null) { + Matcher matchTagValues = tagValuesPattern.matcher(tagValues); + while (matchTagValues.find()) { + String tag = matchTagValues.group(1); + String value = matchTagValues.group(2); + if (value.startsWith("\"") && value.endsWith("\"")) { + // delete start and end " + value = value.substring(1, value.length() - 1); + // if value is between ", then inners " are quoted + value = value.replaceAll("\\\\\"", "\""); + } + result.put(tag, value); + } + } + return result; + } + + /** + * Create map from string representation + * + * ex: "String name", "Wikitty children[0-*]" + * + * @param definitions + * @return + */ + public static LinkedHashMap<String, FieldType> buildFieldMapExtension( + String... definitions) { + LinkedHashMap<String, FieldType> result = new LinkedHashMap<String, FieldType>(); + for (String def : definitions) { + FieldType fieldType = new FieldType(); + String name = WikittyUtil.parseField(def, fieldType); + log.debug("parse " + def + " => " + fieldType.toDefinition(name)); + result.put(name, fieldType); + } + return result; + } + + /** + * if version if null return 0 else version If version is not in format + * <major>.<minor>, ".0" is added to the version + * + * @param version + * @return the normalized version + */ + public static String normalizeVersion(String version) { + if (version == null || "".equals(version)) { + version = "0"; + } + if (version.indexOf(".") == -1) { + version += ".0"; + } + return version; + } + + /** + * return true if v1 and v2 are egals 1.2.0 et 1.2 ne sont pas egaux + */ + public static boolean versionEquals(String v1, String v2) { + if (v1 == null || v2 == null) { + return false; + } + return normalizeVersion(v1).equals(normalizeVersion(v2)); + } + + /** + * return true if v1 greater than v2 + * + * @param v1 + * @param v2 + * @return + */ + public static boolean versionGreaterThan(String v1, String v2) { + if (v1 != null && v2 == null) { + return true; + } + if (v1 == null) { + return false; + } + String[] v1s = normalizeVersion(v1).split("\\."); + String[] v2s = normalizeVersion(v2).split("\\."); + int minlen = Math.min(v1s.length, v2s.length); + for (int i = 0; i < minlen; i++) { + if (!v1s[i].equals(v2s[i])) { + return Integer.parseInt(v1s[i]) > Integer.parseInt(v2s[i]); + } + } + // si on est ici c que tout les nombres sont v1[i] = v2[i] + return v1s.length > v2s.length; + } + + /** + * increment minor version. + * + * @param version + * version as 3.1 where 1 is minor and 3 major + * @return incremented minor number (3.1 -> 3.2) + */ + static public String incrementMinorRevision(String v) { + String result; + + if (v == null || "".equals(v)) { + result = "0.1"; + } else { + v = v.trim(); + String[] mm = v.split("\\."); + if (mm.length == 1) { + result = v + ".1"; + } else { + int i = Integer.parseInt(mm[1]) + 1; + result = mm[0] + "." + i; + } + } + return result; + } + + /** + * increment major version. + * + * @param version + * version as 3.2 where 2 is minor and 3 major + * @return incremented major number and reset minor number (3.2 -> 4.0) + */ + static public String incrementMajorRevision(String v) { + String result; + + if (v == null || "".equals(v)) { + result = "1.0"; + } else { + v = v.trim(); + String[] mm = v.split("\\."); + int i = Integer.parseInt(mm[0]) + 1; + result = i + ".0"; + } + return result; + } + + // /** + // * + // * @param value null and empty string are casted to '0' int value. + // * @throws WikittyException on NumberFormatException or if value object + // can't be casted to int. + // */ + // static public int toInt(Object value) throws WikittyException { + // int result = 0; + // if (value == null || value.equals("") ) { + // result = 0; // default to 0 + // } else if (value instanceof Number) { + // result = ((Number) value).intValue(); + // } else { + // // try to convert to int + // try { + // result = Integer.parseInt(value.toString()); + // } catch (NumberFormatException eee) { + // throw new WikittyException(String.format( + // "Can't convert value '%s' to int", getClass(value)), eee); + // } + // } + // return result; + // } + // + // static public float toFloat(Object value) throws WikittyException { + // float result = 0; + // if (value == null) { + // result = 0; // default to 0 + // } else if (value instanceof Number) { + // result = ((Number) value).floatValue(); + // } else { + // // try to convert to float + // try { + // result = Float.parseFloat(value.toString()); + // } catch (NumberFormatException eee) { + // throw new WikittyException(String.format( + // "Can't convert value '%s' to float", getClass(value)), eee); + // } + // } + // return result; + // } + + /** + * + * @param value + * null and empty string are casted to '0' value. + * @throws WikittyException + * on NumberFormatException or if value object can't be casted + * to number. + */ + static public BigDecimal toBigDecimal(Object value) { + BigDecimal result = null; + if (value == null) { + result = new BigDecimal(0); // default to 0 + } else if (value instanceof BigDecimal) { + result = (BigDecimal) value; + } else { + try { + result = new BigDecimal(value.toString()); + } catch (NumberFormatException eee) { + throw new WikittyException( + String.format("Can't convert value '%s' to numeric", + getClass(value)), eee); + } + } + return result; + } + + /** + * Convert object to boolean: - null => false - 0 => false - numeric => true + * - object.toString() == false => false - other => true + * + * @param value + * @return + */ + static public boolean toBoolean(Object value) { + boolean result = false; + if (value != null) { + if (value instanceof Boolean) { + result = (Boolean) value; + } else if (value instanceof Number) { + result = !((Number) value).equals(0); + } else { + // try to convert to Boolean + result = !"false".equalsIgnoreCase(value.toString()); + } + } + return result; + } + + static public String toString(Object value) { + String result = null; + if (value != null) { + if (value instanceof String) { + result = (String) value; + } else if (value instanceof Wikitty) { + result = ((Wikitty) value).getId(); + } else if (value instanceof BusinessEntity) { + result = ((BusinessEntity) value).getWikittyId(); + } else if (value instanceof Date) { + result = solrDateFormat.format((Date) value); + } else { + // try to convert to String + result = value.toString(); + } + } + return result; + } + + static public Date toDate(Object value) { + Date result = null; + if (value != null) { + if (value instanceof Date) { + result = (Date) value; + } else { + // try to convert to Date + try { + result = solrDateFormat.parse(value.toString()); + } catch (ParseException eee) { + log.debug("Can't parse date, i try with next parser", eee); + } + + if (result == null) { + throw new WikittyException(String.format( + "Can't convert value '%s' of type '%s' to Date", + value, getClass(value))); + } + } + } + return result; + } + + /** + * return wikitty id and not wikitty objet because this method can be call + * on server or client side and it's better to keep conversion between id + * and objet to the caller + * + * @param value + * @return id of wikitty object or null + * @throws org.nuiton.wikitty.WikittyException + */ + static public String toWikitty(Object value) { + String result = null; + if (value != null) { + if (value instanceof String) { + result = (String) value; + } else if (value instanceof Wikitty) { + result = ((Wikitty) value).getId(); + } else if (value instanceof BusinessEntity) { + result = ((BusinessEntity) value).getWikittyId(); + } else { + // try to convert to String + result = value.toString(); + } + } + return result; + } + + /** + * + * @param <E> + * @param clazz + * @return unmodifiable list + */ + static public <E> List<E> toList(Object value, Class<E> clazz) { + try { + List<E> result = (List<E>) value; + if (result != null) { + result = Collections.unmodifiableList(result); + } + return result; + } catch (Exception eee) { + throw new WikittyException(String.format( + "Can't convert value '%s' to list", getClass(value)), eee); + } + } + + /** + * Convert object o for indexation + * + * @param field + * field description + * @param o + * field value + * @return solr representation + */ + static public String toString(FieldType field, Object o) { + String result = null; + if (o != null) { + switch (field.getType()) { + case DATE: + // Date date = (Date)o; + result = (o instanceof String) ? (String) o + : WikittyUtil.solrDateFormat.format((Date) o); + break; + default: + result = WikittyUtil.toString(o); + break; + } + } + return result; + } + + + /** + * convert string field representation to correct value type + * + * @param field + * field description + * @param s + * string value + * @return object in type of field + */ + static public Object fromString(FieldType field, String s) { + Object result = null; + switch (field.getType()) { + case BOOLEAN: + result = WikittyUtil.toBoolean(s); + break; + case DATE: + result = WikittyUtil.toDate(s); + break; + case NUMERIC: + result = WikittyUtil.toBigDecimal(s); + break; + default: + result = s; + break; + } + return result; + } + + /** + * return class of argument, if argument is null, return null + * + * @param value + * @return class of value or null + */ + static public Class getClass(Object value) { + Class result = null; + if (value != null) { + result = value.getClass(); + } + return result; + } + + /** + * Create new instance of WikittyDto without Wikitty object passed in + * argument. If arguement is Interface try to add 'Impl' to find + * instanciable class. + * <p> + * clazz parameter must be child of WikittyDto or business interface + * + * @param clazz + * class of the new instance + * @return + */ + static public <E extends BusinessEntity> E newInstance(Class<E> clazz) { + try { + Class clazzInstanciable = clazz; + if (clazzInstanciable.isInterface()) { + log + .debug(String + .format( + "Argument '%s' is interface looking for implementation", + clazzInstanciable.getName())); + // looking for implementation of this interface + if (interfaceToClass.containsKey(clazz)) { + clazzInstanciable = interfaceToClass.get(clazz); + } else { + // default use xxxImpl.class + clazzInstanciable = clazz.forName(clazz.getName() + "Impl"); + } + } + + if (!BusinessEntityWikitty.class + .isAssignableFrom(clazzInstanciable)) { + throw new WikittyException(String.format( + "Your class '%s' don't extends WikittyDto", clazz + .getName())); + } + + E result = (E) clazzInstanciable.newInstance(); + return result; + + } catch (Exception eee) { + throw new WikittyException(eee); + } + } + + /** + * Create new instance of WikittyDto with Wikitty object passed in argument. + * If arguement is Interface try to add 'Impl' to find instanciable class. + * <p> + * clazz parameter must be child of WikittyDto or business interface + * + * @param clazz + * class of the new instance + * @param w + * wikitty object to use internaly for in new instance + * @return + */ + // E extends BeanDto to permit business interface as parameter + static public <E extends BusinessEntity> E newInstance( + WikittyService wikittyService, Class<E> clazz, Wikitty w) { + try { + Class clazzInstanciable = clazz; + if (clazzInstanciable.isInterface()) { + log + .debug(String + .format( + "Argument '%s' is interface looking for implementation", + clazzInstanciable.getName())); + // looking for implementation of this interface + if (interfaceToClass.containsKey(clazz)) { + clazzInstanciable = interfaceToClass.get(clazz); + } else { + // default use xxxImpl.class + clazzInstanciable = clazz.forName(clazz.getName() + "Impl"); + } + } + + if (!BusinessEntityWikitty.class + .isAssignableFrom(clazzInstanciable)) { + throw new WikittyException(String.format( + "Your class '%s' don't extends WikittyDto", clazz + .getName())); + } + + E result = null; + if (w != null) { + try { + // try to find constructor with wikitty argument + Constructor cons = clazzInstanciable + .getConstructor(Wikitty.class); + Object[] parms = { null }; + result = (E) cons.newInstance(parms); + + BusinessEntityWikitty bean = (BusinessEntityWikitty) result; + checkExtensionVersion(wikittyService, w, bean); + bean.setWikitty(w); + + } catch (NoSuchMethodException noerror) { + log.debug(String.format( + "Can't find constructor with wikitty arguement in '%s'," + + "we try with setWikitty method", + clazzInstanciable.getName()), noerror); + } + } + + return result; + } catch (Exception eee) { + throw new WikittyException(eee); + } + } + + /** + * Check extension default, i.e. if bean contain a extension with a great + * version as in wikitty. In this case the extension is stored in last + * version and wikitty it is restored again. The upgrade data is during the + * restoration. + * + * @param wikittyService + * @param wikitty + * @param entity + * @return + */ + static public Wikitty checkExtensionVersion(WikittyService wikittyService, + Wikitty wikitty, BusinessEntityWikitty entity) { + + Wikitty result = wikitty; + boolean upgradeData = false; + + Collection<WikittyExtension> extensions = entity.getStaticExtensions(); + for (WikittyExtension ext : extensions) { + + String extName = ext.getName(); + if (wikitty.hasExtension(extName)) { + + WikittyExtension oldExt = wikitty.getExtension(extName); + String newVersion = ext.getVersion(); + String oldVersion = oldExt.getVersion(); + + if (WikittyUtil.versionGreaterThan(newVersion, oldVersion)) { + wikittyService.storeExtension(Arrays.asList(ext)); + upgradeData = true; + } + } + } + + if (upgradeData) { + String wikittyId = wikitty.getId(); + result = wikittyService.restore(wikittyId); + } + + return result; + } + + /** + * Try to cast obj to class passed in arguement + * + * @param obj + * object to cast + * @param clazz + * new type of object + * @return the same object but casted to class wanted, except for primitif + * where is new object if obj BigDecimal + */ + public static <E> E cast(Object obj, Class<E> clazz) { + E result = null; + if (obj != null) { + if (clazz.isAssignableFrom(obj.getClass())) { + result = clazz.cast(obj); + } else if (obj instanceof BigDecimal) { + BigDecimal bd = (BigDecimal) obj; + if (clazz == int.class || clazz == Integer.class) { + result = clazz.cast(bd.intValue()); + } else if (clazz == float.class || clazz == Float.class) { + result = clazz.cast(bd.floatValue()); + } + } + if (result == null) { + throw new WikittyException("Unable to cast from '" + + obj.getClass().getName() + "' to " + clazz.getName()); + } + } + return result; + } + + public static Wikitty beanToWikitty(BusinessEntity bean) { + Wikitty result; + if (bean instanceof BusinessEntityWikitty) { + BusinessEntityWikitty b = (BusinessEntityWikitty) bean; + result = b.getWikitty(); + } else if (bean instanceof BusinessEntityBean) { + BusinessEntityBean b = (BusinessEntityBean) bean; + result = WikittyUtil.beanToWikitty(b); + } else { + throw new IllegalArgumentException(String.format( + "This BusinessEntity implementation is not supported: %s", + bean.getClass().getName())); + } + return result; + } + + public static Wikitty beanToWikitty(BusinessEntityBean bean) { + try { + // TODO poussin 20090910 for now, we force version change, but it's + // better if we modify version in bean we field is set + Wikitty result = new Wikitty(bean.getWikittyId()); + // prevent BusinessEntity with null id (during store call for + // creation) + bean.id = result.id; + result.version = bean.getWikittyVersion(); + + // add execution defined extension in wikitty + for (String extName : bean.getExtensionNames()) { + for (String fieldName : bean.getExtensionFields(extName)) { + Object value = bean.getField(extName, fieldName); + result.setField(extName, fieldName, value); + } + } + + // add development time defined extension in wikitty + Field[] fields = bean.getClass().getFields(); + for (Field field : fields) { + Object value = field.get(bean); + String fqfieldName = field.getName(); + // fieldName use $ as separator between extension name and field + // name + fqfieldName = fqfieldName.replace('$', '.'); + result.setFqField(fqfieldName, value); + } + return result; + } catch (Exception eee) { + throw new WikittyException(eee); + } + } + + public static <E extends BusinessEntityBean, F extends BusinessEntityWikitty> E wikittyToBean( + Class<E> clazz, F dto) { + E result = wikittyToBean(clazz, dto.getWikitty()); + return result; + } + + /** + * Convert WikittyDto (dto that encapsulate Wikitty) to BeanDto (dto without + * internaly wikitty) + * + * @param clazz + * target object clazz + * @param w + * source object + * @return + */ + public static <E extends BusinessEntityBean> E wikittyToBean( + Class<E> clazz, Wikitty w) { + try { + E result = clazz.newInstance(); + result.id = w.id; + result.version = w.version; + result.extensions = new LinkedHashMap<String, WikittyExtension>( + w.extensions); + + Field[] fields = clazz.getFields(); + Map<String, Field> allFields = new HashMap<String, Field>(); + for (Field field : fields) { + allFields.put(field.getName(), field); + } + + for (String extName : result.extensions.keySet()) { + WikittyExtension ext = result.extensions.get(extName); + for (String fieldName : ext.getFieldNames()) { + String key = extName + "$" + fieldName; + Field field = allFields.get(key); + if (field != null) { + Class type = field.getType(); + if (Integer.TYPE.isAssignableFrom(type)) { + int value = w.getFieldAsInt(extName, fieldName); + field.setInt(result, value); + } else if (Boolean.TYPE.isAssignableFrom(type)) { + boolean value = w.getFieldAsBoolean(extName, + fieldName); + field.setBoolean(result, value); + } else if (Date.class.isAssignableFrom(type)) { + Date value = w.getFieldAsDate(extName, fieldName); + field.set(result, value); + } else if (Double.TYPE.isAssignableFrom(type)) { + double value = w.getFieldAsDouble(extName, + fieldName); + field.setDouble(result, value); + } else if (Float.TYPE.isAssignableFrom(type)) { + float value = w.getFieldAsFloat(extName, fieldName); + field.setFloat(result, value); + } else if (List.class.isAssignableFrom(type)) { + List value = w.getFieldAsList(extName, fieldName, + clazz); + field.set(result, value); + } else if (Long.TYPE.isAssignableFrom(type)) { + long value = w.getFieldAsLong(extName, fieldName); + field.setLong(result, value); + } else if (Set.class.isAssignableFrom(type)) { + Set value = w.getFieldAsSet(extName, fieldName, + clazz); + field.set(result, value); + } else if (String.class.isAssignableFrom(type)) { + String value = w.getFieldAsString(extName, + fieldName); + field.set(result, value); + } else { + throw new WikittyException(String.format( + "Can't convert field for '%s' because" + + " unkonw field type '%s'", clazz, + field)); + } + } else { + Object value = w.getFieldAsObject(extName, fieldName); + result.setField(extName, fieldName, value); + } + } + } + + return result; + } catch (Exception eee) { + throw new WikittyException(eee); + } + } + + // private static BASE64Encoder enc = new BASE64Encoder(); + public static String genUID() { + return UUID.randomUUID().toString(); + /* + * we can gain 10 chars per ID on applying a base64 on the UID. long + * mostSignificant = uid.getMostSignificantBits(); long leastSignificant + * = uid.getLeastSignificantBits(); long current = mostSignificant; + * byte[] b = new byte[16]; for ( int i = 0; i < 16; i++ ) { b[i] = + * (byte) (current & 0xff); current = current >> 8; if ( i == 7 ) + * current = leastSignificant; } return enc.encode(b); + */ + } +} Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/And.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/And.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/And.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.search; +package org.nuiton.wikitty.search; // Start of user code for import Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/AssociatedRestriction.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/AssociatedRestriction.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/AssociatedRestriction.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.search; +package org.nuiton.wikitty.search; public class AssociatedRestriction extends Restriction { Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Between.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/Between.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Between.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.search; +package org.nuiton.wikitty.search; // Start of user code for import Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/BinaryOperator.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/BinaryOperator.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/BinaryOperator.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.search; +package org.nuiton.wikitty.search; // Start of user code for import Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Contains.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/Contains.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Contains.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.search; +package org.nuiton.wikitty.search; // Start of user code for import Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Element.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/Element.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Element.java 2010-05-12 15:08:48 UTC (rev 53) @@ -14,7 +14,7 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.search; +package org.nuiton.wikitty.search; import java.io.Serializable; Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/EndsWith.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/EndsWith.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/EndsWith.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.search; +package org.nuiton.wikitty.search; // Start of user code for import Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Equals.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/Equals.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Equals.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.search; +package org.nuiton.wikitty.search; // Start of user code for import Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Greater.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/Greater.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Greater.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.search; +package org.nuiton.wikitty.search; // Start of user code for import Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/GreaterOrEqual.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/GreaterOrEqual.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/GreaterOrEqual.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.search; +package org.nuiton.wikitty.search; // Start of user code for import Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/In.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/In.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/In.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.search; +package org.nuiton.wikitty.search; // Start of user code for import Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Keyword.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/Keyword.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Keyword.java 2010-05-12 15:08:48 UTC (rev 53) @@ -14,7 +14,7 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.search; +package org.nuiton.wikitty.search; /** * Search keyword in all wikitty Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Less.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/Less.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Less.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.search; +package org.nuiton.wikitty.search; // Start of user code for import Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/LessOrEqual.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/LessOrEqual.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/LessOrEqual.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.search; +package org.nuiton.wikitty.search; // Start of user code for import Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Like.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/Like.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Like.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,7 +15,7 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.search; +package org.nuiton.wikitty.search; import java.io.Serializable; Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Not.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/Not.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Not.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.search; +package org.nuiton.wikitty.search; // Start of user code for import Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/NotEquals.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/NotEquals.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/NotEquals.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.search; +package org.nuiton.wikitty.search; // Start of user code for import Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Or.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/Or.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Or.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.search; +package org.nuiton.wikitty.search; // Start of user code for import Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Restriction.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/Restriction.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Restriction.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.search; +package org.nuiton.wikitty.search; // Start of user code for import Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/RestrictionHelper.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/RestrictionHelper.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/RestrictionHelper.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.search; +package org.nuiton.wikitty.search; import java.text.SimpleDateFormat; import java.util.LinkedList; Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/RestrictionName.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/RestrictionName.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/RestrictionName.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.search; +package org.nuiton.wikitty.search; /** Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Search.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/Search.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Search.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,13 +1,13 @@ -package org.sharengo.wikitty.search; +package org.nuiton.wikitty.search; import java.util.ArrayList; import java.util.Collection; import java.util.List; -import org.sharengo.wikitty.Criteria; -import org.sharengo.wikitty.FieldType; -import org.sharengo.wikitty.Wikitty; -import org.sharengo.wikitty.WikittyUtil; +import org.nuiton.wikitty.Criteria; +import org.nuiton.wikitty.FieldType; +import org.nuiton.wikitty.Wikitty; +import org.nuiton.wikitty.WikittyUtil; /** * Helper to create a criteria with a restriction Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/SearchOperand.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/SearchOperand.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/SearchOperand.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.search; +package org.nuiton.wikitty.search; // Start of user code for import Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/StartsWith.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/StartsWith.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/StartsWith.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.search; +package org.nuiton.wikitty.search; // Start of user code for import Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/SubSearch.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/SubSearch.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/SubSearch.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.search; +package org.nuiton.wikitty.search; public class SubSearch extends Search { Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Unlike.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/search/Unlike.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/search/Unlike.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,11 +15,11 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.search; +package org.nuiton.wikitty.search; import java.io.Serializable; -import org.sharengo.wikitty.search.Like.SearchAs; +import org.nuiton.wikitty.search.Like.SearchAs; /** * UnLike is use on String field type, to precise some particularity on search Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/AbstractWikittyService.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/AbstractWikittyService.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/AbstractWikittyService.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,1231 +0,0 @@ -/* *##% - * Copyright (c) 2009 poussin. All rights reserved. - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - *##%*/ - -package org.sharengo.wikitty; - -import java.io.File; -import java.io.FileWriter; -import java.io.IOException; -import java.io.InputStreamReader; -import java.io.Reader; -import java.io.StringReader; -import java.io.StringWriter; -import java.io.Writer; -import java.net.URL; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Date; -import java.util.HashMap; -import java.util.HashSet; -import java.util.Iterator; -import java.util.LinkedHashMap; -import java.util.LinkedList; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.UUID; -import java.util.AbstractMap.SimpleEntry; -import java.util.Map.Entry; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import java.util.concurrent.Future; -import java.util.concurrent.FutureTask; - -import org.apache.commons.lang.StringEscapeUtils; -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; -import org.sharengo.wikitty.LabelImpl; -import org.sharengo.wikitty.TreeNodeImpl; -import org.sharengo.wikitty.search.Search; -import org.xmlpull.v1.XmlPullParser; -import org.xmlpull.v1.XmlPullParserFactory; - -/** - * Abstract class that new implementation must extends. - * New implementation only have three method to implement: - * <li>getSearchEngin - * <li>getExtensionStorage - * <li>getWikittyStorage - * - * @author poussin - * @version $Revision$ - * - * Last update: $Date$ - * by : $Author$ - */ -public abstract class AbstractWikittyService implements WikittyService { - - /** to use log facility, just put in your code: log.info(\"...\"); */ - static private Log log = LogFactory.getLog(AbstractWikittyService.class); - - // FIXME poussin 20090902 next 3 variables must be read from configuration file - /** number of thread used to import/export task */ - protected int MAX_IMPORT_EXPORT_THREAD = 1; - /** directory path where export asynchronous file are stored */ - protected String EXPORT_DIRECTORY = "/tmp/"; - /** url used by client to retrieve export file when job is ended */ - protected String EXPORT_URL = "file:///tmp/"; - - /** Executor that do import export task */ - protected ExecutorService importExportExecutor = - // TODO poussin 20090902 do thread number configurable - Executors.newFixedThreadPool(MAX_IMPORT_EXPORT_THREAD); - /** contains all import or export task, key is job id send to client */ - protected Map<String, Future<String>> importExportTask = - new HashMap<String, Future<String>>(); - - /** Default migration use to migrate a wikitty in last extension version */ - protected WikittyExtensionMigration defaultExtensionMigration = - new WikittyExtensionMigrationRename(); - - abstract protected WikittySearchEngin getSearchEngin(); - abstract protected WikittyExtensionStorage getExtensionStorage(); - abstract protected WikittyStorage getWikittyStorage(); - - protected UpdateResponse store(WikittyTransaction transaction, - Collection<Wikitty> wikitties, boolean disableAutoVersionIncrement) { - // update/store extension if necessary - Set<WikittyExtension> allExtensions = new HashSet<WikittyExtension>(); - for (Wikitty w : wikitties) { - // collect all extensions used by all wikitties - allExtensions.addAll(w.getExtensions()); - } - - // try to commit command - UpdateResponse extUpdate = getExtensionStorage().store(transaction, allExtensions); - UpdateResponse wikUpdate = getWikittyStorage().store(transaction, wikitties, disableAutoVersionIncrement); - UpdateResponse indexUpdate = getSearchEngin().store(transaction, wikitties); - - UpdateResponse result = new UpdateResponse(); - // prepare update client response - result.add(extUpdate); - result.add(wikUpdate); - result.add(indexUpdate); - - return result; - } - - /** - * Store and index wikitty object - * @param wikitty - */ - @Override - public UpdateResponse store(Wikitty wikitty) { - if (wikitty != null) { - WikittyTransaction transaction = new WikittyTransaction(); - try { - transaction.begin(); - - List<Wikitty> wikitties = Arrays.asList(wikitty); - UpdateResponse result = store(transaction, wikitties, false); - - transaction.commit(); - return result; - } catch (Exception eee) { - transaction.rollback(); - throw new WikittyException(eee); - } - } else { - throw new WikittyException("You can't store null wikitty object"); - } - } - - /** - * Store and index wikitties object - * @param wikitty - */ - @Override - public UpdateResponse store(Collection<Wikitty> wikitties) { - WikittyTransaction transaction = new WikittyTransaction(); - try { - transaction.begin(); - - UpdateResponse result = store(transaction, wikitties, false); - - transaction.commit(); - return result; - } catch (Exception eee) { - transaction.rollback(); - throw new WikittyException(eee); - } - } - - /** - * Store and index wikitties object - * @param wikitty - */ - @Override - public UpdateResponse store(Collection<Wikitty> wikitties, boolean disableAutoVersionIncrement) { - WikittyTransaction transaction = new WikittyTransaction(); - try { - transaction.begin(); - - UpdateResponse result = store(transaction, wikitties, disableAutoVersionIncrement); - - transaction.commit(); - return result; - } catch (Exception eee) { - transaction.rollback(); - throw new WikittyException(eee); - } - } - - @Override - public List<String> getAllExtensionIds() { - WikittyTransaction transaction = new WikittyTransaction(); - try { - transaction.begin(); - - List<String> result = getExtensionStorage().getAllExtensionIds(transaction); - - transaction.commit(); - return result; - } catch (Exception eee) { - transaction.rollback(); - throw new WikittyException(eee); - } - } - - @Override - public List<String> getAllExtensionsRequires(String extensionName) { - WikittyTransaction transaction = new WikittyTransaction(); - try { - transaction.begin(); - - List<String> result = getExtensionStorage() - .getAllExtensionsRequires(transaction, extensionName); - - transaction.commit(); - return result; - } catch (Exception eee) { - transaction.rollback(); - throw new WikittyException(eee); - } - } - - protected UpdateResponse storeExtension(WikittyTransaction transaction, Collection<WikittyExtension> exts) { - UpdateResponse result = getExtensionStorage().store(transaction, exts); - return result; - } - - /** - * Save just one extension - * @param ext - * @throws java.io.IOException - */ - @Override - public UpdateResponse storeExtension(Collection<WikittyExtension> exts) { - WikittyTransaction transaction = new WikittyTransaction(); - try { - transaction.begin(); - - UpdateResponse result = storeExtension(transaction, exts); - - transaction.commit(); - return result; - } catch (Exception eee) { - transaction.rollback(); - throw new WikittyException(eee); - } - } - - @Override - public UpdateResponse storeExtension(WikittyExtension ext) { - WikittyTransaction transaction = new WikittyTransaction(); - try { - transaction.begin(); - - UpdateResponse result = storeExtension(transaction, Arrays.asList(ext)); - - transaction.commit(); - return result; - } catch (Exception eee) { - transaction.rollback(); - throw new WikittyException(eee); - } - } - - protected WikittyExtension restoreExtension(WikittyTransaction transaction, String id) { - //split the id to ensure that version is normalized - String name = WikittyExtension.computeName(id); - String version = WikittyExtension.computeVersion(id); - - WikittyExtension result = getExtensionStorage().restore(transaction, name, version); - return result; - } - /** - * Load extension from id. Id is 'name[version]' - * @param id - * @return - */ - @Override - public WikittyExtension restoreExtension(String id) { - WikittyTransaction transaction = new WikittyTransaction(); - try { - transaction.begin(); - - WikittyExtension result = restoreExtension(transaction, id); - - transaction.commit(); - return result; - } catch (Exception eee) { - transaction.rollback(); - throw new WikittyException(eee); - } - - } - - protected WikittyExtension restoreExtensionLastVersion(WikittyTransaction transaction, String name) { - String version = getExtensionStorage().getLastVersion(transaction, name); - if(version == null) { - return null; - } - - WikittyExtension result = getExtensionStorage().restore(transaction, name, version); - return result; - } - - @Override - public WikittyExtension restoreExtensionLastVersion(String name) { - WikittyTransaction transaction = new WikittyTransaction(); - try { - transaction.begin(); - - WikittyExtension result = restoreExtensionLastVersion(transaction, name); - - transaction.commit(); - return result; - } catch (Exception eee) { - transaction.rollback(); - throw new WikittyException(eee); - } - } - - protected Wikitty restore(WikittyTransaction transaction, String id) { - if (!getWikittyStorage().exists(transaction, id)) { - // object doesn't exist, we return null - return null; - } - - if (getWikittyStorage().isDeleted(transaction, id)) { - // object deleted, we return null - return null; - } - Wikitty result = getWikittyStorage().restore(transaction, id); - if(result != null) { - result = upgradeData(transaction, result); - } - return result; - } - - protected List<Wikitty> restore(WikittyTransaction transaction, List<String> ids) { - List<Wikitty> result = new ArrayList<Wikitty>(); - for(String id : ids) { - Wikitty w = restore(transaction, id); - if (w != null) { - result.add(w); - } - } - return result; - } - - @Override - public List<Wikitty> restore(List<String> ids) { - WikittyTransaction transaction = new WikittyTransaction(); - try { - transaction.begin(); - - List<Wikitty> result = restore(transaction, ids); - - transaction.commit(); - return result; - } catch (Exception eee) { - transaction.rollback(); - throw new WikittyException(eee); - } - } - - @Override - public Wikitty restore(String id) { - WikittyTransaction transaction = new WikittyTransaction(); - try { - transaction.begin(); - - Wikitty result = restore(transaction, id); - - transaction.commit(); - return result; - } catch (Exception eee) { - transaction.rollback(); - throw new WikittyException(eee); - } - } - - protected Wikitty upgradeData(WikittyTransaction transaction, Wikitty wikitty) { - Wikitty result = wikitty; - - Collection<WikittyExtension> extensions = wikitty.getExtensions(); - for (WikittyExtension extension : extensions) { - String extensionName = extension.getName(); - log.debug("extensionName=" + extensionName); - - WikittyExtension currentExtension = extension; - String currentExtensionVersion = currentExtension.getVersion(); - - WikittyExtension lastExtension = restoreExtensionLastVersion(transaction, extensionName); - String lastExtensionVersion = lastExtension.getVersion(); - log.debug("lastExtensionVersion=" + lastExtensionVersion); - - WikittyExtensionMigration migration = WikittyExtensionMigration.migrationRegistry.get(extensionName); - if (migration == null) { - migration = defaultExtensionMigration; - } - - // Loop on between extension in wikitty and last version - while(WikittyUtil.versionGreaterThan(lastExtensionVersion, currentExtensionVersion)) { - - // Get extension after the current version - String nextExtensionVersion = WikittyUtil.incrementMajorRevision(currentExtensionVersion); - String nextExtensionId = WikittyExtension.computeId(extensionName, nextExtensionVersion); - WikittyExtension nextExtension = restoreExtension(transaction, nextExtensionId); - - log.debug("currentExtensionVersion=" + currentExtensionVersion); - log.debug("nextExtensionVersion=" + nextExtensionVersion); - - // Test if extension is never use in this version - if(nextExtension != null) { - result = migration.migrate(this, transaction, result, currentExtension, nextExtension); - currentExtension = nextExtension; - } - - // Follow - currentExtensionVersion = nextExtensionVersion; - } - } - - return result; - } - - protected void delete(WikittyTransaction transaction, Collection<String> ids) throws WikittyException { - // work only on valid id - Collection<Wikitty> storedWikitties = new ArrayList<Wikitty>(); - List<String> idList = new LinkedList<String>(ids); - for (Iterator<String> i = idList.iterator(); i.hasNext();) { - String id = i.next(); - // test if wikitty exists - if (!getWikittyStorage().exists(transaction, id)) { - // don't exist, remove this id in id list - i.remove(); - } - if (getWikittyStorage().isDeleted(transaction, id)) { - // already deleted, remove this id in id list - i.remove(); - } - - // Store node with have deleted node as parent - Criteria criteria = Search.query().eq(TreeNode.FQ_FIELD_PARENT, id).criteria(); - List<Wikitty> wikittyNodes = findAllByCriteria(transaction, criteria).getAll(); - for (Wikitty wikittyNode : wikittyNodes) { - String wikittyNodeId = wikittyNode.getId(); - if(!ids.contains(wikittyNodeId)) { - TreeNode treeNode = new TreeNodeImpl(wikittyNode); - treeNode.setParent(null); - storedWikitties.add(wikittyNode); - } - } - - // Store node with have deleted child - criteria = Search.query().eq(TreeNode.FQ_FIELD_CHILDREN, id).criteria(); - wikittyNodes = findAllByCriteria(transaction, criteria).getAll(); - for (Wikitty wikittyNode : wikittyNodes) { - String wikittyNodeId = wikittyNode.getId(); - if(!ids.contains(wikittyNodeId)) { - TreeNode treeNode = new TreeNodeImpl(wikittyNode); - treeNode.removeChildren(id); - storedWikitties.add(wikittyNode); - } - } - } - - getWikittyStorage().delete(transaction, ids); - getSearchEngin().delete(transaction, ids); - - store(transaction, storedWikitties, false); - } - - @Override - public void delete(String id) { - WikittyTransaction transaction = new WikittyTransaction(); - try { - transaction.begin(); - - List<String> ids = Arrays.asList(id); - delete(transaction, ids); - - transaction.commit(); - } catch (Exception eee) { - transaction.rollback(); - throw new WikittyException(eee); - } - } - - @Override - public void delete(Collection<String> ids){ - WikittyTransaction transaction = new WikittyTransaction(); - try { - transaction.begin(); - - delete(transaction, ids); - - transaction.commit(); - } catch (Exception eee) { - transaction.rollback(); - throw new WikittyException(eee); - } - } - - /** - * Use with caution : It will delete ALL indexes from search engine ! - * This operation should be disabled in production environment. - */ - @Override - public void clear() { - WikittyTransaction transaction = new WikittyTransaction(); - try { - transaction.begin(); - - getSearchEngin().clear(transaction); - getWikittyStorage().clear(transaction); - getExtensionStorage().clear(transaction); - - transaction.commit(); - } catch (Exception eee) { - transaction.rollback(); - throw new WikittyException(eee); - } - } - - /** - * Assume that this PagedResult contains wikitty id as result and - * return new PagedResult with Wikitty instance - */ - protected PagedResult<Wikitty> findAllByCriteria(WikittyTransaction transaction, Criteria criteria) { - PagedResult<String> resultIds = getSearchEngin().findAllByCriteria(transaction, criteria); - List<String> ids = resultIds.getAll(); - List<Wikitty> wikitties = restore(transaction, ids); - PagedResult<Wikitty> result = new PagedResult<Wikitty>( - resultIds.getFirstIndice(), - resultIds.getNumFound(), - resultIds.getQueryString(), - resultIds.getFacets(), - wikitties); - return result; - } - - @Override - public PagedResult<Wikitty> findAllByCriteria(Criteria criteria) { - WikittyTransaction transaction = new WikittyTransaction(); - try { - transaction.begin(); - - PagedResult<Wikitty> result = findAllByCriteria(transaction, criteria); - - transaction.commit(); - return result; - } catch (Exception eee) { - transaction.rollback(); - throw new WikittyException(eee); - } - } - - protected Wikitty findByCriteria(WikittyTransaction transaction, Criteria criteria) { - criteria.setFirstIndex(0).setEndIndex(1); - PagedResult<Wikitty> pages = findAllByCriteria(transaction, criteria); - - Wikitty result = null; - if (pages.size() > 0) { - result = pages.getFirst(); - } - - return result; - } - - @Override - public Wikitty findByCriteria(Criteria criteria) { - WikittyTransaction transaction = new WikittyTransaction(); - try { - transaction.begin(); - - Wikitty result = findByCriteria(transaction, criteria); - - transaction.commit(); - return result; - } catch (Exception eee) { - transaction.rollback(); - throw new WikittyException(eee); - } - } - - @Override - public void addLabel(String wikittyId, String label) { - WikittyTransaction transaction = new WikittyTransaction(); - try { - transaction.begin(); - - Wikitty w = restore(transaction, wikittyId); - w.addExtension(LabelImpl.extensions); - LabelImpl l = new LabelImpl(w); - l.addLabels(label); - store(transaction, Arrays.asList(w), false); - - transaction.commit(); - } catch (Exception eee) { - transaction.rollback(); - throw new WikittyException(eee); - } - } - - - @Override - public PagedResult<Wikitty> findAllByLabel(String label, int firstIndex, int endIndex) { - WikittyTransaction transaction = new WikittyTransaction(); - try { - transaction.begin(); - - LabelImpl l = new LabelImpl(); - l.addLabels(label); - Criteria criteria = Search.query(l.getWikitty()).criteria() - .setFirstIndex(firstIndex).setEndIndex(endIndex); - PagedResult<Wikitty> result = findAllByCriteria(transaction, criteria); - - transaction.commit(); - return result; - } catch (Exception eee) { - transaction.rollback(); - throw new WikittyException(eee); - } - } - - - @Override - public Wikitty findByLabel(String label) { - WikittyTransaction transaction = new WikittyTransaction(); - try { - transaction.begin(); - - LabelImpl l = new LabelImpl(); - l.addLabels(label); - Criteria criteria = Search.query(l.getWikitty()).criteria(); - Wikitty result = findByCriteria(transaction, criteria); - - transaction.commit(); - return result; - } catch (Exception eee) { - transaction.rollback(); - throw new WikittyException(eee); - } - } - - - @Override - public Set<String> findAllAppliedLabels(String wikittyId) { - WikittyTransaction transaction = new WikittyTransaction(); - try { - transaction.begin(); - - Wikitty w = restore(transaction, wikittyId); - LabelImpl l = new LabelImpl(w); - Set<String> result = l.getLabels(); - - transaction.commit(); - return result; - } catch (Exception eee) { - transaction.rollback(); - throw new WikittyException(eee); - } - } - - - protected Tree restoreTree(WikittyTransaction transaction, String wikittyId) { - Wikitty w = restore(transaction, wikittyId); - if(w == null) { - return null; - } - - if ( !w.hasExtension(TreeNode.EXT_TREENODE) ) { - throw new WikittyException(String.format( - "Wikitty '%s' do not handle extension %s", - wikittyId, TreeNode.EXT_TREENODE )); - } - Tree tree = new Tree(); - TreeNode node = AbstractWikittyService.toBean(new TreeNodeImpl(w)); - tree.setNode(node); - - TreeNodeImpl exempleNode = new TreeNodeImpl(); - exempleNode.setParent(wikittyId); - - Criteria criteria = Search.query(exempleNode.getWikitty()).criteria() - .setFirstIndex(0).setEndIndex(Criteria.ALL_ELEMENTS); - PagedResult<Wikitty> childNodes = findAllByCriteria(transaction, criteria); - for( Wikitty childNode : childNodes.getAll() ) { - tree.addChild(restoreTree(transaction, childNode.getId())); - } - - return tree; - } - - @Override - public Tree restoreTree(String wikittyId) { - WikittyTransaction transaction = new WikittyTransaction(); - try { - transaction.begin(); - - Tree tree = restoreTree(transaction, wikittyId); - - transaction.commit(); - return tree; - } catch (Exception eee) { - transaction.rollback(); - throw new WikittyException(eee); - } - } - - @Override - public Map.Entry<TreeNode, Integer> restoreNode(String wikittyId, Criteria filter) { - WikittyTransaction transaction = new WikittyTransaction(); - try { - transaction.begin(); - - Wikitty w = restore(transaction, wikittyId); - if(w == null) { - transaction.commit(); - return null; - } - - if ( !w.hasExtension(TreeNode.EXT_TREENODE) ) { - throw new WikittyException(String.format( - "Wikitty '%s' do not handle extension %s", - wikittyId, TreeNode.EXT_TREENODE )); - } - - TreeNode node = AbstractWikittyService.toBean(new TreeNodeImpl(w)); - Integer count = getSearchEngin().findNodeCount(transaction, w, filter); - - HashMap.SimpleEntry<TreeNode, Integer> result = - new SimpleEntry<TreeNode, Integer>(node, count); - - transaction.commit(); - return result; - } catch (Exception eee) { - transaction.rollback(); - throw new WikittyException(eee); - } - } - - @Override - public Map<TreeNode, Integer> restoreChildren(String wikittyId, Criteria filter) { - WikittyTransaction transaction = new WikittyTransaction(); - try { - transaction.begin(); - - Wikitty w = restore(transaction, wikittyId); - if(w == null) { - transaction.commit(); - return null; - } - - if ( !w.hasExtension(TreeNode.EXT_TREENODE) ) { - throw new WikittyException(String.format( - "Wikitty '%s' do not handle extension %s", - wikittyId, TreeNode.EXT_TREENODE )); - } - - Map<TreeNode, Integer> result = new LinkedHashMap<TreeNode, Integer>(); - - Map<String, Integer> search = getSearchEngin().findAllChildrenCount(transaction, w, filter); - Set<Entry<String, Integer>> children = search.entrySet(); - for (Entry<String, Integer> child : children) { - Integer count = child.getValue(); - - String id = child.getKey(); - Wikitty wikitty = restore(transaction, id); - TreeNode node = AbstractWikittyService.toBean(new TreeNodeImpl(wikitty)); - - result.put(node, count); - } - - transaction.commit(); - return result; - } catch (Exception eee) { - transaction.rollback(); - throw new WikittyException(eee); - } - } - - @Override - public Wikitty restoreVersion(String wikittyId, String version) { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public UpdateResponse syncEngin() { - final WikittyTransaction transaction = new WikittyTransaction(); - try { - final int numberForCommit = 1000; - final WikittySearchEngin searchEngin = getSearchEngin(); - final UpdateResponse result = new UpdateResponse(); - final List<Wikitty> wikitties = new ArrayList<Wikitty>(numberForCommit); - - transaction.begin(); - searchEngin.clear(transaction); - transaction.commit(); - transaction.begin(); - - getWikittyStorage().scanWikitties(transaction, new WikittyStorage.Scanner() { - int count = 0; - - @Override - public void scan(Wikitty wikitty) { - Date deleteDate = wikitty.getDeleteDate(); - if(deleteDate == null) { - count ++; - wikitties.add(wikitty); - - if(count == numberForCommit) { - // Reindex - UpdateResponse response = searchEngin.store(transaction, wikitties); - result.add(response); - transaction.commit(); - // Reinit - count = 0; - wikitties.clear(); - transaction.begin(); - } - } - } - }); - - // Last wikitties - UpdateResponse response = searchEngin.store(transaction, wikitties); - result.add(response); - - transaction.commit(); - return result; - } catch (Exception eee) { - transaction.rollback(); - throw new WikittyException(eee); - } - } - - /** - * Class used for import process, this class retain numberForCommit object - * before to send it to storage. - */ - static protected class WikittyBatchUpdate { - // TODO poussin 20090902 do configurable numberForCommit - protected int numberForCommit = 1000; - protected int currentAdded = 0; - protected Map<String, WikittyExtension> exts = new HashMap<String, WikittyExtension>(); - protected List<Wikitty> wikitties = new LinkedList<Wikitty>(); - - protected AbstractWikittyService ws; - protected WikittyTransaction transaction; - - public WikittyBatchUpdate(AbstractWikittyService ws, WikittyTransaction transaction) { - this.ws = ws; - this.transaction = transaction; - } - - public void addExtension(WikittyExtension ext) { - exts.put(ext.getId(), ext); - inc(); - } - - public void addWikitty(Wikitty w) { - wikitties.add(w); - inc(); - } - - /** - * search extension in local extension list and if missed restore - * extension from internal WikittyService - * @param id - * @return - */ - public WikittyExtension getExtension(WikittyTransaction transaction, String id) { - WikittyExtension result = exts.get(id); - if (result == null) { - result = ws.restoreExtension(transaction, id); - } - return result; - } - - public void flush() { - ws.storeExtension(transaction, exts.values()); - ws.store(transaction, wikitties, true); - - exts.clear(); - wikitties.clear(); - currentAdded = 0; - } - - protected void inc() { - currentAdded++; - if (currentAdded >= numberForCommit) { - flush(); - } - } - } - - - @Override - public void syncImportFromXml(String xml) { - Reader reader = new StringReader(xml); - ImportTask task = new ImportTask(this, reader); - task.run(); - } - - - @Override - public void syncImportFromUri(String uri) { - try { - URL url = new URL(uri); - Reader reader = new InputStreamReader(url.openStream()); - ImportTask task = new ImportTask(this, reader); - task.run(); - } catch (Exception eee) { - throw new WikittyException(eee); - } - } - - - @Override - public String asyncImportFromUri(String uri) { - try { - URL url = new URL(uri); - Reader reader = new InputStreamReader(url.openStream()); - ImportTask task = new ImportTask(this, reader); - FutureTask<String> future = new FutureTask<String>(task, null); - importExportExecutor.submit(future); - - String jobId = UUID.randomUUID().toString(); - importExportTask.put(jobId, future); - return jobId; - } catch (Exception eee) { - throw new WikittyException(eee); - } - } - - - static public class ImportTask implements Runnable { - protected AbstractWikittyService ws; - protected WikittyTransaction transaction; - protected Reader reader; - - public ImportTask(AbstractWikittyService ws, Reader reader) { - this.ws = ws; - this.reader = reader; - this.transaction = new WikittyTransaction(); - } - - @Override - public void run() { - try { - transaction.begin(); - XmlPullParserFactory factory = XmlPullParserFactory.newInstance( - System.getProperty(XmlPullParserFactory.PROPERTY_NAME), null); - factory.setNamespaceAware(true); - XmlPullParser xpp = factory.newPullParser(); - xpp.setInput(reader); - - WikittyExtension ext = null; - Wikitty w = null; - String CDATA = null; - - WikittyBatchUpdate batchUpdate = new WikittyBatchUpdate(ws, transaction); - - long time = System.currentTimeMillis(); - - int eventType = xpp.getEventType(); - do { - String objectVersion = null; - if (eventType == xpp.START_DOCUMENT) { - log.info("start XML import at " + new Date()); - } else if (eventType == xpp.END_DOCUMENT) { - time = System.currentTimeMillis() - time; - log.info("XML import in (ms)" + time); - } else if (eventType == xpp.START_TAG) { - String name = xpp.getName(); - if ("extension".equals(name)) { - String extName = xpp.getAttributeValue(null, "name"); - String version = xpp.getAttributeValue(null, "version"); - String requires = xpp.getAttributeValue(null, "requires"); - ext = new WikittyExtension(extName, version, requires, new LinkedHashMap<String, FieldType>()); - } else if ("object".equals(name)) { - String id = xpp.getAttributeValue(null, "id"); - objectVersion = xpp.getAttributeValue(null, "version"); - String extensions = xpp.getAttributeValue(null, "extensions"); - w = new Wikitty(id); - String[] extensionList = extensions.split(","); - for (String extId : extensionList) { - String extName = WikittyExtension.computeName(extId); - String extVersion = WikittyExtension.computeVersion(extId); - extId = WikittyExtension.computeId(extName, extVersion); - WikittyExtension e = batchUpdate.getExtension(transaction, extId); - if(e == null) { - throw new WikittyException("Extension not found : " + extId); - } - w.addExtension(e); - } - } - } else if (eventType == xpp.END_TAG) { - String name = xpp.getName(); - if ("extension".equals(name)) { - batchUpdate.addExtension(ext); - ext = null; - } else if ("object".equals(name)) { - w.setVersion(objectVersion); - batchUpdate.addWikitty(w); - w = null; - } else if (ext != null && "field".equals(name)) { - FieldType type = new FieldType(); - String fieldName = WikittyUtil.parseField(CDATA, type); - ext.addField(fieldName, type); - } else if (ext != null && "tagvalues".equals(name)) { - Map<String, String> tagValues = WikittyUtil.tagValuesToMap(CDATA); - ext.setTagValues(tagValues); - } else if (w != null) { - String[] fq = name.split("\\."); - String extensionName = fq[0]; - String fieldName = fq[1]; - FieldType fieldType = w.getFieldType(name); - if(fieldType.isCollection()) { - w.addToField(extensionName, fieldName, CDATA); - } else { - w.setField(extensionName, fieldName, CDATA); - } - } - } else if (eventType == xpp.TEXT) { - CDATA = xpp.getText(); - } - eventType = xpp.next(); - } while (eventType != xpp.END_DOCUMENT); - - // don't forget to flush batchUpdate :) - batchUpdate.flush(); - transaction.commit(); - } catch (Exception eee) { - transaction.rollback(); - throw new WikittyException(eee); - } - } - } // end ImportTask - - @Override - public String asyncExportAllByCriteria(Criteria criteria) { - try { - String jobId = UUID.randomUUID().toString(); - - File file = new File(EXPORT_DIRECTORY, jobId); - String url = EXPORT_URL + jobId; - Writer result = new FileWriter(file); - ExportTask task = new ExportTask(this, criteria, result); - FutureTask<String> future = new FutureTask<String>(task, url); - importExportExecutor.submit(future); - - importExportTask.put(jobId, future); - return jobId; - } catch (Exception eee) { - throw new WikittyException(eee); - } - } - - - @Override - public String syncExportAllByCriteria(Criteria criteria) { - StringWriter result = new StringWriter(); - ExportTask task = new ExportTask(this, criteria, result); - task.run(); - return result.toString(); - } - - - static public class ExportTask implements Runnable { - protected AbstractWikittyService ws; - protected WikittyTransaction transaction; - - protected Criteria criteria; - protected Writer result; - - public ExportTask(AbstractWikittyService ws, Criteria criteria, Writer result) { - this.ws = ws; - this.transaction = new WikittyTransaction(); - this.criteria = criteria; - this.result = result; - } - - @Override - public void run() { - try { - transaction.begin(); - PagedResult<Wikitty> pageResult = ws.findAllByCriteria(transaction, criteria); - - // keep extension already done - Set<String> extDone = new HashSet<String>(); - result.write("<wikengo>\n"); - for (Wikitty w : pageResult.getAll()) { - String extensionList = ""; - for (WikittyExtension ext : w.getExtensions()) { - String id = ext.getId(); - extensionList += "," + id; - if (!extDone.contains(id)) { - extDone.add(id); - result.write(" <extension name='" + ext.getName() - + "' version='" + ext.getVersion() - + (ext.getRequires() != null ? "' requires='" + ext.getRequires() : "") - + "'>\n"); - Map<String, String> tagValues = ext.getTagValues(); - result.write(" <tagvalues>" + WikittyUtil.tagValuesToString(tagValues) + "</tagvalues>\n"); - for (String fieldName : ext.getFieldNames()) { - String def = ext.getFieldType(fieldName).toDefinition(fieldName); - result.write(" <field>" + def + "</field>\n"); - } - result.write(" </extension>\n"); - } - } - if (!"".equals(extensionList)) { - // delete first ',' - extensionList = extensionList.substring(1); - } - result.write(" <object id='" + w.getId() + "' version='" + w.getVersion() + "' extensions='" + extensionList + "'>\n"); - for (String fieldName : w.fieldNames()) { - FieldType type = w.getFieldType(fieldName); - if (type.isCollection()) { - Object fqField = w.getFqField(fieldName); - if (fqField != null) { - for (Object o : (Collection) fqField) { - String fqFieldValue = WikittyUtil.toString(type, o); - if (fqFieldValue != null) { - fqFieldValue = StringEscapeUtils.escapeXml(fqFieldValue); - result.write(" <" + fieldName + ">" + fqFieldValue + "</" + fieldName + ">\n"); - } - } - } - } else { - String fqFieldValue = WikittyUtil.toString(type, w.getFqField(fieldName)); - if (fqFieldValue != null) { - fqFieldValue = StringEscapeUtils.escapeXml(fqFieldValue); - result.write(" <" + fieldName + ">" + fqFieldValue + "</" + fieldName + ">\n"); - } - } - } - result.write(" </object>\n"); - } - result.write("</wikengo>\n"); - transaction.commit(); - } catch (IOException eee) { - transaction.rollback(); - throw new WikittyException(eee); - } - } - } // end ExportTask - - - @Override - public JobState infoJob(String jobId) { - try { - Future<String> future = importExportTask.get(jobId); - JobState result = new JobState(); - if (future.isDone()) { - result.status = "done"; - result.resourceUri = future.get(); - } else if (future.isCancelled()) { - result.status = "cancelled"; - } else { - result.status = "inProgress"; - } - return result; - } catch (Exception eee) { - throw new WikittyException(eee); - } - } - - - @Override - public void cancelJob(String jobId) { - Future future = importExportTask.get(jobId); - future.cancel(true); // true to kill process, perhaps to strong ? - } - - - @Override - public void freeJobResource(String jobId) { - Future<String> future = importExportTask.remove(jobId); - if (future != null) { - File file = new File(EXPORT_DIRECTORY, jobId); - file.delete(); - } - } - - /** - * Method copied from eugengo-0.7 generators - * - * @param bean - * @return - */ - /*public static TreeNodeImpl toImpl(TreeNode bean) { - if (bean == null) return null; - TreeNodeImpl impl = new TreeNodeImpl(bean); - return impl; - }*/ - - /** - * Method copied from eugengo-0.7 generators - * - * @param bean - * @return - */ - protected static void fillBeanAttributes(TreeNode fromBean, TreeNodeBean toBean) { - String beanId = fromBean.getWikittyId(); - toBean.id = beanId; - - String beanVersion = fromBean.getWikittyVersion(); - toBean.setWikittyVersion(beanVersion); - - toBean.setName(fromBean.getName()); - toBean.setParent(fromBean.getParent()); - // WARNING: Copy collection to other collection to not manipulate storage collection directly - Collection<String> treeNodeChildren = fromBean.getChildren(); - if(treeNodeChildren != null) { - toBean.TreeNode$children = new HashSet<String>(treeNodeChildren); - } - } - - /** - * Method copied from eugengo-0.7 generators - * - * @param impl - * @return - */ - public static TreeNode toBean(TreeNodeImpl impl) { - if (impl == null) return null; - TreeNodeBean bean = new TreeNodeBean(); - AbstractWikittyService.fillBeanAttributes(impl, bean); - return bean; - } -} Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/BusinessEntity.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/BusinessEntity.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/BusinessEntity.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,81 +0,0 @@ -/* *##% - * Copyright (c) 2009 Sharengo, Guillaume Dufrene, Benjamin POUSSIN. - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - *##%*/ - -package org.sharengo.wikitty; - -import java.io.Serializable; -import java.util.Collection; - -/** - * Used as parent interface to all Business class - * - * @author poussin - * @version $Revision$ - * - * Last update: $Date$ - * by : $Author$ - */ -public interface BusinessEntity extends Serializable, Cloneable { - - public String getWikittyId(); - public String getWikittyVersion(); - /** - * Only framework can use this method - * @param version - */ - public void setWikittyVersion(String version); - - /** - * Return list of all extension for this object - * @return - */ - public Collection<String> getExtensionNames(); - - /** - * Return list of all field for this object - * @param ext - * @return - */ - public Collection<String> getExtensionFields(String ext); - - /** - * Return field value for the specifique extension and field - * @param ext - * @param fieldName - * @return - */ - public Object getField(String ext, String fieldName); - - /** - * set field value for the specifique extension and field. - * This method don't check the type of value for this field. - * @param ext - * @param fieldName - * @param value - * @return - */ - public void setField(String ext, String fieldName, Object value); - - /** - * Return the field type - * @param ext - * @param fieldName - * @return - */ - public FieldType getFieldType(String ext, String fieldName); - -} Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/BusinessEntityBean.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/BusinessEntityBean.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/BusinessEntityBean.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,92 +0,0 @@ -/* *##% - * Copyright (c) 2009 poussin. All rights reserved. - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - *##%*/ - -package org.sharengo.wikitty; - -import java.util.Collection; -import java.util.HashMap; -import java.util.LinkedHashMap; -import java.util.Map; - -/** - * - * @author poussin - * @version $Revision$ - * - * Last update: $Date$ - * by : $Author$ - */ -public class BusinessEntityBean implements BusinessEntity { - - private static final long serialVersionUID = 1L; - - protected String id; - protected String version; - - /** - * Map is LinkedHashMap to maintains order like user want - * key: extension name - * value: extension definition - */ - protected Map<String, WikittyExtension> extensions = - new LinkedHashMap<String, WikittyExtension>(); - /** - * key: field name prefixed by extension name (dot separator) - * value: value of field - */ - protected Map<String, Object> fieldValue = new HashMap<String, Object>(); - - public String getWikittyId() { - return id; - } - - public String getWikittyVersion() { - return version; - } - - public void setWikittyVersion(String version) { - this.version = version; - } - - - public Collection<String> getExtensionNames() { - Collection<String> result = extensions.keySet(); - return result; - } - - public Collection<String> getExtensionFields(String ext) { - WikittyExtension extension = extensions.get(ext); - Collection<String> result = extension.getFieldNames(); - return result; - } - - public Object getField(String ext, String fieldName) { - String key = ext + "$" + fieldName; - Object result = fieldValue.get(key); - return result; - } - - public void setField(String ext, String fieldName, Object value) { - String key = ext + "$" + fieldName; - fieldValue.put(key, value); - } - - public FieldType getFieldType(String ext, String fieldName) { - throw new UnsupportedOperationException("Not supported yet."); - } - -} Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/BusinessEntityWikitty.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/BusinessEntityWikitty.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/BusinessEntityWikitty.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,101 +0,0 @@ -/* *##% - * Copyright (c) 2009 Sharengo, Guillaume Dufrene, Benjamin POUSSIN. - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - *##%*/ - -package org.sharengo.wikitty; - -import java.util.Collection; -import java.util.Collections; - -/** - * - * @author poussin - * @version $Revision$ - * - * Each business object will inherit of this class. - * - * Last update: $Date$ - * by : $Author$ - */ -public class BusinessEntityWikitty implements BusinessEntity { - - private static final long serialVersionUID = 1L; - - protected Wikitty wikitty; - - public BusinessEntityWikitty(Wikitty wi) { - setWikitty(wi); - } - - public BusinessEntityWikitty() { - setWikitty(new Wikitty()); - } - - public String getWikittyId() { - String result = getWikitty().getId(); - return result; - } - - public String getWikittyVersion() { - String result = getWikitty().getVersion(); - return result; - } - - public void setWikittyVersion(String version) { - getWikitty().setVersion(version); - } - - public void setWikitty(Wikitty wikitty) { - if(wikitty != null) { - for (WikittyExtension ext : getStaticExtensions()) { - wikitty.addExtension(ext); - } - } - this.wikitty = wikitty; - } - - public Wikitty getWikitty() { - return wikitty; - } - - public Collection<String> getExtensionNames() { - Collection<String> result = getWikitty().getExtensionNames(); - return result; - } - - public Collection<String> getExtensionFields(String ext) { - Collection<String> result = getWikitty().getExtension(ext).getFieldNames(); - return result; - } - - public FieldType getFieldType(String ext, String fieldName) { - FieldType result = getWikitty().getExtension(ext).getFieldType(fieldName); - return result; - } - - public Object getField(String ext, String fieldName) { - Object result = getWikitty().getFieldAsObject(ext, fieldName); - return result; - } - - public void setField(String ext, String fieldName, Object value) { - getWikitty().setField(ext, fieldName, value); - } - - public Collection<WikittyExtension> getStaticExtensions() { - return Collections.emptyList(); - } -} Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/Criteria.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/Criteria.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/Criteria.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,236 +0,0 @@ -/* *##% - * Copyright (c) 2009 Sharengo, Guillaume Dufrene, Benjamin POUSSIN. - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - *##%*/ - -package org.sharengo.wikitty; - -import java.beans.XMLDecoder; -import java.beans.XMLEncoder; -import java.io.ByteArrayInputStream; -import java.io.ByteArrayOutputStream; -import java.io.InputStream; -import java.io.OutputStream; -import java.io.Serializable; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; - -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; -import org.sharengo.wikitty.search.Restriction; - -/** - * Criteria represent the search on the wikitty with restriction on field and - * informations on facet, paggination and sortting. - *<p> - * For search multiple extension use ALL_EXTENSIONS as extension name and - * specify field type. - * <p> - * Example : Criteria.ALL_EXTENSIONS + Criteria.SEPARATOR + <fieldName> + Criteria.SEPARATOR + FieldType.TYPE.<fieldType> - * - * @author poussin - * @version $Revision$ - * - * Last update: $Date$ - * by : $Author$ - */ -public class Criteria implements Serializable { - - /** serialVersionUID. */ - private static final long serialVersionUID = 2590223960861630283L; - - /** to use log facility, just put in your code: log.info(\"...\"); */ - static private Log log = LogFactory.getLog(Criteria.class); - - /** Use to not limit result */ - static public int ALL_ELEMENTS = -1; - - /** Search on all extension */ - static public String ALL_EXTENSIONS = "*"; - - /** Search on all values */ - static public String ALL_VALUES = "*"; - - /** Separator between extension name, field name and type */ - static public String SEPARATOR = "."; - - /** - * Criteria can have name this help for presentation and is very - * useful for facet created by criteria - */ - protected String name; - - /** All restriction on fields */ - private Restriction restriction; - - /** First index to get result */ - private int firstIndex = 0; - /** Last index to get result */ - private int endIndex = ALL_ELEMENTS; - - /** Facet on criteria */ - private List<Criteria> facetCriteria; - /** Facet on field */ - private List<String> facetField; - - /** Sort ascending on fields */ - private List<String> sortAscending; - /** Sort descending on fields */ - private List<String> sortDescending; - - /** - * Default constuctor - */ - public Criteria() { - } - - /** - * Create named criteria - * @param name - */ - public Criteria(String name) { - this.name = name; - } - - /** - * Deserialize xml to criteria - * @param xml - * @return criteria - */ - public static Criteria fromXML(String xml) { - InputStream inputStream = new ByteArrayInputStream(xml.getBytes()); - XMLDecoder decoder = new XMLDecoder(inputStream); - Criteria criteria = (Criteria) decoder.readObject(); - return criteria; - } - - /** - * Serialize criteria to xml - * @param criteria - * @return xml string - */ - public static String toXML(Criteria criteria) { - OutputStream outputStream = new ByteArrayOutputStream(); - XMLEncoder encoder = new XMLEncoder(outputStream); - encoder.writeObject(criteria); - encoder.close(); - String result = outputStream.toString(); - return result; - } - - public Restriction getRestriction() { - return restriction; - } - - public void setRestriction(Restriction restriction) { - this.restriction = restriction; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - public int getFirstIndex() { - return firstIndex; - } - - public Criteria setFirstIndex(int firstIndex) { - this.firstIndex = firstIndex; - return this; - } - - public int getEndIndex() { - return endIndex; - } - - public Criteria setEndIndex(int endIndex) { - this.endIndex = endIndex; - return this; - } - - public List<Criteria> getFacetCriteria() { - return facetCriteria; - } - - public Criteria addFacetCriteria(Criteria criteria) { - if (facetCriteria == null) { - facetCriteria = new ArrayList<Criteria>(); - } - facetCriteria.add(criteria); - return this; - } - - public Criteria setFacetCriteria(Criteria[] facetCriteria) { - this.facetCriteria = Arrays.asList(facetCriteria); - return this; - } - - public List<String> getFacetField() { - return facetField; - } - - public Criteria addFacetField(String field) { - if (facetField == null) { - facetField = new ArrayList<String>(); - } - facetField.add(field); - return this; - } - - public Criteria setFacetField(String[] facetField) { - this.facetField = Arrays.asList(facetField); - return this; - } - - public List<String> getSortAscending() { - return sortAscending; - } - - public Criteria addSortAscending(String field) { - if(sortAscending == null) { - sortAscending = new ArrayList<String>(); - } - sortAscending.add(field); - return this; - } - - public Criteria setSortAscending(String[] sortAscending) { - this.sortAscending = Arrays.asList(sortAscending); - return this; - } - - public List<String> getSortDescending() { - return sortDescending; - } - - public Criteria addSortDescending(String field) { - if(sortDescending == null) { - sortDescending = new ArrayList<String>(); - } - sortDescending.add(field); - return this; - } - - public Criteria setSortDescending(String[] sortDescending) { - this.sortDescending = Arrays.asList(sortDescending); - return this; - } - -} Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/ExtensionFactory.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/ExtensionFactory.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/ExtensionFactory.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,38 +0,0 @@ -package org.sharengo.wikitty; - -import java.util.LinkedHashMap; - -import org.sharengo.wikitty.FieldType.TYPE; - -public class ExtensionFactory { - - private String name; - private String version; - private String requiredExtension; - - private LinkedHashMap<String, FieldType> fields; - - private ExtensionFactory(String name, String version) { - this.name = name; - this.version = version; - this.fields = new LinkedHashMap<String, FieldType>(); - } - - public static ExtensionFactory create(String name, String version) { - return new ExtensionFactory(name, version); - } - - public FieldFactory addField(String name, TYPE fieldType) { - return new FieldFactory(this, name, fieldType); - } - - public WikittyExtension extension() { - WikittyExtension ext = new WikittyExtension(name, version, requiredExtension, fields); - return ext; - } - - protected void add(String fieldName, FieldType fieldType) { - fields.put(fieldName, fieldType); - } - -} Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/FacetTopic.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/FacetTopic.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/FacetTopic.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,62 +0,0 @@ -/* *##% - * Copyright (c) 2009 poussin. All rights reserved. - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - *##%*/ - -package org.sharengo.wikitty; - - -import java.io.Serializable; -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; - -/** - * - * @author poussin - * @version $Revision$ - * - * Last update: $Date$ - * by : $Author$ - */ -public class FacetTopic implements Serializable { - - /** to use log facility, just put in your code: log.info(\"...\"); */ - static private Log log = LogFactory.getLog(FacetTopic.class); - - private static final long serialVersionUID = 1L; - - protected String facetName; - protected String topicName; - protected int count; - - public FacetTopic(String facetName, String topicName, int count) { - this.facetName = facetName; - this.topicName = topicName; - this.count = count; - } - - public String getFacetName() { - return facetName; - } - - public String getTopicName() { - return topicName; - } - - public int getCount() { - return count; - } - -} Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/FieldFactory.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/FieldFactory.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/FieldFactory.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,62 +0,0 @@ -package org.sharengo.wikitty; - -import java.util.HashMap; -import java.util.Map; -import org.sharengo.wikitty.FieldType.TYPE; - -public class FieldFactory { - - private ExtensionFactory parentFactory; - private String fieldName; - private TYPE type; - private int minOccur = 0, maxOccur = 1; - private boolean unique = false; - private Map<String, String> tagValues = new HashMap<String, String>(); - - public FieldFactory(ExtensionFactory parentFactory, String fieldName, TYPE type) { - this.parentFactory = parentFactory; - this.fieldName = fieldName; - this.type = type; - } - - public FieldFactory addField(String name, TYPE type) { - append(); - return parentFactory.addField(name, type); - } - - public WikittyExtension extension() { - append(); - return parentFactory.extension(); - } - - private void append() { - FieldType fieldType = new FieldType(type, minOccur, maxOccur, unique, minOccur > 0); - for (Map.Entry<String, String> entry : tagValues.entrySet()) { - String tag = entry.getKey(); - String value = entry.getValue(); - fieldType.addTagValue(tag, value); - } - parentFactory.add(fieldName, fieldType); - } - - public FieldFactory maxOccur(int max) { - maxOccur = max; - return this; - } - - public FieldFactory minOccur(int min) { - minOccur = min; - return this; - } - - public FieldFactory unique() { - unique = true; - return this; - } - - public FieldFactory addTagValue(String tag, String value) { - tagValues.put(tag, value); - return this; - } - -} Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/FieldType.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/FieldType.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/FieldType.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,234 +0,0 @@ -/* *##% - * Copyright (c) 2009 Sharengo, Guillaume Dufrene, Benjamin POUSSIN. - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - *##%*/ - -package org.sharengo.wikitty; - - -import java.io.Serializable; -import java.util.ArrayList; -import java.util.Collection; -import java.util.HashMap; -import java.util.LinkedHashSet; -import java.util.Map; -import java.util.Set; - -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; - -/** - * - * @author poussin - * @version $Revision$ - * - * Last update: $Date$ - * by : $Author$ - */ -public class FieldType implements Serializable { - - static public enum TYPE { - BOOLEAN, DATE, NUMERIC, STRING, WIKITTY; - - /** - * convert string to TYPE, this methode accept not trimed and not well - * cased string (difference with valueOf) - * @param name - * @return TYPE else exception is throw - */ - public static TYPE parse(String name) { - TYPE result = valueOf(name.trim().toUpperCase()); - return result; - } - } - - /** to use log facility, just put in your code: log.info(\"...\"); */ - static private Log log = LogFactory.getLog(FieldType.class); - - private static final long serialVersionUID = 1L; - - public static final int NOLIMIT = Integer.MAX_VALUE; - - TYPE type; - int lowerBound; - int upperBound; - boolean unique = false; - boolean notNull = false; - - /** used to store tag/value used by client side ex: editor=xhtml */ - Map<String, String> tagValues = new HashMap<String, String>(); - - public FieldType() { - } - - public FieldType(TYPE type, int lowerBound, int upperBound) { - this.type = type; - this.lowerBound = lowerBound; - this.upperBound = upperBound; - } - - public FieldType(TYPE type, int lowerBound, int upperBound, boolean unique, boolean notNull) { - this.type = type; - this.lowerBound = lowerBound; - this.upperBound = upperBound; - this.unique = unique; - this.notNull = notNull; - } - - public void addTagValue(String tag, String value) { - tagValues.put(tag, value); - } - - public String getTagValue(String tag) { - String result = tagValues.get(tag); - return result; - } - - public Set<String> getTagNames() { - return tagValues.keySet(); - } - - public Map<String, String> getTagValues() { - return tagValues; - } - - public void setTagValues(Map<String, String> tagValues) { - this.tagValues = tagValues; - } - - /** - * Return true if this field have upperBound > 1 - * @return - */ - public boolean isCollection() { - return upperBound > 1; - } - - /** - * Return string definition for this field - * @param name field name used for definition - * @return - */ - public String toDefinition(String name) { - String result = type + " " + name; - if (lowerBound != 0 || upperBound != 0) { - if (upperBound != NOLIMIT) { - result += "[" + lowerBound + "-" + upperBound + "]"; - } else { - result += "[" + lowerBound + "-*]"; - } - } - if (isUnique()) { - result += " unique"; - } - if (isNotNull()) { - result += " not null"; - } - result += WikittyUtil.tagValuesToString(tagValues); - return result; - } - - /** - * Convert value in argument in right type for this FieldType. Don't support - * collection - * - * @param value value to convert - * @return object in type of this FieldType - */ - protected Object getContainedValidObject( Object value ) { - Object result = null; - switch (type) { - case DATE: - result = WikittyUtil.toDate(value); break; - case NUMERIC: - result = WikittyUtil.toBigDecimal(value); break; - case BOOLEAN: - result = WikittyUtil.toBoolean(value); break; - case STRING: - result = WikittyUtil.toString(value); break; - default: - // if type is not found then type is business type - // and is wikity object - result = WikittyUtil.toWikitty(value); break; - } - return result; - } - - /** - * Return a valid value for this field. - * @param value is casted if possible to an actual correct value. - * @return - */ - public Object getValidValue( Object value ) throws WikittyException { - if (value == null && isNotNull()) { - throw new WikittyException("Value can't be null for this field"); - } - - Object result; - if (value == null) { - result = null; - } else if (isCollection()) { - if ( !(value instanceof Collection) ) { - throw new WikittyException( "A collection is expected for type " - + type.name() + "[" + lowerBound + " - " + upperBound + "]" ); - } - Collection<Object> col; - if (isUnique()) { - col = new LinkedHashSet<Object>(); - } else { - col = new ArrayList<Object>(); - } - - // copy all value in new collections - for ( Object o : (Collection) value ) { - col.add( getContainedValidObject(o) ); - } - result = col; - } else { - result = getContainedValidObject(value); - } - return result; - } - - /** - * test if value in argument is valide for this field type - * @param value to test - * @return true if value is valid - */ - public boolean isValidValue(Object value) { - return getValidValue(value) != null; - } - - public TYPE getType() { - return type; - } - - public int getLowerBound() { - return lowerBound; - } - - public int getUpperBound() { - return upperBound; - } - - public boolean isUnique() { - return unique; - } - - public boolean isNotNull() { - return notNull; - } - -} Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/JobState.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/JobState.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/JobState.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,41 +0,0 @@ -/* *##% - * Copyright (c) 2009 Sharengo, Guillaume Dufrene, Benjamin POUSSIN. - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - *##%*/ - -package org.sharengo.wikitty; - - -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; - -/** - * - * @author poussin - * @version $Revision$ - * - * Last update: $Date$ - * by : $Author$ - */ -public class JobState { - - /** to use log facility, just put in your code: log.info(\"...\"); */ - static private Log log = LogFactory.getLog(JobState.class); - - String status; // or enum - /** if is an export, resourceUri is not null when job is ended */ - String resourceUri; // generated resource URI on that job - -} Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/Package.html =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/Package.html 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/Package.html 2010-05-12 15:08:48 UTC (rev 53) @@ -1,203 +0,0 @@ -<h1>Wikitty API documentation</h1> - -<h2>Extensions version management</h2> - -The extension version number have to be managed by the developer who writes or -modify the extension. - -When we modify an extension in a model, a developer have to remember to update -the version tag/value. - -<h2>Objects deletion management</h2> - -The objects deleted are only marked as deleted, like that it will be possible to -restore a deleted object in future implementations. - -The deleted objects are not indexed anymore (and so do not appear in search -results). - -If we try to get a deleted object by its id, null is returned. - -We cannot save a deleted object until we do a undelete on it. - -<h2>Wikitties attributes</h2> - -It is possible to define several things for a wikitty field : - -<ul> - <li>its type (String)</li> - <li>its name (String)</li> - <li>its cardinality ([1-n])</li> - <li>if it is unique (unique), for the lists it will be reprensted by a Set, for - not-list objects it means that two objects cannot have the same value for - this field (constraint not implemented for now). - </li> - <li>if it has to be not null, there is no mean, in the modeler to indicate it, - and so it is not possible to generate it. - </li> - <li>Tag/values (tag=value). It is possible to create as many tag/values as we - want. You can then get them by FieldType.getTagValue(tagName). This can be - useful to put a tag 'editor' used by UI and that allows to put a specific - editor for a field (e.g. a html editor for a String field) - </li> -</ul> - -<h2>PropertyChangeListener</h2> - -The field modification listeners management is diretly done by the wikitty -object. The name of the field is the concatenation of the extension name and the -field name ([extName].[fieldName]). - -<h2>Search API</h2> - -<h3>General points</h3> - -The search are made by example (a model dto), or from a search 'Criteria' object. - -This criteria contains restrictions that will be turned into searhc request. - -The criteria can be built from the utility class 'Search' that allows to express, -via instructions, all the restrictions. - -The Search operations return a reference to an object of the same type allowing -to continue expressing other criteria. - -This allows to write quickly and easily search expressions with the Search API's -help (and auto-completion will help even more). - -The Search operations names are really short and syntaxically close to bash -conditional expressions... - -<h3>List of criteria operations</h3> -We will find : <ul> - <li> eq : to express equality</li> - <li> neq : to express difference (not equals)</li> - <li> le, lt : respectively for inclusive and exclusive inferiority operations - (less than, less or equals)</li> - <li> ge, gt : respectively for inclusive and exclusive superiority operations - (greater than, greater or equals)</li> - <li> sw : to express an expression beginning (start with)</li> - <li> ew : to express an expression ending (end with)</li> - <li> in : to express a list of possible values</li> -</ul> - -<h3>Disjunction operation, disjunction group</h3> -By default, each restrictions express by the above expressions are added to a -list of conjunctions (logical AND). - -It is possible to express disjunctions (logical OR) using the or operation. - -The restriction following the or is then in disjunction with the one preceding -it. - -If other restrictions are added after that, they are attached to the previous -conjunction. - -To express a group of disjunction, we can call the or operation between each -restriction or call the group operation with the 'OR' type. - -In this last case, you will need to close the groupe by calling the end operation. - -<h3>Associative search</h3> -It is possible to express associative search, i.e. search for which some criteria -are based on objects linked by a reference (link or foreign key notion). - -Then, the associated (fieldName) operation allows to -Il est possible d'exprimer des recherches associatives, c'est à dire des recherches pour lesquelles certains critères portent sur un objet lié par une référence (notion de lien, ou de clé étrangère).<br> -Ainsi, l'opération associated( fieldName ) permet de faire porter les critères suivant cette opération sur les objets lié via ce champ.<br> -Le résultat sera une conjonction (ET) entre les critères exprimés avant l'opération associated sur l'objet 'principal' (il peut ne pas y en avoir), et dont la ou les références associée répondent aux critères exprimés après le associated.<br> -Tout cela est beaucoup plus clair par l'exemple ;-)<br> - -I want to find all paints between 15 and 25 euros in the Hardware section. - -This search can be expressed ina more concrete way using API via : - -"I search all products wich price is between 15 and 25 euros, which name starts -by 'Paint', and which associated section, using the 'section' field, have the -name 'Hardware'". - -It is built using the following operations : - -<pre> - RestrictionDto dto = Search.query() - .bw( "Product.selling_price", "15", "25") - .sw( "Produit.article_name", "Paint") - .associated( "Product.section" ) - .eq( "Section.name", "Hardware" ) - .criteria(); -</pre> - - -<h2>Data migration</h2> - -When the list of wikitty extensions is modified, either: -<ul> - <li>we deleted an extension, the data stays in the wikitty</li> - <li>we added an extension, nothing is done but we can add data for the new - fields</li> - <li>we modified an extension - <li>deleted an extension field : the data stays but are no more - accessible</li> - <li>added a field to the extension : nothing is done but we can add data - for the new field</li> - <li>modified a field type: - <ul> - <li>API knows how to convert it, nothing to do (e.g. int->String)</li> - <li>The type has been deeply modified (e.g. String->List<int<): - you have to implement an extension migration sub-class - (WikittyExtensionMigration) and save it so that it is used when - necessary.</li> - </ul> - </li> -</ul> - -<p>An object is converted when it is loaded in its BusinessEntity, but is is not - automatically save, it is saved only if a store is called on the client side. -</p> - -<p>It is also possible to force the migration searching all the objects with the -modified extension, load them in WikittyDtos and save them.</p> -<pre> -Wikitty w = new Wikitty(); -w.addExtension(myModifiedExtension); -WikittyDto dto = new WikittyDto(w); -PagedResult<WikittyDto> result = proxy.findAllByExample(dto, 0, Proxy.ALL_ELEMENTS); -proxy.store(result.getAll()); -</pre> - -<h2>Import Wikitties</h2> - -When importing XML file, if an object has a version nmber, then if in the -database there is no object or if the object has a version number less or equal -than the imported version number, the xml file data overwrite the database data. - -If the database version number is greater than the imported version number, the -imported object is rejected and an exception is thrown. - -If the imported object had no version number, in all cases, it overwrite the -database data and the object version number is incremented if it was present in -database. - -Modifications to do on implementation : -<ul> - <li>During xml file reading and loading into wikitty object, if there is no - version number in xml flux, the version number is null instead of - defaultversion.</li> - <li>Take into account that during wikitty save, the version number can be - null, do the appropriate treatment</li> -</ul> - -If an object in database was deleted and we try to import it, we throw an -exception. - -<h2>TODO</h2> -<ul> -<li>while generating BusinessEntity, if 2 extensions have the same method, - suffix the next ones with xxxxxxForExtensionName</li> -<li>Think about object search problem if its extensions have been modified. - If you do a search by example, we add the extension list in the request, the - new BusinessEntity has more extensions, we do not find the old objects. If - we do a search by criteria/example, the criterie field cannot exist in the - index and so the object is not returned in results even if we put '*' as - field value.</li> -</ul> \ No newline at end of file Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/PagedResult.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/PagedResult.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/PagedResult.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,189 +0,0 @@ -/* *##% - * Copyright (c) 2009 Sharengo, Guillaume Dufrene, Benjamin POUSSIN. - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - *##%*/ - -package org.sharengo.wikitty; - - -import java.io.Serializable; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.List; -import java.util.Map; - -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; - -/** - * - * @author poussin - * @version $Revision$ - * - * Last update: $Date$ - * by : $Author$ - */ -public class PagedResult<T> implements Serializable { - - /** to use log facility, just put in your code: log.info(\"...\"); */ - static private Log log = LogFactory.getLog(PagedResult.class); - - private static final long serialVersionUID = 1L; - - /** indice element in global search result */ - protected int firstIndice; - /** total number of result if we call the query for all possible result */ - protected int numFound; - /** query really executed */ - protected String queryString; - /** list of result in the wanted interval */ - protected List<T> results; - /** facet asked or null if no facet */ - protected Map<String, List<FacetTopic>> facets; - - public PagedResult(int FirstIndice, int numFound, String queryString, - Map<String, List<FacetTopic>> facets, List<T> results) { - this.firstIndice = FirstIndice; - this.numFound = numFound; - this.queryString = queryString; - this.facets = facets; - this.results = Collections.unmodifiableList(results); - } - - /** - * Converte all result to the wanted type and return new PagedResult with - * this new result list. If some result don't have the right extension (clazz) - * this extension is automatically added if autoconvert is true. Else - * an exception is throwed when result without extension is found. - * - * When you used autoconvert = false, you have a potentialy probleme when - * you have modified a BusinessEntity to have new extension and all your - * wikitty object are not uptodate in database. - * - * @param clazz - * @param autoconvert - * @return - */ - public <E extends BusinessEntityWikitty> PagedResult<E> cast( - WikittyService wikittyService, Class<E> clazz, boolean autoconvert) { - List<E> castedResult = new ArrayList<E>(results.size()); - E sample = WikittyUtil.newInstance(clazz); - Collection<WikittyExtension> wantedExtension = sample.getStaticExtensions(); - for (T t : results) { - if (t == null) { - castedResult.add(null); - } else { - Wikitty w = null; - if (t instanceof Wikitty) { - w = (Wikitty)t; - } else if (t instanceof BusinessEntityWikitty) { - w = ((BusinessEntityWikitty) t).getWikitty(); - } else { - throw new WikittyException(String.format( - "Illegal object result class '%s' can't convert it to wikitty", - t.getClass().getName(), clazz.getName())); - } - - Collection<WikittyExtension> wikittyExtension = w.getExtensions(); - if (autoconvert || wikittyExtension.containsAll(wantedExtension)) { - E e = WikittyUtil.newInstance(wikittyService, clazz, (Wikitty) t); - castedResult.add(e); - } else { - throw new WikittyException(String.format( - "Illegal object result class '%s' can't convert it to '%s'" + - "there is no same extension %s != %s", - t.getClass().getName(), clazz.getName(), - wikittyExtension, wantedExtension)); - } - } - } - PagedResult<E> result = new PagedResult<E>( - firstIndice, numFound, queryString, facets, castedResult); - return result; - } - - public int getFirstIndice() { - return firstIndice; - } - - public int getNumFound() { - return numFound; - } - - public String getQueryString() { - return queryString; - } - - /** - * Return name of all facet used in query - * @return - */ - public Collection<String> getFacetNames() { - Collection<String> result = facets.keySet(); - return result; - } - - /** - * Return all topic for the specified facet - * @param facetName name of the wanted facet - * @return - */ - public List<FacetTopic> getTopic(String facetName) { - List<FacetTopic> result = facets.get(facetName); - return result; - } - - /** - * Get map represent facets - * @return - */ - public Map<String, List<FacetTopic>> getFacets() { - return facets; - } - - /** - * Return the firstIndice element in result or throw an exception if no element - * available - * @return - */ - public T getFirst() { - T result = get(0); - return result; - } - - public T get(int i) { - T result = results.get(i); - return result; - } - - /** - * Return unmodifiable list of all result - * @return - */ - public List<T> getAll() { - return results; - } - - /** - * Return the number of result in this object - * @return - */ - public int size() { - int result = results.size(); - return result; - } - -} Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/Tree.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/Tree.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/Tree.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,30 +0,0 @@ -package org.sharengo.wikitty; - -import java.util.ArrayList; -import java.util.List; -import java.util.Set; - -public class Tree { - - TreeNode node; - List<Tree> children; - - public void setNode(TreeNode node) { - this.node = node; - } - - public void addChild(Tree tree) { - getChildren().add( tree ); - } - - public List<Tree> getChildren() { - if ( children == null ) { - children = new ArrayList<Tree>(); - } - return children; - } - - public String getName() { - return node.getName(); - } -} Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/UpdateResponse.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/UpdateResponse.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/UpdateResponse.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,75 +0,0 @@ -package org.sharengo.wikitty; - -import java.util.Date; -import java.util.HashMap; -import java.util.Map; - -public class UpdateResponse { - - protected Map<String, String> idVersionMap = new HashMap<String, String>(); - protected Map<String, Date> idDeletionDateMap = new HashMap<String, Date>(); - - public UpdateResponse() { - super(); - idVersionMap = new HashMap<String, String>(); - } - - /** - * Merge all update passed in argument in local update list - * @param update - */ - public void add(UpdateResponse update) { - idVersionMap.putAll(update.idVersionMap); - idDeletionDateMap.putAll(update.idDeletionDateMap); - } - - public void addVersionUpdate( String id, String version ) { - idVersionMap.put(id, version); - } - - public void addDeletionDateUpdate(String id, Date date) { - idDeletionDateMap.put(id, date); - } - - public void update(BusinessEntity e) { - if (e instanceof BusinessEntityWikitty) { - update((BusinessEntityWikitty) e); - } else if (e instanceof BusinessEntityBean) { - update((BusinessEntityBean) e); - } - } - - public void update(BusinessEntityBean e) { - // update version - String id = e.getWikittyId(); - String version = idVersionMap.get(id); - if (version != null) { - e.setWikittyVersion(version); - } - } - - public void update(BusinessEntityWikitty e) { - update(e.getWikitty()); - } - - /** - * Update data directly in object passed in argument. - * Actualy only version and deletion date are updated. - * And internaly wikitty object is marked clean (not dirty) - * @param e - */ - public void update(Wikitty e) { - // update version - String id = e.getId(); - String version = idVersionMap.get(id); - if (version != null) { - e.setVersion(version); - } - Date date = idDeletionDateMap.get(id); - if (date != null) { - e.setDeleteDate(date); - } - e.clearDirty(); - } - -} Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/Wikitty.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/Wikitty.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/Wikitty.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,636 +0,0 @@ -/* *##% - * Copyright (c) 2009 Sharengo, Guillaume Dufrene, Benjamin POUSSIN. - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - *##%*/ - -package org.sharengo.wikitty; - -import java.beans.PropertyChangeListener; -import java.beans.PropertyChangeSupport; -import java.io.Serializable; -import java.math.BigDecimal; -import java.util.AbstractList; -import java.util.AbstractSet; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Date; -import java.util.HashMap; -import java.util.HashSet; -import java.util.Iterator; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; - -/** - * - * @author poussin - * @version $Revision$ - * - * Last update: $Date$ - * by : $Author$ - */ -public class Wikitty implements Serializable { - - private static final long serialVersionUID = 1L; - - /** - * technical id for this wikitty object. id must be never null - */ - protected String id; - /** current version of this wikitty object */ - protected String version = WikittyUtil.DEFAULT_VERSION; - /** if not null, date of deletion, if date this object is marked as deleted */ - protected Date deleteDate = null; - - /** used to add property change support to wikitty object */ - protected transient PropertyChangeSupport propertyChange = new PropertyChangeSupport(this); - - /** - * key: field name prefixed by extension name (dot separator) - * value: value of field - */ - protected HashMap<String, Object> fieldValue = new HashMap<String, Object>(); - /** - * all field name currently modified (field name = extension . fieldname) - */ - protected Set<String> fieldDirty = new HashSet<String>(); - /** - * Map is LinkedHashMap to maintains order like user want - * key: extension name - * value: extension definition - */ - protected Map<String, WikittyExtension> extensions = - new LinkedHashMap<String, WikittyExtension>(); - - - public Wikitty() { - this(null); - } - - public Wikitty(String id){ - if(id == null) { - this.id = WikittyUtil.genUID(); - } else { - this.id = id; - } - } - - public synchronized void addPropertyChangeListener( - PropertyChangeListener listener) { - propertyChange.addPropertyChangeListener(listener); - } - - - public synchronized void removePropertyChangeListener( - PropertyChangeListener listener) { - propertyChange.removePropertyChangeListener(listener); - } - - - public synchronized void addPropertyChangeListener(String propertyName, - PropertyChangeListener listener) { - propertyChange.addPropertyChangeListener(propertyName, listener); - } - - - public synchronized void removePropertyChangeListener(String propertyName, - PropertyChangeListener listener) { - propertyChange.removePropertyChangeListener(propertyName, listener); - } - - public String getId() { - return id; - } - - public boolean isDeleted() { - boolean result = deleteDate != null; - return result; - } - - public Date getDeleteDate() { - return deleteDate; - } - - /** - * Server only used - * @param delete - */ - public void setDeleteDate(Date delete) { - this.deleteDate = delete; - } - - /** - * mark field as dirty - * @param ext - * @param fieldName - */ - protected void setFieldDirty(String ext, String fieldName, - Object oldValue, Object newValue) { - String key = ext + "." + fieldName; - fieldDirty.add(key); - version = WikittyUtil.incrementMinorRevision(version); - propertyChange.firePropertyChange(key, oldValue, newValue); - } - - public void addExtension(WikittyExtension ext) { - String required = ext.getRequires(); - if (required != null && !required.isEmpty() && - !extensions.containsKey(required)) { - throw new WikittyException(String.format( - "You try to add extension '%s' that" + - " required not available extension '%s' in this wikitty", - ext.getName(), required)); - } - extensions.put(ext.name, ext); - } - - public void addExtension(List<WikittyExtension> exts) { - for (WikittyExtension ext : exts) { - extensions.put(ext.name, ext); - } - } - - public boolean hasExtension(String extName) { - return extensions.containsKey(extName); - } - - public boolean hasField(String extName, String fieldName) { - boolean result = false; - WikittyExtension ext = extensions.get(extName); - if (ext != null) { - result = ext.getFieldType(fieldName) != null; - } - return result; - } - - public WikittyExtension getExtension(String ext) { - WikittyExtension result = extensions.get(ext); - return result; - } - - public Collection<String> getExtensionNames() { - Collection<String> result = extensions.keySet(); - return result; - } - - public Collection<WikittyExtension> getExtensions() { - Collection<WikittyExtension> result = extensions.values(); - return result; - } - - public Collection<WikittyExtension> getExtensionDependencies(String ext, boolean recursively) { - Collection<WikittyExtension> result = new HashSet<WikittyExtension>(); - Collection<WikittyExtension> all = extensions.values(); - for (WikittyExtension dependency : all) { - String requires = dependency.getRequires(); - if(requires != null && !requires.isEmpty() && requires.equals(ext)) { - result.add(dependency); - if(recursively) { - String dependencyName = dependency.getName(); - Collection<WikittyExtension> dependencies = getExtensionDependencies(dependencyName, recursively); - result.addAll(dependencies); - } - } - } - return result; - } - - /** - * return field type for the given fieldName. - * @param fieldName fully qualified fieldName extension.fieldname - * @return field type - */ - public FieldType getFieldType(String fqfieldName) { - try { - String[] field = fqfieldName.split("\\."); - WikittyExtension ext = getExtension(field[0]); - if (ext == null) { - throw new WikittyException(String.format( - "extension '%s' doesn't exists", field[0])); - } else { - String fieldName = field[1]; - int crochet = fieldName.indexOf("["); - if (crochet != -1) { - fieldName = fieldName.substring(0, crochet); - } - FieldType result = ext.getFieldType(fieldName); - if (result == null) { - throw new WikittyException(String.format( - "field '%s' doesn't exists on extension '%s'", fieldName, field[0])); - - } - return result; - } - } catch (Exception eee) { - throw new WikittyException( - String.format("Field %s is not a fully qualified field name", fqfieldName), - eee - ); - } - } - - public void setField(String ext, String fieldName, Object value) { - if (! hasField(ext, fieldName)) { - String def = ""; - for ( WikittyExtension extension : extensions.values() ) { - def += extension.toDefinition() + "\n"; - } - throw new WikittyException(String.format( - "field '%s' is not valid, extensions definition : %s", ext + "." + fieldName, def)); - } - String key = ext + "." + fieldName; - - // take old value if needed - Object oldValue = null; - if (propertyChange.hasListeners(key)) { - oldValue = fieldValue.get(key); - } - - // put new value - FieldType fieldType = getExtension(ext).getFieldType(fieldName); - Object validValue = fieldType.getValidValue(value); - fieldValue.put(key, validValue); - - // mark field dirty and call listener - setFieldDirty(ext, fieldName, oldValue, validValue); - } - - public Object getFieldAsObject(String ext, String fieldName) { - if (!hasField(ext, fieldName)) { - throw new WikittyException(String.format( - "field '%s' is not a valid field", - ext + "." + fieldName)); - } - String key = ext + "." + fieldName; - Object result = fieldValue.get(key); - return result; - } - - public boolean getFieldAsBoolean(String ext, String fieldName) { - Object value = getFieldAsObject(ext, fieldName); - try { - boolean result = WikittyUtil.toBoolean(value); - return result; - } catch (WikittyException eee) { - throw new WikittyException(String.format( - "field '%s' is not a valid boolean", - ext + "." + fieldName), eee); - } - } - - public BigDecimal getFieldAsBigDecimal(String ext, String fieldName) { - Object value = getFieldAsObject(ext, fieldName); - try { - BigDecimal result = WikittyUtil.toBigDecimal(value); - return result; - } catch (WikittyException eee) { - throw new WikittyException(String.format( - "field '%s' is not a valid numeric", - ext + "." + fieldName), eee); - } - } - - public int getFieldAsInt(String ext, String fieldName) { - try { - BigDecimal value = getFieldAsBigDecimal(ext, fieldName); - int result = value.intValue(); - return result; - } catch (WikittyException eee) { - throw new WikittyException(String.format( - "field '%s' is not a valid int", - ext + "." + fieldName), eee); - } - } - - public long getFieldAsLong(String ext, String fieldName) { - try { - BigDecimal value = getFieldAsBigDecimal(ext, fieldName); - long result = value.longValue(); - return result; - } catch (WikittyException eee) { - throw new WikittyException(String.format( - "field '%s' is not a valid int", - ext + "." + fieldName), eee); - } - } - - public float getFieldAsFloat(String ext, String fieldName) { - try { - BigDecimal value = getFieldAsBigDecimal(ext, fieldName); - float result = value.floatValue(); - return result; - } catch (WikittyException eee) { - throw new WikittyException(String.format( - "field '%s' is not a valid float", - ext + "." + fieldName), eee); - } - } - - public double getFieldAsDouble(String ext, String fieldName) { - try { - BigDecimal value = getFieldAsBigDecimal(ext, fieldName); - double result = value.doubleValue(); - return result; - } catch (WikittyException eee) { - throw new WikittyException(String.format( - "field '%s' is not a valid float", - ext + "." + fieldName), eee); - } - } - - public String getFieldAsString(String ext, String fieldName) { - Object value = getFieldAsObject(ext, fieldName); - try { - String result = WikittyUtil.toString(value); - return result; - } catch (WikittyException eee) { - throw new WikittyException(String.format( - "field '%s' is not a valid String", - ext + "." + fieldName), eee); - } - } - - public Date getFieldAsDate(String ext, String fieldName) { - Object value = getFieldAsObject(ext, fieldName); - try { - Date result = WikittyUtil.toDate(value); - return result; - } catch (WikittyException eee) { - throw new WikittyException(String.format( - "field '%s' is not a valid Date", - ext + "." + fieldName), eee); - } - } - - /** - * return wikitty id and not wikitty objet because this method can be call - * on server or client side and it's better to keep conversion between id - * and objet to the caller - * @param ext extension name where this field must to be - * @param fieldName the field name - * @return id of wikitty object or null - * @throws org.sharengo.wikitty.WikittyException - */ - public String getFieldAsWikitty(String ext, String fieldName) { - Object value = getFieldAsObject(ext, fieldName); - String result = WikittyUtil.toWikitty(value); - return result; - } - - /** - * If object is a set, it is automatically transform to list. - * @param <E> - * @param clazz - * @return unmodifiable list - */ - public <E> List<E> getFieldAsList(String ext, String fieldName, final Class<E> clazz) { - try { - final Collection<E> collection = (Collection<E>) getFieldAsObject(ext, fieldName); - if (collection != null) { - // return unmodiable collection that check type of element - return new AbstractList<E>() { - List<E> contained = new ArrayList<E>(collection); - @Override public E get(int index) { - return WikittyUtil.cast( contained.get(index), clazz ); - } - @Override public int size() { - return contained.size(); - } - }; - } - return null; - } catch (Exception eee) { - throw new WikittyException(String.format( - "Can't add value to field '%s'", - ext + "." + fieldName), eee); - } - } - - /** - * - * @param <E> - * @param clazz - * @return unmodifiable list - */ - public <E> Set<E> getFieldAsSet(String ext, String fieldName, final Class<E> clazz) { - try { - final Set<E> result = (Set<E>) getFieldAsObject(ext, fieldName); - if (result != null) { - // return unmodifable Set - return new AbstractSet<E>() { - Set<E> contained = result; - @Override public int size() { - return contained.size(); - } - @Override - public Iterator<E> iterator() { - return new Iterator<E>() { - Iterator containedIterator = contained.iterator(); - public boolean hasNext() { - return containedIterator.hasNext(); - } - - public E next() { - Object o = containedIterator.next(); - return WikittyUtil.cast(o, clazz); - } - - public void remove() { - throw new UnsupportedOperationException("Not supported operation"); - } - }; - - } - }; - } - return result; - } catch (Exception eee) { - throw new WikittyException(String.format( - "Can't add value to field '%s'", - ext + "." + fieldName), eee); - } - } - - public void addToField(String ext, String fieldName, Object value) { - try { - FieldType fieldType = getExtension(ext).getFieldType(fieldName); - Collection col = (Collection) getFieldAsObject(ext, fieldName); - if (col == null) { - if (fieldType.isUnique()) { - col = new HashSet(); - } else { - col = new ArrayList(); - } - col.add(value); - setField(ext, fieldName, col); - // no call dirty, because already done in setField - } else { - // check upper bound only if col exists, - // because ask upper bound == 0 is ridiculous - - if (fieldType.isUnique()) { - if (!col.contains(value)) { - // only add if not already in collection (unique) - if (col.size() + 1 > fieldType.getUpperBound()) { - // if upper bound reached, throw an exception - throw new WikittyException(String.format( - "Can't add value for field '%s', upper bound is reached", - ext + "." + fieldName)); - } - col.add(value); - setFieldDirty(ext, fieldName, null, col); - } - } else { - if (col.size() + 1 > fieldType.getUpperBound()) { - throw new WikittyException(String.format( - "Can't add value for field '%s', upper bound is reached", - ext + "." + fieldName)); - } - col.add(value); - setFieldDirty(ext, fieldName, null, col); - } - } - } catch (Exception eee) { - throw new WikittyException(String.format( - "Can't add value to field '%s'", - ext + "." + fieldName), eee); - } - } - - public void removeFromField(String ext, String fieldName, Object value) { - try { - Collection col = (Collection) getFieldAsObject(ext, fieldName); - if (col != null) { - FieldType type = getExtension(ext).getFieldType(fieldName); - if (col.contains(value)) { - if (col.size() - 1 < type.getLowerBound()) { - throw new WikittyException(String.format( - "Can't remove value for field '%s', lower bound is reached", - ext + "." + fieldName)); - } else { - if (col.remove(value)) { - // field is dirty only if remove is done - setFieldDirty(ext, fieldName, null, col); - } - } - } - } - } catch (Exception eee) { - throw new WikittyException(String.format( - "Can't remove value for field '%s'", - ext + "." + fieldName), eee); - } - } - - public void clearField(String ext, String fieldName) { - FieldType type = getExtension(ext).getFieldType(fieldName); - if (type.getLowerBound() > 0) { - throw new WikittyException(String.format( - "Can't clear values for field '%s', lower bound is > 0", - ext + "." + fieldName)); - } - try { - Collection col = (Collection) getFieldAsObject(ext, fieldName); - if (col != null) { - col.clear(); - setFieldDirty(ext, fieldName, null, col); - } - } catch (Exception eee) { - throw new WikittyException(String.format( - "Can't clear value for field '%s'", - ext + "." + fieldName), eee); - } - } - - @Override - public boolean equals(Object obj) { - boolean result = false; - if (obj instanceof Wikitty) { - Wikitty other = (Wikitty) obj; - result = id.equals(other.id); - } - return result; - } - - @Override - public int hashCode() { - if (id == null) { - return super.hashCode(); - } else { - return id.hashCode(); - } - } - - public Set<String> fieldNames() { - return fieldValue.keySet(); - } - - public Object getFqField(String fqFieldName) { - return fieldValue.get(fqFieldName); - } - - public String getVersion() { - return version; - } - - /** - * Server only used - * @param version - */ - public void setVersion(String version) { - this.version = version; - } - - /** - * Server only used - * @param version - */ - public void clearDirty() { - fieldDirty.clear(); - } - - /** - * Server only used - * @param fieldName fqn (ex: extensionName.fieldName) - * @param value new value - */ - public void setFqField(String fieldName, Object value) { - FieldType fieldType = getFieldType(fieldName); - Object validValue = fieldType.getValidValue(value); - fieldValue.put(fieldName, validValue); - } - - public boolean isEmpty() { - return fieldValue.isEmpty(); - } - - @Override - public String toString() { - boolean cr = true; - String str = "[" + getId() + ":" + getVersion() + "] {"; - for ( String extName : getExtensionNames() ) { - WikittyExtension ext = getExtension(extName); - str += (cr ? "\n" : "") + "\t<" + extName + ">\n"; - cr = false; - for ( String fieldName : ext.getFieldNames() ) { - str += "\t\t" + fieldName + " = " + getFieldAsString(extName, fieldName) + "\n"; - } - } - str += "}"; - return str; - } - -} Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyDAO.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyDAO.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyDAO.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,189 +0,0 @@ -package org.sharengo.wikitty; - -import java.lang.reflect.ParameterizedType; -import java.util.Collection; -import java.util.List; -import java.util.Map; -import java.util.Set; - -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; - -public class WikittyDAO<E extends BusinessEntityWikitty> { - - protected static Log log = LogFactory.getLog( WikittyDAO.class ); - - private WikittyProxy proxy; - private Class<E> clazz; - - public WikittyDAO() { - clazz = getActualClassType(); - } - - private Class<E> getActualClassType() { - ParameterizedType type = (ParameterizedType)this.getClass().getGenericSuperclass(); - Class<E> clazz = (Class<E>)type.getActualTypeArguments()[0]; - return clazz; - } - - public void addLabel(String wikittyId, String label) { - proxy.addLabel(wikittyId, label); - } - - public String asyncExportAllByCriteria(Criteria criteria) { - return proxy.asyncExportAllByCriteria(criteria); - } - - public String asyncExportAllByExample(E e) { - return proxy.asyncExportAllByExample(e); - } - - public String asyncImportFromUri(String uri) { - return proxy.asyncImportFromUri(uri); - } - - public void cancelJob(String jobId) { - proxy.cancelJob(jobId); - } - - public void delete(Collection<String> ids) { - proxy.delete(ids); - } - - public void delete(String id) { - proxy.delete(id); - } - - public boolean equals(Object obj) { - return proxy.equals(obj); - } - - public Set<String> findAllAppliedLabels(String wikittyId) { - return proxy.findAllAppliedLabels(wikittyId); - } - - public PagedResult<E> findAll() { - return proxy.findAllByCriteria(clazz, null); - } - - public PagedResult<E> findAllByCriteria(Criteria criteria) { - return proxy.findAllByCriteria(clazz, criteria); - } - - public PagedResult<E> findAllByExample(E e, int firstIndex, int endIndex, String... fieldFacet) { - return proxy.findAllByExample(e, firstIndex, endIndex, fieldFacet); - } - - public PagedResult<Wikitty> findAllByLabel(String label, int firstIndex, int endIndex) { - return proxy.findAllByLabel(label, firstIndex, endIndex); - } - - public E findByCriteria(Criteria criteria) { - return proxy.findByCriteria(clazz, criteria); - } - - public E findByExample(E e) { - return proxy.findByExample(e); - } - - public Wikitty findByLabel(String label) { - return proxy.findByLabel(label); - } - - public void freeJobResource(String jobId) { - proxy.freeJobResource(jobId); - } - - public WikittyService getWikittyService() { - return proxy.getWikittyService(); - } - - public int hashCode() { - return proxy.hashCode(); - } - - public JobState infoJob(String jobId) { - return proxy.infoJob(jobId); - } - - public List<E> restore(List<String> id) { - return proxy.restore(clazz, id, true); - } - - public E restore(String id) { - return proxy.restore(clazz, id, true); - } - - public <E extends BusinessEntity> E restore(String id,Class<E> clazz ) { - return proxy.restore(clazz, id); - } - - public Tree restoreTree(String wikittyId) { - return proxy.restoreTree(wikittyId); - } - - public Map.Entry<E, Integer> restoreNode(String wikittyId) { - return restoreNode(wikittyId, null); - } - - public Map.Entry<E, Integer> restoreNode(String wikittyId, Criteria filter) { - Class<E> clazz = getActualClassType(); - return proxy.restoreNode(clazz, wikittyId, filter, true); - } - - public Map<E, Integer> restoreChildren(String wikittyId) { - return restoreChildren(wikittyId, null); - } - - public Map<E, Integer> restoreChildren(String wikittyId, Criteria filter) { - Class<E> clazz = getActualClassType(); - return proxy.restoreChildren(clazz, wikittyId, filter, true); - } - - public Wikitty restoreVersion(String wikittyId, String version) { - return proxy.restoreVersion(wikittyId, version); - } - - public boolean hasType(String wikittyId) { - Class<E> clazz = getActualClassType(); - return proxy.hasType(clazz, wikittyId); - } - - public void setWikittyService(WikittyService wikittyService) { - proxy.setWikittyService(wikittyService); - } - - public E store(E e) { - return proxy.store(e); - } - - public List<E> store(List<E> objets) { - return proxy.store(objets); - } - - public String syncExportAllByCriteria(Criteria criteria) { - return proxy.syncExportAllByCriteria(criteria); - } - - public String syncExportAllByExample(E e) { - return proxy.syncExportAllByExample(e); - } - - public void syncImportFromUri(String uri) { - proxy.syncImportFromUri(uri); - } - - public void syncImportFromXml(String xml) { - proxy.syncImportFromXml(xml); - } - - public String toString() { - return proxy.toString(); - } - - public void setProxy(WikittyProxy proxy) { - this.proxy = proxy; - } - - -} Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyException.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyException.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyException.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,44 +0,0 @@ -/* *##% - * Copyright (c) 2009 Sharengo, Guillaume Dufrene, Benjamin POUSSIN. - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - *##%*/ - -package org.sharengo.wikitty; - -/** - * - * @author poussin - * @version $Revision$ - * - * Last update: $Date$ - * by : $Author$ - */ -public class WikittyException extends RuntimeException { - - private static final long serialVersionUID = 1L; - - public WikittyException(String message) { - super(message); - } - - public WikittyException(Exception eee) { - super(eee); - } - - public WikittyException(String message, Exception eee) { - super(message, eee); - } - -} Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyExtension.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyExtension.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyExtension.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,242 +0,0 @@ -/* *##% - * Copyright (c) 2009 Sharengo, Guillaume Dufrene, Benjamin POUSSIN. - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - *##%*/ - -package org.sharengo.wikitty; - -import java.io.Serializable; -import java.util.Collection; -import java.util.HashMap; -import java.util.LinkedHashMap; -import java.util.Map; -import java.util.Set; - -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; - -/** - * - * @author poussin - * @version $Revision$ - * - * Last update: $Date$ - * by : $Author$ - */ -public class WikittyExtension implements Serializable { - - /** to use log facility, just put in your code: log.info(\"...\"); */ - static private Log log = LogFactory.getLog(WikittyExtension.class); - - private static final long serialVersionUID = 1L; - - /** - * Name of this extension. - */ - protected String name; - - /** - * Name of other extension needed to put this extension to object. - * - * Warning : Multiples extensions are not supported yet. - * - * FIXME EC-20100420 multiples extensions need to work - */ - protected String requires; - - /** - * use to know version objet, when you change field number, type or other - * you must change version number. - */ - protected String version = WikittyUtil.DEFAULT_VERSION; - - /** used to store tag/value used by client side ex: updatedDate=101212 */ - Map<String, String> tagValues = new HashMap<String, String>(); - - /** - * fields use ordered map, to keep order insertion of field - * key: field name - * value: field type - */ - protected LinkedHashMap<String, FieldType> fields = new LinkedHashMap<String, FieldType>(); - - protected WikittyExtension() { - } - - public WikittyExtension(String name) { - if (name == null) { - throw new IllegalArgumentException("Name must not be null"); - } - this.name = name; - } - - public WikittyExtension(String name, String version, - String requires, LinkedHashMap<String, FieldType> fields) { - if (name == null) { - throw new IllegalArgumentException("Name must not be null"); - } - if (version == null) { - throw new IllegalArgumentException("Version must not be null"); - } - this.name = name; - this.version = WikittyUtil.normalizeVersion(version); - this.requires = requires; - if (fields != null) { - this.fields = fields; - } - } - - public WikittyExtension cloneForUpgrade() { - String nextRevision = WikittyUtil.incrementMajorRevision(getVersion()); - - LinkedHashMap<String, FieldType> nextFields = null; - if (fields != null) { - nextFields = new LinkedHashMap<String, FieldType>(); - for (Map.Entry<String, FieldType> entry : fields.entrySet()) { - FieldType type = entry.getValue(); - FieldType nextType = new FieldType(type.getType(), type.getLowerBound(), type.getUpperBound(), type.isUnique(), type.isNotNull()); - Set<String> tagNames = type.getTagNames(); - if (tagNames != null) { - for (String tagName : tagNames) { - String tagValue = type.getTagValue(tagName); - nextType.addTagValue(tagName, tagValue); - } - } - nextFields.put(entry.getKey(), nextType); - } - } - - WikittyExtension result = new WikittyExtension(name, nextRevision, requires, nextFields); - return result; - } - - /** - * compute id for extension name and version in argument - * @param name - * @param version - * @return - */ - static public String computeId(String name, String version) { - String result = name + "[" + version + "]"; - return result; - } - - static public String computeName(String id) { - int i = id.lastIndexOf("["); - String result = id; - if (i != -1) { - result = id.substring(0, i); - } - return result; - } - - static public String computeVersion(String id) { - int b = id.lastIndexOf("["); - int e = id.lastIndexOf("]"); - String result = null; - if (b != -1 && e != -1) { - result = id.substring(b+1, e); - } - result = WikittyUtil.normalizeVersion(result); - return result; - } - - public String getId() { - String result = computeId(getName(), getVersion()); - return result; - } - - public String getName() { - return name; - } - - public String getVersion() { - return version; - } - - public String getRequires() { - return requires; - } - - public FieldType getFieldType(String fieldName) { - return fields.get(fieldName); - } - - public Collection<String> getFieldNames() { - Collection<String> result = fields.keySet(); - return result; - } - - public void addField(String fieldName, FieldType type) { - fields.put(fieldName, type); - } - - public void removeField(String fieldName) { - fields.remove(fieldName); - } - - @Override - public int hashCode() { - return getId().hashCode(); - } - - public void addTagValue(String tag, String value) { - tagValues.put(tag, value); - } - - public String getTagValue(String tag) { - String result = tagValues.get(tag); - return result; - } - - public Set<String> getTagNames() { - return tagValues.keySet(); - } - - public Map<String, String> getTagValues() { - return tagValues; - } - - public void setTagValues(Map<String, String> tagValues) { - this.tagValues = tagValues; - } - - @Override - public boolean equals(Object obj) { - boolean result = false; - if (obj instanceof WikittyExtension) { - WikittyExtension other = (WikittyExtension)obj; - result = this.getId().equals(other.getId()); - } - return result; - } - - @Override - public String toString() { - return getId(); - } - - public String toDefinition() { - String result = "Extension " + getId(); - result += WikittyUtil.tagValuesToString(tagValues); - result += " {\n"; - for (String fieldName : fields.keySet()) { - result += fields.get(fieldName).toDefinition(fieldName) + "\n"; - } - result += "}"; - return result; - } - -} Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyExtensionMigration.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyExtensionMigration.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyExtensionMigration.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,59 +0,0 @@ -/* *##% - * Copyright (c) 2009 poussin. All rights reserved. - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - *##%*/ - -package org.sharengo.wikitty; - - -import java.util.HashMap; -import java.util.Map; - -/** - * Interface used to migrate Wikitty data from one WikittyExtension version - * to another version - * - * @author poussin - * @version $Revision$ - * - * Last update: $Date$ - * by : $Author$ - */ -public interface WikittyExtensionMigration { - - // TODO poussin 20090902 permit configuration of migrationRegistry by spring - /** - * use to put migration class for extension. - * key: extensionName, value: migration class - */ - static public Map<String, WikittyExtensionMigration> migrationRegistry = - new HashMap<String, WikittyExtensionMigration>(); - - /** - * Migrate wikitty data from oldExt version to newExt. - * - * @param service Wikitty service that do migration - * @param transaction current transaction to use - * @param wikitty Wikitty object that contains data in old version - * extension format - * @param oldExt old extension definition - * @param newExt new extension definition - * @return same wikitty as argument if nothing to do, or new wikitty - * if some modification is done - */ - public Wikitty migrate(AbstractWikittyService service, WikittyTransaction transaction, - Wikitty wikitty, WikittyExtension oldExt, WikittyExtension newExt); - -} Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyExtensionMigrationRename.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyExtensionMigrationRename.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyExtensionMigrationRename.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,123 +0,0 @@ -/* *##% - * Copyright (c) 2009 ruchaud. All rights reserved. - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - *##%*/ - -package org.sharengo.wikitty; - -import java.util.Collection; -import java.util.Set; - -import org.apache.commons.lang.StringUtils; -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; - -/** - * Basic extension migration use to manage rename field name. Order to detect a - * rename, not creation a new field, you should use tag value "renameFrom" with - * name of use in before extension. - * - * Since 1.5, this class also take care about extension order. - * - * @author ruchaud - */ -public class WikittyExtensionMigrationRename implements WikittyExtensionMigration { - - static private Log log = LogFactory.getLog(WikittyExtensionMigrationRename.class); - - public static String TAG_RENAME = "renameFrom"; - - /** - * Recursively add extension with requires ones (orderer). - * - * @param service service - * @param transaction current transaction to use - * @param wikitty wikitty to add extension to - * @param newExt extension to add - */ - protected void addExtension(AbstractWikittyService service, WikittyTransaction transaction, Wikitty wikitty, WikittyExtension newExt) { - - // manage requires before current - String requires = newExt.getRequires(); - if (StringUtils.isNotEmpty(requires)) { - for (String require : requires.split(",")) { - WikittyExtension newRequireExt = service.restoreExtensionLastVersion(transaction, require); - addExtension(service, transaction, wikitty, newRequireExt); - } - } - - // add current extension - wikitty.addExtension(newExt); - } - - @Override - public Wikitty migrate(AbstractWikittyService service, WikittyTransaction transaction, Wikitty wikitty, WikittyExtension oldExt, WikittyExtension newExt) { - - String wikittyId = wikitty.getId(); - String wikittyVersion = wikitty.getVersion(); - - Wikitty result = new Wikitty(wikittyId); - result.setVersion(wikittyVersion); - - // Add all extension and replace old by the new - for (WikittyExtension extension : wikitty.getExtensions()) { - // add one by one to manage require - - // during loop add new when old one is found - if (extension.equals(oldExt)) { - addExtension(service, transaction, result, newExt); - } - else { - addExtension(service, transaction, result, extension); - } - } - - // Copy other values - Set<String> fqFieldNames = wikitty.fieldNames(); - String extName = newExt.getName(); - for (String fieldName : fqFieldNames) { - if(!fieldName.startsWith(extName + ".")) { - Object value = wikitty.getFqField(fieldName); - log.debug("Value " + fieldName + "=" + value); - result.setFqField(fieldName, value); - } - } - - // Migrate field name - Collection<String> oldFieldNames = oldExt.getFieldNames(); - Collection<String> newFieldNames = newExt.getFieldNames(); - for (String fieldName : newFieldNames) { - FieldType fieldType = newExt.getFieldType(fieldName); - - String renameFrom = fieldType.getTagValue(TAG_RENAME); - log.debug("Scan rename migration on " + extName + "." + fieldName + ":" + TAG_RENAME + "=" + renameFrom); - - if(renameFrom != null && !renameFrom.isEmpty()) { - Object value = wikitty.getFieldAsObject(extName, renameFrom); - log.debug("Rename " + extName + "." + fieldName + "=" + value); - result.setField(extName, fieldName, value); - } else { - if(oldFieldNames.contains(fieldName)) { - Object value = wikitty.getFieldAsObject(extName, fieldName); - log.debug("Copy " + extName + "." + fieldName + "=" + value); - result.setField(extName, fieldName, value); - } - } - } - - return result; - } - -} Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyExtensionStorage.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyExtensionStorage.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyExtensionStorage.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,95 +0,0 @@ -/* *##% - * Copyright (c) 2009 poussin. All rights reserved. - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - *##%*/ - -package org.sharengo.wikitty; - -import java.util.Collection; -import java.util.List; - -/** - * - * @author poussin - * @version $Revision$ - * - * Last update: $Date$ - * by : $Author$ - */ -public interface WikittyExtensionStorage { - - /** - * Store extension in storage. - * - * @param transaction the current transaction - * @param extensions the extensions to store - * @return information usefull for client side update data - */ - UpdateResponse store(WikittyTransaction transaction, Collection<WikittyExtension> extensions); - - /** - * Return true if id exists in storage. - * - * @param transaction the current transaction - * @param id an extension id - * @return true if the extension exists - */ - boolean exists(WikittyTransaction transaction, String id); - - /** - * Return all extension ids. - * - * @param transaction the current transaction - * @return a list of extension ids - */ - List<String> getAllExtensionIds(WikittyTransaction transaction); - - /** - * Return all extension ids where the specified extensionName is required. - * - * @param transaction the current transaction - * @param extensionName the extension required - * @return a list of extension ids - */ - List<String> getAllExtensionsRequires(WikittyTransaction transaction, - String extensionName); - - /** - * return last version available for specified extension name. - * - * @param transaction the current transaction - * @param extName name of extension - * @return last version availble for this version, or null if extension - * doesn't exist - */ - String getLastVersion(WikittyTransaction transaction, String extName); - - /** - * Restore one extension from storage, if not found an exception is thrown. - * - * @param transaction the current transaction - * @param name extension name to restore - * @param version extension version to restore - * @return an extension - */ - WikittyExtension restore(WikittyTransaction transaction, String name, String version) - throws WikittyException; - - /** - * Remove all extensions - */ - public void clear(WikittyTransaction transaction); - -} Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyProxy.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyProxy.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyProxy.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,514 +0,0 @@ -/* *##% - * Copyright (c) 2009 Sharengo, Guillaume Dufrene, Benjamin POUSSIN. - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - *##%*/ - -package org.sharengo.wikitty; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.HashMap; -import java.util.HashSet; -import java.util.Iterator; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Map.Entry; -import java.util.Set; -import org.sharengo.wikitty.search.Element; -import org.sharengo.wikitty.search.Search; - -/** - * - * @author poussin - * @version $Revision$ - * - * Last update: $Date$ - * by : $Author$ - */ -public class WikittyProxy { - - protected WikittyService wikittyService; - - public WikittyService getWikittyService() { - return wikittyService; - } - - public void setWikittyService(WikittyService wikittyService) { - this.wikittyService = wikittyService; - } - - public <E extends BusinessEntity> E store(E e) { - Wikitty w = WikittyUtil.beanToWikitty(e); - UpdateResponse resp = wikittyService.store(w); - resp.update(e); - return e; - } - - /** - * Store to WikittyService objects. - * @param objets list of BeanDto - * @return - */ - public <E extends BusinessEntity> List<E> store(List<E> objets) { - // prepare data to send to service - List<Wikitty> wikitties = new ArrayList<Wikitty>(objets.size()); - for (E e : objets) { - Wikitty w = WikittyUtil.beanToWikitty(e); - wikitties.add(w); - } - - // call the service with Wikitty - UpdateResponse resp = wikittyService.store(wikitties); - - // update object - for (E e : objets) { - resp.update(e); - } - return objets; - } - - /** - * Restore wikitty entity with specified id or {@code null} if entity can't be found. - * - * @param clazz entity class - * @param id entity id - * @param checkExtension if true check that Wikitty result has all extension - * declared in clazz - * @return wikitty entity with specified id or {@code null} if entity can't be found - */ - public <E extends BusinessEntity> E restore(Class<E> clazz, String id, boolean checkExtension) { - E result = null; - HashSet extNames = null; - try { - Wikitty wikitty = wikittyService.restore(id); - if(wikitty == null) { - return null; - } - - if (checkExtension) { - extNames = new HashSet<String>(wikitty.getExtensionNames()); - } - result = WikittyUtil.newInstance(wikittyService, clazz, wikitty); - } catch (Exception eee) { - throw new WikittyException(eee); - } - if (checkExtension) { - // WikittyUtil.newInstance instanciate only BusinessEntityWikittyImpl - BusinessEntityWikitty b = (BusinessEntityWikitty)result; - Collection<WikittyExtension> BusinessEntityStaticExtensions = b.getStaticExtensions(); - for (WikittyExtension ext : BusinessEntityStaticExtensions) { - String extensionName = ext.getName(); - if (!extNames.contains(extensionName)) { - // extension wanted by BusinessEntity (clazz) - // is not in wikitty, then wikitty is not good type - // for business - return null; - } - } - } - return result; - } - - /** - * Restore wikitty entity with specified id or {@code null} if entity can't be found. - * - * @param clazz entity class - * @param id entity id - * @return wikitty entity with specified id or {@code null} if entity can't be found - */ - public <E extends BusinessEntity> E restore(Class<E> clazz, String id) { - E result = restore(clazz, id, false); - return result; - } - - /** - * - * @param clazz - * @param id - * @param checkExtension if true check that Wikitty result has all extension - * @return - */ - public <E extends BusinessEntity> List<E> restore( - Class<E> clazz, List<String> id, boolean checkExtension) { - - List<Wikitty> wikitties = wikittyService.restore(id); - List<E> result = new ArrayList<E>(); - for (Wikitty w : wikitties) { - HashSet extNames = null; - if (checkExtension) { - extNames = new HashSet<String>(w.getExtensionNames()); - } - - E dto = WikittyUtil.newInstance(wikittyService, clazz, w); - if (checkExtension) { - // WikittyUtil.newInstance instanciate only BusinessEntityWikittyImpl - BusinessEntityWikitty b = (BusinessEntityWikitty) dto; - for (WikittyExtension ext : b.getStaticExtensions()) { - if (!extNames.contains(ext.getName())) { - // extension wanted by BusinessEntity (clazz) - // is not in wikitty, then wikitty is not good type - // for business - return null; - } - } - } - result.add(dto); - } - return result; - } - - public <E extends BusinessEntity> List<E> restore(Class<E> clazz, List<String> id) { - List<E> result = restore(clazz, id, false); - return result; - } - - public void delete(String id) { - wikittyService.delete(id); - } - - public void delete(Collection<String> ids) { - wikittyService.delete(ids); - } - - public <E extends BusinessEntityWikitty> PagedResult<E> findAllByExample(E e, - int firstIndex, int endIndex, String ... fieldFacet ) { - - Criteria criteria = Search.query(e.getWikitty()).criteria() - .setFirstIndex(firstIndex).setEndIndex(endIndex) - .setFacetField(fieldFacet); - - PagedResult<Wikitty> pagedResult = wikittyService.findAllByCriteria(criteria); - // we can use autoconvert = true because search by example add automaticaly - // restriction on extension - PagedResult<E> result = (PagedResult<E>)pagedResult.cast(wikittyService, e.getClass(), true); - return result; - } - - public <E extends BusinessEntityWikitty> E findByExample(E e) { - Criteria criteria = Search.query(e.getWikitty()).criteria(); - - Wikitty w = wikittyService.findByCriteria(criteria); - E result = (E)WikittyUtil.newInstance(wikittyService, e.getClass(), w); - return result; - } - - /** - * Search object that correspond to criteria and that have all extension - * needed by BusinessEntity (clazz). If criteria is null, find all extensions - * else if crtiteria is empty return nothing. - * @param clazz - * @param criteria - * @param firstIndex - * @param endIndex - * @return - */ - public <E extends BusinessEntity> PagedResult<E> findAllByCriteria( - Class<E> clazz, Criteria criteria) { - - // newInstance only return BusinessEntityWikittyImpl - BusinessEntityWikitty sample = - (BusinessEntityWikitty)WikittyUtil.newInstance(clazz); - - Wikitty wikitty = sample.getWikitty(); - Collection<String> extensions = wikitty.getExtensionNames(); - - Criteria serviceCriteria; - if(criteria == null) { - Search search = Search.query(); - search = search.eq(Element.ELT_EXTENSION, extensions); - - serviceCriteria = search.criteria(); - } else { - Search search = Search.query(criteria); - search = search.eq(Element.ELT_EXTENSION, extensions); - - serviceCriteria = search.criteria(criteria.getName()); - serviceCriteria.setFirstIndex(criteria.getFirstIndex()); - serviceCriteria.setEndIndex(criteria.getEndIndex()); - - List<String> facetField = criteria.getFacetField(); - if(facetField != null) { - String[] facetFieldTab = new String[facetField.size()]; - serviceCriteria.setFacetField(facetField.toArray(facetFieldTab)); - } - - List<Criteria> facetCriteria = criteria.getFacetCriteria(); - if(facetCriteria != null) { - Criteria[] facetCriteriaTab = new Criteria[facetCriteria.size()]; - serviceCriteria.setFacetCriteria(facetCriteria.toArray(facetCriteriaTab)); - } - - List<String> sortAscending = criteria.getSortAscending(); - if(sortAscending != null) { - String[] sortAscendingTab = new String[sortAscending.size()]; - serviceCriteria.setSortAscending(sortAscending.toArray(sortAscendingTab)); - } - - List<String> sortDescending = criteria.getSortDescending(); - if(sortDescending != null) { - String[] sortDescendingTab = new String[sortDescending.size()]; - serviceCriteria.setSortDescending(sortDescending.toArray(sortDescendingTab)); - } - } - - PagedResult<Wikitty> pagedResult = wikittyService.findAllByCriteria(serviceCriteria); - - // we can cast with autoconvert true because we have add restriction - // on extension - PagedResult<E> result = (PagedResult<E>)pagedResult.cast(wikittyService, sample.getClass(), true); - return result; - } - - public <E extends BusinessEntity> E findByCriteria(Class<E> clazz, Criteria criteria) { - BusinessEntityWikitty sample = - (BusinessEntityWikitty)WikittyUtil.newInstance(clazz); - - Wikitty wikitty = sample.getWikitty(); - Collection<String> extensions = wikitty.getExtensionNames(); - Search search = Search.query(criteria); - search = search.eq(Element.ELT_EXTENSION, extensions); - - criteria = search.criteria(criteria.getName()); - - Wikitty w = wikittyService.findByCriteria(criteria); - E result = WikittyUtil.newInstance(wikittyService, clazz, w); - return result; - } - - public void addLabel(String wikittyId, String label) { - wikittyService.addLabel(wikittyId, label); - } - - public PagedResult<Wikitty> findAllByLabel(String label, int firstIndex, int endIndex) { - PagedResult<Wikitty> result = wikittyService.findAllByLabel( - label, firstIndex, endIndex); - return result; - } - - public Wikitty findByLabel(String label) { - Wikitty result = wikittyService.findByLabel(label); - return result; - } - - public Set<String> findAllAppliedLabels(String wikittyId) { - Set<String> result = wikittyService.findAllAppliedLabels(wikittyId); - return result; - } - - public Tree restoreTree(String wikittyId) { - Tree result = wikittyService.restoreTree(wikittyId); - return result; - } - - public <E extends BusinessEntity> Map.Entry<E, Integer> restoreNode(Class<E> clazz, String wikittyId, Criteria filter) { - Entry<E, Integer> result = restoreNode(clazz, wikittyId, filter, false); - return result; - } - - public <E extends BusinessEntity> Map.Entry<E, Integer> restoreNode(Class<E> clazz, String wikittyId, Criteria filter, boolean checkExtension) { - Map.Entry<TreeNode, Integer> node = wikittyService.restoreNode(wikittyId, filter); - if(node == null) { - return null; - } - - E bean = restore(clazz, wikittyId, checkExtension); - if(bean == null) { - return null; - } - - Map.Entry<E, Integer> result = - new HashMap.SimpleEntry<E, Integer>(bean, node.getValue()); - return result; - } - - public <E extends BusinessEntity> Map<E, Integer> restoreChildren(Class<E> clazz, String wikittyId, Criteria filter) { - Map<E, Integer> result = restoreChildren(clazz, wikittyId, filter, false); - return result; - } - - public <E extends BusinessEntity> Map<E, Integer> restoreChildren(Class<E> clazz, String wikittyId, Criteria filter, boolean checkExtension) { - - Map<TreeNode, Integer> result = wikittyService.restoreChildren(wikittyId, filter); - if(result == null) { - return null; - } - - Map<E, Integer> convertedResult = new LinkedHashMap<E, Integer>(); - Set<Entry<TreeNode, Integer>> entries = result.entrySet(); - for (Entry<TreeNode, Integer> entry : entries) { - - TreeNode node = entry.getKey(); - - //TODO EC-20100420 was : String nodeId = node.getId(); - String nodeId = node.getWikittyId(); - - E businessEntity = null; - HashSet<String> extNames = null; - try { - Wikitty wikitty = wikittyService.restore(nodeId); - if(checkExtension) { - extNames = new HashSet<String>(wikitty.getExtensionNames()); - } - businessEntity = WikittyUtil.newInstance(wikittyService, clazz, wikitty); - } catch (Exception eee) { - throw new WikittyException(eee); - } - - boolean goodType = true; - if(checkExtension) { - // WikittyUtil.newInstance instanciate only BusinessEntityWikittyImpl - BusinessEntityWikitty businessEntityImpl = (BusinessEntityWikitty) businessEntity; - Collection<WikittyExtension> staticExtensions = businessEntityImpl.getStaticExtensions(); - - for (Iterator<WikittyExtension> iterator = staticExtensions.iterator(); iterator.hasNext() && goodType;) { - WikittyExtension ext = iterator.next(); - if (!extNames.contains(ext.getName())) { - // extension wanted by BusinessEntity (clazz) - // is not in wikitty, then wikitty is not good type - // for business - goodType = false; - } - } - } - - if(goodType) { - Integer nodeCount = entry.getValue(); - convertedResult.put(businessEntity, nodeCount); - } - } - return convertedResult; - } - - public Wikitty restoreVersion(String wikittyId, String version) { - Wikitty result = wikittyService.restoreVersion(wikittyId, version); - return result; - } - - public <E extends BusinessEntity> boolean hasType(Class<E> clazz, String wikittyId) { - E result = null; - HashSet<String> extNames = null; - try { - Wikitty wikitty = wikittyService.restore(wikittyId); - if(wikitty == null) { - return false; - } - extNames = new HashSet<String>(wikitty.getExtensionNames()); - result = WikittyUtil.newInstance(wikittyService, clazz, wikitty); - } catch (Exception eee) { - throw new WikittyException(eee); - } - // WikittyUtil.newInstance instanciate only BusinessEntityWikittyImpl - BusinessEntityWikitty b = (BusinessEntityWikitty)result; - for (WikittyExtension ext : b.getStaticExtensions()) { - if (!extNames.contains(ext.getName())) { - // extension wanted by BusinessEntity (clazz) - // is not in wikitty, then wikitty is not good type - // for business - return false; - } - } - return true; - } - - public void syncImportFromXml(String xml) { - wikittyService.syncImportFromXml(xml); - } - - public void syncImportFromUri(String uri) { - wikittyService.syncImportFromUri(uri); - } - - /** - * - * @param uri - * @return job id - */ - public String asyncImportFromUri(String uri) { - String result = wikittyService.asyncImportFromUri(uri); - return result; - } - - /** - * - * @param e - * @return job id - */ - public <E extends BusinessEntityWikitty> String asyncExportAllByExample(E e) { - Criteria criteria = Search.query(e.getWikitty()).criteria(); - String result = wikittyService.asyncExportAllByCriteria(criteria); - return result; - } - - /** - * - * @param e - * @return xml string - */ - public <E extends BusinessEntityWikitty> String syncExportAllByExample(E e) { - Criteria criteria = Search.query(e.getWikitty()).criteria(); - String result = wikittyService.syncExportAllByCriteria(criteria); - return result; - } - - /** - * - * @param criteria - * @return job id - */ - public String asyncExportAllByCriteria(Criteria criteria) { - String result = wikittyService.asyncExportAllByCriteria(criteria); - return result; - } - - /** - * - * @param criteria - * @return xml string - */ - public String syncExportAllByCriteria(Criteria criteria) { - String result = wikittyService.syncExportAllByCriteria(criteria); - return result; - } - - /** - * give the job state - * @param jobId - * @return - */ - public JobState infoJob(String jobId) { - JobState result = wikittyService.infoJob(jobId); - return result; - } - - /** - * cancel job you must call freeJobResource - * @param jobId - */ - public void cancelJob(String jobId) { - wikittyService.cancelJob(jobId); - } - - /** - * This method must be call when your job is done and you have result, or - * when you call cancelJob - * @param jobId - */ - public void freeJobResource(String jobId) { - wikittyService.freeJobResource(jobId); - } - - -} Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittySearchEngin.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittySearchEngin.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittySearchEngin.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,83 +0,0 @@ -/* *##% - * Copyright (c) 2009 poussin. All rights reserved. - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - *##%*/ - -package org.sharengo.wikitty; - -import java.util.Collection; -import java.util.Map; - -/** - * WikittySearchEngin is used to abstract search engin used in WikittyService. - * - * - * @author poussin - * @version $Revision$ - * - * Last update: $Date$ - * by : $Author$ - */ -public interface WikittySearchEngin { - - /** - * Remove all data in index - */ - public void clear(WikittyTransaction transaction); - - /** - * Store wikitty in storage - * @return information usefull for client side update data - */ - public UpdateResponse store(WikittyTransaction transaction, - Collection<Wikitty> wikitties); - - /** - * Delete all object with idList argument. If id is not valid or don't exist. - * - * @param idList list of ids to delete - * @return <code>UpdateResponse</code>> - * @throws WikittyException - */ - public UpdateResponse delete(WikittyTransaction transaction, - Collection<String> idList) throws WikittyException; - - /** - * Delete all object with idList argument. idList is directly passed to search engine - * and is processed without any other kind of treatment. - * - * @param idList list of ids to delete - * @return <code>UpdateResponse</code>> - * @throws WikittyException - */ - public void delete(Collection<String> idList) throws WikittyException; - - public PagedResult<String> findAllByCriteria(WikittyTransaction transaction, Criteria criteria); - - /** - * Find count of child for a node - * @param w - * @return - */ - public Integer findNodeCount(WikittyTransaction transaction, Wikitty w, Criteria filter); - - /** - * Find all children ids with count for a node wikitty. - * @param w - * @return - */ - public Map<String, Integer> findAllChildrenCount(WikittyTransaction transaction, Wikitty w, Criteria filter); - -} Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyService.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyService.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyService.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,304 +0,0 @@ -/* *##% - * Copyright (c) 2009 Sharengo, Guillaume Dufrene, Benjamin POUSSIN. - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - *##%*/ - -package org.sharengo.wikitty; - -import java.util.Collection; -import java.util.List; -import java.util.Map; -import java.util.Set; - -/** - * - * @author poussin - * @version $Revision$ - * - * Last update: $Date$ - * by : $Author$ - */ -public interface WikittyService { - - /** - * Use {@link Criteria.ALL_ELEMENTS} - */ - @Deprecated - public static final int ALL_ELEMENTS = -1; - - /* - * Storage - */ - - /** - * Use with caution : It will delete ALL indexes from search engine ! - * This operation should be disabled in production environment. - */ - public void clear(); - - /** - * Manage Update and creation. - * - * @param wikitty contains an id all the time. - */ - UpdateResponse store(Wikitty wikitty); - - /** - * Manage Update and creation. - * - * @param wikitties list of wikitty to be persisted - */ - UpdateResponse store(Collection<Wikitty> wikitties); - - /** - * Manage Update and creation. - * - * @param wikitties list of wikitty to be persisted - * @param disableAutoVersionIncrement boolean to disable version increment - * on saved wikitty - */ - UpdateResponse store(Collection<Wikitty> wikitties, - boolean disableAutoVersionIncrement); - - /** - * Return all extension id (ex: "extName[version])") - * @return - */ - List<String> getAllExtensionIds(); - - /** - * Return all extension id (ex: "extName[version])") where extensionName is required. - * @return - */ - List<String> getAllExtensionsRequires(String extensionName); - - /** - * Manage Update and creation. - * - * @param wikitty extension to be persisted - */ - UpdateResponse storeExtension(WikittyExtension ext); - - /** - * Manage Update and creation. - * - * @param exts list of wikitty extension to be persisted - */ - UpdateResponse storeExtension(Collection<WikittyExtension> exts); - - /** - * - * @param id - * @return the corresponding object, exception if no such object found. - */ - public WikittyExtension restoreExtension(String id); - - /** - * Search extension with name in last version - * @param name - * @return the corresponding object, exception if no such object found. - */ - public WikittyExtension restoreExtensionLastVersion(String name); - - /** - * - * @param id object id to restore - * @return the corresponding object, or null if object doesn't exist or is - * deleted - */ - Wikitty restore( String id ); - - /** - * - * @param id list of wikitty ids to restore - * @return list of corresponding wikitty, if one id is not valid (no object - * or deleted) this id is skip and result list have less elements than - * collection argument - */ - List<Wikitty> restore( List<String> id ); - - /** - * delete object if id exists - * @param id object's id to remove - */ - void delete(String id); - - /** - * delete all object if id exists - * @param ids object's ids to remove - */ - void delete(Collection<String> ids); - - /** - * - * @param criteria - * @return - */ - public PagedResult<Wikitty> findAllByCriteria(Criteria criteria); - - /** - * Fist lonely (or first one) wikitty object that match criteria, if no wikitty found return null - * @param criteria - * @return - */ - public Wikitty findByCriteria(Criteria criteria); - - /* - * Labelisation - */ - - /** - * add new lable to the wikitty object - * @param wikittyId id of wikitty object to add label - * @param label label to add - */ - void addLabel(String wikittyId, String label); - - /** - * - * @param label - * @return - */ - PagedResult<Wikitty> findAllByLabel(String label, int firstIndex, int endIndex); - - /** - * - * @param addLabel - * @return - */ - Wikitty findByLabel(String label); - - /** - * retrieve all labels applied on a wikitty object - * @param wikittyId - * @return - */ - Set<String> findAllAppliedLabels(String wikittyId); - - - /* - * Classification - * Most of classification purpose is handle by extension mechanisms - */ - - /** - * Retrieve all wikitties children (recursively) of an other one - * Wikitty reference by wikittyId MUST include the 'Node' extension - * - * @param wikittyId - * @return - */ - Tree restoreTree(String wikittyId); - - /** - * Retrieve wikitty node with count. Wikitty reference by wikittyId MUST - * include the 'Node' extension - * @param wikittyId - * @return - */ - Map.Entry<TreeNode, Integer> restoreNode(String wikittyId, Criteria filter); - - /** - * Retrieve all wikitties children with count (no recursively) of an other one - * Wikitty reference by wikittyId MUST include the 'Node' extension - * - * @param wikittyId - * @return - */ - Map<TreeNode, Integer> restoreChildren(String wikittyId, Criteria filter); - - - /* - * history - */ - - /** - * - */ - Wikitty restoreVersion(String wikittyId, String version); - - /* - * admin - */ - - /** - * Synchronise search engine with wikitty strorage engine, i.e. clear and - * reindex all wikitties. - * @return - */ - UpdateResponse syncEngin(); - - /* - * Import / Export - */ - - - /** - * synchonous or not ? - * - * @param xmlData data to import - */ - void syncImportFromXml(String xml); - - /** - * - * @param uri - */ - void syncImportFromUri(String uri); - - /** - * - * @param uri - * @return a jobID - */ - String asyncImportFromUri(String uri); - - /** - * - * @param criteria - * @return - */ - String asyncExportAllByCriteria(Criteria criteria); - - /** - * - * @param criteria - * @return - */ - String syncExportAllByCriteria(Criteria criteria); - - /* - * Job Management - */ - - /** - * - * @param jobId - * @return - */ - JobState infoJob(String jobId); - - /** - * - * @param jobId - */ - void cancelJob(String jobId); - - /** - * delete job info and all resources associated to that job (files or other ...) - */ - void freeJobResource(String jobId); - -} Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyServiceInMemory.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyServiceInMemory.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyServiceInMemory.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,418 +0,0 @@ -/* *##% - * Copyright (c) 2009 poussin. All rights reserved. - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - *##%*/ - -package org.sharengo.wikitty; - -import java.io.File; -import java.io.FileInputStream; -import java.io.FileOutputStream; -import java.io.IOException; -import java.io.ObjectInputStream; -import java.io.ObjectOutputStream; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Date; -import java.util.HashMap; -import java.util.LinkedHashMap; -import java.util.LinkedList; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.Map.Entry; - -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; -import org.sharengo.wikitty.FieldType.TYPE; -import org.sharengo.wikitty.search.And; -import org.sharengo.wikitty.search.BinaryOperator; -import org.sharengo.wikitty.search.Element; -import org.sharengo.wikitty.search.Restriction; - -/** - * In memory implementation of WikittyService, currently used for test only - * - * @author poussin - * @version $Revision$ - * - * Last update: $Date$ - * by : $Author$ - */ -public class WikittyServiceInMemory extends AbstractWikittyService { - - //FIXME InMemory implementation is not usable for production. Must be reviewed. - //FIXME The version increment must be done in 'prepare' method - - /** to use log facility, just put in your code: log.info(\"...\"); */ - static private Log log = LogFactory.getLog(WikittyServiceInMemory.class); - - public static class WikittyStorageInMemory implements WikittyStorage { - protected Map<String, Wikitty> wikitties = new LinkedHashMap<String, Wikitty>(); - - @Override - public UpdateResponse store(WikittyTransaction transaction, Collection<Wikitty> wikitties, boolean disableAutoVersionIncrement) { - UpdateResponse result = new UpdateResponse(); - for (Wikitty wikitty : wikitties) { - wikitty.version = WikittyUtil.incrementMajorRevision(wikitty.version); - wikitty.fieldDirty.clear(); - this.wikitties.put(wikitty.id, wikitty); - result.addVersionUpdate(wikitty.id, wikitty.version); - } - return result; - } - - @Override - public UpdateResponse delete(WikittyTransaction transaction, Collection<String> idList) throws WikittyException { - UpdateResponse result = new UpdateResponse(); - Date now = new Date(); - for (String id : idList) { - Wikitty w = restore(transaction, id); - w.setDeleteDate(now); - result.addDeletionDateUpdate(id, now); - } - return result; - } - - @Override - public boolean exists(WikittyTransaction transaction, String id) { - boolean result = wikitties.containsKey(id); - return result; - } - - @Override - public boolean isDeleted(WikittyTransaction transaction, String id) { - boolean result = false; - Wikitty w = wikitties.get(id); - if (w == null) { - throw new WikittyException(String.format("No wikitty with id '%s'", id)); - } else { - result = w.isDeleted(); - } - return result; - } - - @Override - public Wikitty restore(WikittyTransaction transaction, String id, String ... fqFieldName) throws WikittyException { - Wikitty result = wikitties.get(id); - if (result.isDeleted()) { - result = null; - } - if (result == null) { - throw new WikittyException(String.format("No wikitty with id '%s'", id)); - } - return result; - } - - @Override - public void scanWikitties(WikittyTransaction transaction, Scanner scanner) { - Collection<Wikitty> all = wikitties.values(); - for (Wikitty wikitty : all) { - scanner.scan(wikitty); - } - } - - @Override - public void clear(WikittyTransaction transaction) { - wikitties = new LinkedHashMap<String, Wikitty>(); - } - } - - public static class WikittyExtensionStorageInMemory implements WikittyExtensionStorage { - protected Map<String, WikittyExtension> extensions; - - public WikittyExtensionStorageInMemory() { - this.extensions = new HashMap<String, WikittyExtension>(); - } - - @Override - public UpdateResponse store(WikittyTransaction transaction, - Collection<WikittyExtension> exts) throws WikittyException { - for (WikittyExtension ext : exts) { - extensions.put(ext.getId(), ext); - } - // nothing to do in UpdateResponse - UpdateResponse result = new UpdateResponse(); - return result; - } - - @Override - public boolean exists(WikittyTransaction transaction, String id) { - boolean result = extensions.containsKey(id); - return result; - } - - @Override - public List<String> getAllExtensionIds(WikittyTransaction transaction) { - List<String> result = new ArrayList<String>(extensions.keySet()); - return result; - } - - @Override - public List<String> getAllExtensionsRequires(WikittyTransaction transaction, - String extensionName) { - ArrayList<String> ids = new ArrayList<String>(); - - Collection<WikittyExtension> values = extensions.values(); - if (values != null) { - for (WikittyExtension extension : values) { - if (extensionName.equals(extension.getRequires())) { - ids.add(extension.getId()); - } - } - } - - return ids; - } - - @Override - public String getLastVersion(WikittyTransaction transaction, String extName) { - String result = null; - Set<String> extensionIds = extensions.keySet(); - for (String extensionId : extensionIds) { - String extensionVersion = WikittyExtension.computeVersion(extensionId); - if(extensionId.startsWith(extName) && (result == null || - WikittyUtil.versionGreaterThan(extensionVersion, result))) { - result = extensionVersion; - } - } - return result; - } - - @Override - public WikittyExtension restore(WikittyTransaction transaction, String name, String version) - throws WikittyException { - String id = WikittyExtension.computeId(name, version); - WikittyExtension result = extensions.get(id); - if (result == null) { - throw new WikittyException(String.format("No extension with id '%s'", id)); - } - return result; - } - - @Override - public void clear(WikittyTransaction transaction) { - extensions = new HashMap<String, WikittyExtension>(); - } - } - - public static class WikittySearchEnginInMemory implements WikittySearchEngin { - - WikittyStorageInMemory wikittyStorage; - - public WikittySearchEnginInMemory(WikittyStorageInMemory wikittyStorage) { - this.wikittyStorage = wikittyStorage; - } - - @Override - public void clear(WikittyTransaction transaction) { - // do nothing - } - - @Override - public UpdateResponse store(WikittyTransaction transaction, - Collection<Wikitty> wikitties) { - // do nothing - return new UpdateResponse(); - } - - @Override - public UpdateResponse delete(WikittyTransaction transaction, - Collection<String> idList) throws WikittyException { - // do nothing - return new UpdateResponse(); - } - - - @Override - public void delete(Collection<String> idList) throws WikittyException { - } - - public boolean checkRestriction( Restriction restriction, Wikitty w ) { - if ( restriction instanceof BinaryOperator ) { - BinaryOperator binOp = (BinaryOperator) restriction; - - if ( binOp.getElement().equals(Element.ELT_EXTENSION) ) { - return w.hasExtension(binOp.getValue()); - } - - String fqfieldName = binOp.getElement().getName(); - if(Element.ELT_EXTENSION.equals(fqfieldName) || - Element.ELT_ID.equals(fqfieldName)) { - return true; // FIXME: 20091104 jru manage search on extension and id - } - Object o = w.getFqField( fqfieldName ); - FieldType t = w.getFieldType(fqfieldName); - Object value = t.getValidValue( binOp.getValue() ); - boolean checked = false; - switch( restriction.getName() ) { - case EQUALS: - checked = value.equals(o); - break; - case LESS: - checked = ((Comparable)o).compareTo( value ) < 0; - break; - case LESS_OR_EQUAL: - checked = ((Comparable)o).compareTo( value ) <= 0; - break; - case GREATER: - checked = ((Comparable)o).compareTo( value ) > 0; - break; - case GREATER_OR_EQUAL: - checked = ((Comparable)o).compareTo( value ) >= 0; - break; - case NOT_EQUALS: - checked = !value.equals(o); - break; - case ENDS_WITH: - if (t.getType() != TYPE.STRING) { - throw new WikittyException("Can't search for contents that 'ends with' on attribute type different of String. " + - "Attribute " + fqfieldName + " is " + t.getType().name() ); - } - checked = ((String) o).endsWith( (String) value ); - break; - case STARTS_WITH: - if (t.getType() != TYPE.STRING) { - throw new WikittyException("Can't search for contents that 'starts with' on attribute type different of String. " + - "Attribute " + fqfieldName + " is " + t.getType().name() ); - } - checked = ((String) o).startsWith( (String) value ); - break; - } - return checked; - } else if ( restriction instanceof And ) { - And and = (And) restriction; - for ( Restriction sub : and.getRestrictions() ) { - if (!checkRestriction(sub, w)) { - return false; - } - } - return true; - } else { - throw new UnsupportedOperationException( restriction.getName() + " Search Not yet implemented"); - } - } - - @Override - public PagedResult<String> findAllByCriteria(WikittyTransaction transaction, - Criteria criteria) { - // throw new UnsupportedOperationException("Not supported yet."); - - int firstIndex = criteria.getFirstIndex(); - int endIndex = criteria.getEndIndex(); - - List<String> ids = new LinkedList<String>(); - int currentIndex = 0; - - for( Entry<String, Wikitty> entry : wikittyStorage.wikitties.entrySet() ) { - Wikitty w = entry.getValue(); - String id = entry.getKey(); - Restriction dto = criteria.getRestriction(); - - if ( checkRestriction(dto, w) ) { - currentIndex++; - if (currentIndex > firstIndex) { - ids.add(id); - } - if (endIndex >= 0 && currentIndex >= endIndex) { - break; - } - } - - } - return new PagedResult<String>(firstIndex, endIndex, criteria.getRestriction().toString(), null, ids ); - } - - @Override - public Integer findNodeCount(WikittyTransaction transaction, Wikitty w, Criteria filter) { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public Map<String, Integer> findAllChildrenCount(WikittyTransaction transaction, Wikitty w, Criteria filter) { - throw new UnsupportedOperationException("Not supported yet."); - } - - } - - /** - * if persitenceFile is not null, serialize all data to disk during store - * operation and the file is reloaded during init - */ - protected File persitenceFile = null; - - protected WikittyStorage wikittyStorage; - protected WikittyExtensionStorage extensionStorage; - protected WikittySearchEngin searchEngin; - - public WikittyServiceInMemory() { - extensionStorage = new WikittyExtensionStorageInMemory(); - wikittyStorage = new WikittyStorageInMemory(); - searchEngin = new WikittySearchEnginInMemory((WikittyStorageInMemory)wikittyStorage); - } - - public WikittyServiceInMemory(File persitenceFile) { - this(); - this.persitenceFile = persitenceFile; - if (persitenceFile != null && persitenceFile.exists()) { - try { - ObjectInputStream in = new ObjectInputStream(new FileInputStream( - persitenceFile)); - ((WikittyExtensionStorageInMemory)extensionStorage).extensions = (Map) in.readObject(); - ((WikittyStorageInMemory)wikittyStorage).wikitties = (Map) in.readObject(); - in.close(); - } catch (Exception eee) { - log.error("Can't read data file " + persitenceFile, eee); - } - } - } - - @Override - protected WikittyStorage getWikittyStorage() { - return wikittyStorage; - } - - @Override - protected WikittyExtensionStorage getExtensionStorage() { - return extensionStorage; - } - - @Override - protected WikittySearchEngin getSearchEngin() { - return searchEngin; - } - - @Override - protected void finalize() throws Throwable { - saveToPersistenceFile(); - - super.finalize(); - } - - public void saveToPersistenceFile() { - if (persitenceFile != null) { - try { - ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream( - persitenceFile)); - out.writeObject(((WikittyExtensionStorageInMemory)extensionStorage).extensions); - out.writeObject(((WikittyStorageInMemory)wikittyStorage).wikitties); - out.close(); - } catch (IOException eee) { - log.error("Can't write data file " + persitenceFile, eee); - } - } - } - -} Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyStorage.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyStorage.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyStorage.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,90 +0,0 @@ -/* *##% - * Copyright (c) 2009 poussin. All rights reserved. - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - *##%*/ - -package org.sharengo.wikitty; - -import java.util.Collection; -import java.util.List; - -/** - * WikittyStorage is used to abstract data and extension storage in WikittyService. - * - * @author poussin - * @version $Revision$ - * - * Last update: $Date$ - * by : $Author$ - */ -public interface WikittyStorage { - - /** - * Store wikitty in storage - * @return information usefull for client side update data - */ - public UpdateResponse store(WikittyTransaction transaction, Collection<Wikitty> wikitties, boolean disableAutoVersionIncrement); - - /** - * Return true if id exists in storage - * @param id - * @return - */ - public boolean exists(WikittyTransaction transaction, String id); - - /** - * Return true if wikitty object with this id are marked deleted - * @param id - * @return - */ - public boolean isDeleted(WikittyTransaction transaction, String id); - - /** - * Restore list of wikitty object, if wikitty not found an exception is throw - * @param id list of wikitty id - * @param fqFieldName list of field that must be loaded, other fields - * can be not loaded - * @return - */ - public Wikitty restore(WikittyTransaction transaction, String id, - String ... fqFieldName) throws WikittyException; - - /** - * Delete all object with id argument. If id is not valid or don't exist - * throw an exception - * @param idList - * @return - */ - public UpdateResponse delete(WikittyTransaction transaction, Collection<String> idList) throws WikittyException; - - /** - * Scan all wikitties with specific scanner, even if the wikitty is deleted - * @param scanner scanner - */ - void scanWikitties(WikittyTransaction transaction, Scanner scanner); - - /** - * Call each time wikitty is scan - */ - public static interface Scanner { - void scan(Wikitty wikitty); - } - - /** - * Remove all wikitty - */ - public void clear(WikittyTransaction transaction); - -} Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyTransaction.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyTransaction.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyTransaction.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,75 +0,0 @@ -package org.sharengo.wikitty; - -import java.util.HashMap; -import java.util.Map; -import javax.transaction.Status; -import javax.transaction.TransactionManager; -import javax.transaction.UserTransaction; -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; - -/*** - * Manage JTA transaction. You can store some information during execution. - */ -public class WikittyTransaction { - - /** to use log facility, just put in your code: log.info(\"...\"); */ - static private Log log = LogFactory.getLog(AbstractWikittyService.class); - - protected Map<Object, Object> tagValues; - - public WikittyTransaction() { - tagValues = new HashMap<Object, Object>(); - } - - public Object getTagValue(Object tag) { - return tagValues.get(tag); - } - - public void setTagValue(Object tag, Object value) { - tagValues.put(tag, value); - } - - public UserTransaction getUserTransaction() { - return com.arjuna.ats.jta.UserTransaction.userTransaction(); - } - - public TransactionManager getTransactionManager() { - return com.arjuna.ats.jta.TransactionManager.transactionManager(); - } - - public void begin() { - UserTransaction userTransaction = getUserTransaction(); - try { - log.debug("Begin transaction"); - userTransaction.setTransactionTimeout(3600); // FIXME: jru 20100115 error in service if call during lot of times - userTransaction.begin(); - } catch (Exception eee) { - throw new WikittyException("Error on begin JTA transaction", eee); - } - } - - public void commit() { - - UserTransaction userTransaction = getUserTransaction(); - try { - log.debug("Commit transaction"); - userTransaction.commit(); - } catch (Exception eee) { - throw new WikittyException("Error on commit JTA transaction", eee); - } - } - - public void rollback() { - UserTransaction userTransaction = getUserTransaction(); - try { - if(userTransaction.getStatus() != Status.STATUS_NO_TRANSACTION - && userTransaction.getStatus() != Status.STATUS_UNKNOWN) { - log.debug("Rollback transaction"); - userTransaction.rollback(); - } - } catch (Exception eee) { - throw new WikittyException("Error on roolback JTA transaction", eee); - } - } -} Deleted: trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyUtil.java =================================================================== --- trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyUtil.java 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/java/org/sharengo/wikitty/WikittyUtil.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,897 +0,0 @@ -/* *##% - * Copyright (c) 2009 poussin. All rights reserved. - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - *##%*/ - -package org.sharengo.wikitty; - -import java.lang.reflect.Constructor; -import java.lang.reflect.Field; -import java.math.BigDecimal; -import java.text.CharacterIterator; -import java.text.DateFormat; -import java.text.ParseException; -import java.text.SimpleDateFormat; -import java.text.StringCharacterIterator; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.Date; -import java.util.HashMap; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Locale; -import java.util.Map; -import java.util.Set; -import java.util.TimeZone; -import java.util.UUID; -import java.util.regex.Matcher; -import java.util.regex.Pattern; - -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; - -/** - * - * Util static method for wikitty - * - * @author poussin - * @version $Revision$ - * - * Last update: $Date$ by : $Author$ - */ -public class WikittyUtil { - - public static final String DEFAULT_VERSION = "0.0"; - - public static final String DATE_FORMAT = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"; - - /** to use log facility, just put in your code: log.info(\"...\"); */ - static private Log log = LogFactory.getLog(WikittyUtil.class); - - /** used to format date for solr */ - protected static TimeZone CANONICAL_TZ = TimeZone.getTimeZone("UTC"); - protected static final Locale CANONICAL_LOCALE = Locale.US; - - static final public SimpleDateFormat solrDateFormat = new SolrDateFormat(); - - public static class SolrDateFormat extends SimpleDateFormat { - public SolrDateFormat() { - super(DATE_FORMAT, CANONICAL_LOCALE); - setTimeZone(CANONICAL_TZ); - } - } - - /** All date format parser used to convert string to date */ - static final protected DateFormat[] parserDateFormats = new DateFormat[] { - solrDateFormat, DateFormat.getInstance(), - // TODO poussin 20090813: add other date syntax - }; - - // TODO poussin 20090902 use spring configuration to add mapping in this - // variable - /** contains mapping between interface and concret class that must be used */ - static public Map<Class, Class> interfaceToClass = new HashMap<Class, Class>(); - - /** - * Pattern for tag value: tag="value" or tag=value. value can contains '"' - */ - static protected String tagValuesPatternString = "(\\w*)=(\".*?(?<!\\\\)\"|[^(\\p{Space})]+)"; - static protected Pattern tagValuesPattern = Pattern.compile( - tagValuesPatternString, Pattern.DOTALL); - /** - * Field pattern parser <li>group 1: type (string) <li>group 2: name - * (string) <li>group 3: lower bound (number) can be null <li>group 4: upper - * bound (number) can be null, mutualy exclusif with group 5 <li>group 5: - * upper bound (n or *) can be null <li>group 6: unique can be null <li> - * group 7: not null can be null <li>group 8: all tag/value (toto=titi - * tutu=tata;lala tata="truc bidulle") - */ - static protected Pattern fieldPattern = Pattern - .compile( - "\\s*(\\w+)\\s+(\\w+)(?:\\s*\\[(\\d+)-(?:(\\d+)|([\\*n]))\\])?(?:\\s+(unique))?(?:\\s+(not null))?((?:\\s+" - + tagValuesPatternString + ")*)", Pattern.DOTALL); - - /** - * parse FieldType definition and return field name. All field information - * are stored in fieldType object passed in argument - * - * @param def - * string field definition - * @param fieldType - * object used to put parsed information - * @return field name parsed in definition - */ - static public String parseField(String def, FieldType fieldType) { - Matcher match = fieldPattern.matcher(def); - if (match.matches()) { - fieldType.type = FieldType.TYPE.parse(match.group(1)); - String name = match.group(2); - String lower = match.group(3); - if (lower != null) { - fieldType.lowerBound = Integer.parseInt(lower); - } - - String upper = match.group(4); - if (upper != null) { - fieldType.upperBound = Integer.parseInt(upper); - } - String noupper = match.group(5); - if (noupper != null) { - fieldType.upperBound = FieldType.NOLIMIT; - } - String uniqueString = match.group(6); - fieldType.unique = uniqueString != null; - - String notNullString = match.group(7); - fieldType.notNull = notNullString != null; - - String tagValues = match.group(8); - Map<String, String> tagValuesMap = tagValuesToMap(tagValues); - fieldType.setTagValues(tagValuesMap); - - return name; - } else { - throw new WikittyException(String.format( - "Bad FieldType definition '%s'", def)); - } - } - - - /** - * Serialize tagValues to string - * - * @param tagValues tagValues as map - * @return string represent tagValues - */ - public static String tagValuesToString(Map<String, String> tagValues) { - String result = ""; - if(tagValues != null) { - for (String tag : tagValues.keySet()) { - String value = tagValues.get(tag); - // replace " in string with \" - value = value.replaceAll("\"", "\\\\\""); - // quote value with "..." - result += " " + tag + "=\"" + tagValues.get(tag) +"\""; - } - } - return result; - } - - /** - * Deserialize tagValues to map - * - * @param tagValues tagValues as string - * @return map represent tagValues - */ - public static Map<String, String> tagValuesToMap(String tagValues) { - Map<String, String> result = new HashMap<String, String>(); - if (tagValues != null) { - Matcher matchTagValues = tagValuesPattern.matcher(tagValues); - while (matchTagValues.find()) { - String tag = matchTagValues.group(1); - String value = matchTagValues.group(2); - if (value.startsWith("\"") && value.endsWith("\"")) { - // delete start and end " - value = value.substring(1, value.length() - 1); - // if value is between ", then inners " are quoted - value = value.replaceAll("\\\\\"", "\""); - } - result.put(tag, value); - } - } - return result; - } - - /** - * Create map from string representation - * - * ex: "String name", "Wikitty children[0-*]" - * - * @param definitions - * @return - */ - public static LinkedHashMap<String, FieldType> buildFieldMapExtension( - String... definitions) { - LinkedHashMap<String, FieldType> result = new LinkedHashMap<String, FieldType>(); - for (String def : definitions) { - FieldType fieldType = new FieldType(); - String name = WikittyUtil.parseField(def, fieldType); - log.debug("parse " + def + " => " + fieldType.toDefinition(name)); - result.put(name, fieldType); - } - return result; - } - - /** - * if version if null return 0 else version If version is not in format - * <major>.<minor>, ".0" is added to the version - * - * @param version - * @return the normalized version - */ - public static String normalizeVersion(String version) { - if (version == null || "".equals(version)) { - version = "0"; - } - if (version.indexOf(".") == -1) { - version += ".0"; - } - return version; - } - - /** - * return true if v1 and v2 are egals 1.2.0 et 1.2 ne sont pas egaux - */ - public static boolean versionEquals(String v1, String v2) { - if (v1 == null || v2 == null) { - return false; - } - return normalizeVersion(v1).equals(normalizeVersion(v2)); - } - - /** - * return true if v1 greater than v2 - * - * @param v1 - * @param v2 - * @return - */ - public static boolean versionGreaterThan(String v1, String v2) { - if (v1 != null && v2 == null) { - return true; - } - if (v1 == null) { - return false; - } - String[] v1s = normalizeVersion(v1).split("\\."); - String[] v2s = normalizeVersion(v2).split("\\."); - int minlen = Math.min(v1s.length, v2s.length); - for (int i = 0; i < minlen; i++) { - if (!v1s[i].equals(v2s[i])) { - return Integer.parseInt(v1s[i]) > Integer.parseInt(v2s[i]); - } - } - // si on est ici c que tout les nombres sont v1[i] = v2[i] - return v1s.length > v2s.length; - } - - /** - * increment minor version. - * - * @param version - * version as 3.1 where 1 is minor and 3 major - * @return incremented minor number (3.1 -> 3.2) - */ - static public String incrementMinorRevision(String v) { - String result; - - if (v == null || "".equals(v)) { - result = "0.1"; - } else { - v = v.trim(); - String[] mm = v.split("\\."); - if (mm.length == 1) { - result = v + ".1"; - } else { - int i = Integer.parseInt(mm[1]) + 1; - result = mm[0] + "." + i; - } - } - return result; - } - - /** - * increment major version. - * - * @param version - * version as 3.2 where 2 is minor and 3 major - * @return incremented major number and reset minor number (3.2 -> 4.0) - */ - static public String incrementMajorRevision(String v) { - String result; - - if (v == null || "".equals(v)) { - result = "1.0"; - } else { - v = v.trim(); - String[] mm = v.split("\\."); - int i = Integer.parseInt(mm[0]) + 1; - result = i + ".0"; - } - return result; - } - - // /** - // * - // * @param value null and empty string are casted to '0' int value. - // * @throws WikittyException on NumberFormatException or if value object - // can't be casted to int. - // */ - // static public int toInt(Object value) throws WikittyException { - // int result = 0; - // if (value == null || value.equals("") ) { - // result = 0; // default to 0 - // } else if (value instanceof Number) { - // result = ((Number) value).intValue(); - // } else { - // // try to convert to int - // try { - // result = Integer.parseInt(value.toString()); - // } catch (NumberFormatException eee) { - // throw new WikittyException(String.format( - // "Can't convert value '%s' to int", getClass(value)), eee); - // } - // } - // return result; - // } - // - // static public float toFloat(Object value) throws WikittyException { - // float result = 0; - // if (value == null) { - // result = 0; // default to 0 - // } else if (value instanceof Number) { - // result = ((Number) value).floatValue(); - // } else { - // // try to convert to float - // try { - // result = Float.parseFloat(value.toString()); - // } catch (NumberFormatException eee) { - // throw new WikittyException(String.format( - // "Can't convert value '%s' to float", getClass(value)), eee); - // } - // } - // return result; - // } - - /** - * - * @param value - * null and empty string are casted to '0' value. - * @throws WikittyException - * on NumberFormatException or if value object can't be casted - * to number. - */ - static public BigDecimal toBigDecimal(Object value) { - BigDecimal result = null; - if (value == null) { - result = new BigDecimal(0); // default to 0 - } else if (value instanceof BigDecimal) { - result = (BigDecimal) value; - } else { - try { - result = new BigDecimal(value.toString()); - } catch (NumberFormatException eee) { - throw new WikittyException( - String.format("Can't convert value '%s' to numeric", - getClass(value)), eee); - } - } - return result; - } - - /** - * Convert object to boolean: - null => false - 0 => false - numeric => true - * - object.toString() == false => false - other => true - * - * @param value - * @return - */ - static public boolean toBoolean(Object value) { - boolean result = false; - if (value != null) { - if (value instanceof Boolean) { - result = (Boolean) value; - } else if (value instanceof Number) { - result = !((Number) value).equals(0); - } else { - // try to convert to Boolean - result = !"false".equalsIgnoreCase(value.toString()); - } - } - return result; - } - - static public String toString(Object value) { - String result = null; - if (value != null) { - if (value instanceof String) { - result = (String) value; - } else if (value instanceof Wikitty) { - result = ((Wikitty) value).getId(); - } else if (value instanceof BusinessEntity) { - result = ((BusinessEntity) value).getWikittyId(); - } else if (value instanceof Date) { - result = solrDateFormat.format((Date) value); - } else { - // try to convert to String - result = value.toString(); - } - } - return result; - } - - static public Date toDate(Object value) { - Date result = null; - if (value != null) { - if (value instanceof Date) { - result = (Date) value; - } else { - // try to convert to Date - try { - result = solrDateFormat.parse(value.toString()); - } catch (ParseException eee) { - log.debug("Can't parse date, i try with next parser", eee); - } - - if (result == null) { - throw new WikittyException(String.format( - "Can't convert value '%s' of type '%s' to Date", - value, getClass(value))); - } - } - } - return result; - } - - /** - * return wikitty id and not wikitty objet because this method can be call - * on server or client side and it's better to keep conversion between id - * and objet to the caller - * - * @param value - * @return id of wikitty object or null - * @throws org.sharengo.wikitty.WikittyException - */ - static public String toWikitty(Object value) { - String result = null; - if (value != null) { - if (value instanceof String) { - result = (String) value; - } else if (value instanceof Wikitty) { - result = ((Wikitty) value).getId(); - } else if (value instanceof BusinessEntity) { - result = ((BusinessEntity) value).getWikittyId(); - } else { - // try to convert to String - result = value.toString(); - } - } - return result; - } - - /** - * - * @param <E> - * @param clazz - * @return unmodifiable list - */ - static public <E> List<E> toList(Object value, Class<E> clazz) { - try { - List<E> result = (List<E>) value; - if (result != null) { - result = Collections.unmodifiableList(result); - } - return result; - } catch (Exception eee) { - throw new WikittyException(String.format( - "Can't convert value '%s' to list", getClass(value)), eee); - } - } - - /** - * Convert object o for indexation - * - * @param field - * field description - * @param o - * field value - * @return solr representation - */ - static public String toString(FieldType field, Object o) { - String result = null; - if (o != null) { - switch (field.getType()) { - case DATE: - // Date date = (Date)o; - result = (o instanceof String) ? (String) o - : WikittyUtil.solrDateFormat.format((Date) o); - break; - default: - result = WikittyUtil.toString(o); - break; - } - } - return result; - } - - - /** - * convert string field representation to correct value type - * - * @param field - * field description - * @param s - * string value - * @return object in type of field - */ - static public Object fromString(FieldType field, String s) { - Object result = null; - switch (field.getType()) { - case BOOLEAN: - result = WikittyUtil.toBoolean(s); - break; - case DATE: - result = WikittyUtil.toDate(s); - break; - case NUMERIC: - result = WikittyUtil.toBigDecimal(s); - break; - default: - result = s; - break; - } - return result; - } - - /** - * return class of argument, if argument is null, return null - * - * @param value - * @return class of value or null - */ - static public Class getClass(Object value) { - Class result = null; - if (value != null) { - result = value.getClass(); - } - return result; - } - - /** - * Create new instance of WikittyDto without Wikitty object passed in - * argument. If arguement is Interface try to add 'Impl' to find - * instanciable class. - * <p> - * clazz parameter must be child of WikittyDto or business interface - * - * @param clazz - * class of the new instance - * @return - */ - static public <E extends BusinessEntity> E newInstance(Class<E> clazz) { - try { - Class clazzInstanciable = clazz; - if (clazzInstanciable.isInterface()) { - log - .debug(String - .format( - "Argument '%s' is interface looking for implementation", - clazzInstanciable.getName())); - // looking for implementation of this interface - if (interfaceToClass.containsKey(clazz)) { - clazzInstanciable = interfaceToClass.get(clazz); - } else { - // default use xxxImpl.class - clazzInstanciable = clazz.forName(clazz.getName() + "Impl"); - } - } - - if (!BusinessEntityWikitty.class - .isAssignableFrom(clazzInstanciable)) { - throw new WikittyException(String.format( - "Your class '%s' don't extends WikittyDto", clazz - .getName())); - } - - E result = (E) clazzInstanciable.newInstance(); - return result; - - } catch (Exception eee) { - throw new WikittyException(eee); - } - } - - /** - * Create new instance of WikittyDto with Wikitty object passed in argument. - * If arguement is Interface try to add 'Impl' to find instanciable class. - * <p> - * clazz parameter must be child of WikittyDto or business interface - * - * @param clazz - * class of the new instance - * @param w - * wikitty object to use internaly for in new instance - * @return - */ - // E extends BeanDto to permit business interface as parameter - static public <E extends BusinessEntity> E newInstance( - WikittyService wikittyService, Class<E> clazz, Wikitty w) { - try { - Class clazzInstanciable = clazz; - if (clazzInstanciable.isInterface()) { - log - .debug(String - .format( - "Argument '%s' is interface looking for implementation", - clazzInstanciable.getName())); - // looking for implementation of this interface - if (interfaceToClass.containsKey(clazz)) { - clazzInstanciable = interfaceToClass.get(clazz); - } else { - // default use xxxImpl.class - clazzInstanciable = clazz.forName(clazz.getName() + "Impl"); - } - } - - if (!BusinessEntityWikitty.class - .isAssignableFrom(clazzInstanciable)) { - throw new WikittyException(String.format( - "Your class '%s' don't extends WikittyDto", clazz - .getName())); - } - - E result = null; - if (w != null) { - try { - // try to find constructor with wikitty argument - Constructor cons = clazzInstanciable - .getConstructor(Wikitty.class); - Object[] parms = { null }; - result = (E) cons.newInstance(parms); - - BusinessEntityWikitty bean = (BusinessEntityWikitty) result; - checkExtensionVersion(wikittyService, w, bean); - bean.setWikitty(w); - - } catch (NoSuchMethodException noerror) { - log.debug(String.format( - "Can't find constructor with wikitty arguement in '%s'," - + "we try with setWikitty method", - clazzInstanciable.getName()), noerror); - } - } - - return result; - } catch (Exception eee) { - throw new WikittyException(eee); - } - } - - /** - * Check extension default, i.e. if bean contain a extension with a great - * version as in wikitty. In this case the extension is stored in last - * version and wikitty it is restored again. The upgrade data is during the - * restoration. - * - * @param wikittyService - * @param wikitty - * @param entity - * @return - */ - static public Wikitty checkExtensionVersion(WikittyService wikittyService, - Wikitty wikitty, BusinessEntityWikitty entity) { - - Wikitty result = wikitty; - boolean upgradeData = false; - - Collection<WikittyExtension> extensions = entity.getStaticExtensions(); - for (WikittyExtension ext : extensions) { - - String extName = ext.getName(); - if (wikitty.hasExtension(extName)) { - - WikittyExtension oldExt = wikitty.getExtension(extName); - String newVersion = ext.getVersion(); - String oldVersion = oldExt.getVersion(); - - if (WikittyUtil.versionGreaterThan(newVersion, oldVersion)) { - wikittyService.storeExtension(Arrays.asList(ext)); - upgradeData = true; - } - } - } - - if (upgradeData) { - String wikittyId = wikitty.getId(); - result = wikittyService.restore(wikittyId); - } - - return result; - } - - /** - * Try to cast obj to class passed in arguement - * - * @param obj - * object to cast - * @param clazz - * new type of object - * @return the same object but casted to class wanted, except for primitif - * where is new object if obj BigDecimal - */ - public static <E> E cast(Object obj, Class<E> clazz) { - E result = null; - if (obj != null) { - if (clazz.isAssignableFrom(obj.getClass())) { - result = clazz.cast(obj); - } else if (obj instanceof BigDecimal) { - BigDecimal bd = (BigDecimal) obj; - if (clazz == int.class || clazz == Integer.class) { - result = clazz.cast(bd.intValue()); - } else if (clazz == float.class || clazz == Float.class) { - result = clazz.cast(bd.floatValue()); - } - } - if (result == null) { - throw new WikittyException("Unable to cast from '" - + obj.getClass().getName() + "' to " + clazz.getName()); - } - } - return result; - } - - public static Wikitty beanToWikitty(BusinessEntity bean) { - Wikitty result; - if (bean instanceof BusinessEntityWikitty) { - BusinessEntityWikitty b = (BusinessEntityWikitty) bean; - result = b.getWikitty(); - } else if (bean instanceof BusinessEntityBean) { - BusinessEntityBean b = (BusinessEntityBean) bean; - result = WikittyUtil.beanToWikitty(b); - } else { - throw new IllegalArgumentException(String.format( - "This BusinessEntity implementation is not supported: %s", - bean.getClass().getName())); - } - return result; - } - - public static Wikitty beanToWikitty(BusinessEntityBean bean) { - try { - // TODO poussin 20090910 for now, we force version change, but it's - // better if we modify version in bean we field is set - Wikitty result = new Wikitty(bean.getWikittyId()); - // prevent BusinessEntity with null id (during store call for - // creation) - bean.id = result.id; - result.version = bean.getWikittyVersion(); - - // add execution defined extension in wikitty - for (String extName : bean.getExtensionNames()) { - for (String fieldName : bean.getExtensionFields(extName)) { - Object value = bean.getField(extName, fieldName); - result.setField(extName, fieldName, value); - } - } - - // add development time defined extension in wikitty - Field[] fields = bean.getClass().getFields(); - for (Field field : fields) { - Object value = field.get(bean); - String fqfieldName = field.getName(); - // fieldName use $ as separator between extension name and field - // name - fqfieldName = fqfieldName.replace('$', '.'); - result.setFqField(fqfieldName, value); - } - return result; - } catch (Exception eee) { - throw new WikittyException(eee); - } - } - - public static <E extends BusinessEntityBean, F extends BusinessEntityWikitty> E wikittyToBean( - Class<E> clazz, F dto) { - E result = wikittyToBean(clazz, dto.getWikitty()); - return result; - } - - /** - * Convert WikittyDto (dto that encapsulate Wikitty) to BeanDto (dto without - * internaly wikitty) - * - * @param clazz - * target object clazz - * @param w - * source object - * @return - */ - public static <E extends BusinessEntityBean> E wikittyToBean( - Class<E> clazz, Wikitty w) { - try { - E result = clazz.newInstance(); - result.id = w.id; - result.version = w.version; - result.extensions = new LinkedHashMap<String, WikittyExtension>( - w.extensions); - - Field[] fields = clazz.getFields(); - Map<String, Field> allFields = new HashMap<String, Field>(); - for (Field field : fields) { - allFields.put(field.getName(), field); - } - - for (String extName : result.extensions.keySet()) { - WikittyExtension ext = result.extensions.get(extName); - for (String fieldName : ext.getFieldNames()) { - String key = extName + "$" + fieldName; - Field field = allFields.get(key); - if (field != null) { - Class type = field.getType(); - if (Integer.TYPE.isAssignableFrom(type)) { - int value = w.getFieldAsInt(extName, fieldName); - field.setInt(result, value); - } else if (Boolean.TYPE.isAssignableFrom(type)) { - boolean value = w.getFieldAsBoolean(extName, - fieldName); - field.setBoolean(result, value); - } else if (Date.class.isAssignableFrom(type)) { - Date value = w.getFieldAsDate(extName, fieldName); - field.set(result, value); - } else if (Double.TYPE.isAssignableFrom(type)) { - double value = w.getFieldAsDouble(extName, - fieldName); - field.setDouble(result, value); - } else if (Float.TYPE.isAssignableFrom(type)) { - float value = w.getFieldAsFloat(extName, fieldName); - field.setFloat(result, value); - } else if (List.class.isAssignableFrom(type)) { - List value = w.getFieldAsList(extName, fieldName, - clazz); - field.set(result, value); - } else if (Long.TYPE.isAssignableFrom(type)) { - long value = w.getFieldAsLong(extName, fieldName); - field.setLong(result, value); - } else if (Set.class.isAssignableFrom(type)) { - Set value = w.getFieldAsSet(extName, fieldName, - clazz); - field.set(result, value); - } else if (String.class.isAssignableFrom(type)) { - String value = w.getFieldAsString(extName, - fieldName); - field.set(result, value); - } else { - throw new WikittyException(String.format( - "Can't convert field for '%s' because" - + " unkonw field type '%s'", clazz, - field)); - } - } else { - Object value = w.getFieldAsObject(extName, fieldName); - result.setField(extName, fieldName, value); - } - } - } - - return result; - } catch (Exception eee) { - throw new WikittyException(eee); - } - } - - // private static BASE64Encoder enc = new BASE64Encoder(); - public static String genUID() { - return UUID.randomUUID().toString(); - /* - * we can gain 10 chars per ID on applying a base64 on the UID. long - * mostSignificant = uid.getMostSignificantBits(); long leastSignificant - * = uid.getLeastSignificantBits(); long current = mostSignificant; - * byte[] b = new byte[16]; for ( int i = 0; i < 16; i++ ) { b[i] = - * (byte) (current & 0xff); current = current >> 8; if ( i == 7 ) - * current = leastSignificant; } return enc.encode(b); - */ - } -} Modified: trunk/wikitty-api/src/main/uml/wikitty-api/wikitty-api.uml =================================================================== --- trunk/wikitty-api/src/main/uml/wikitty-api/wikitty-api.uml 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/main/uml/wikitty-api/wikitty-api.uml 2010-05-12 15:08:48 UTC (rev 53) @@ -1,7 +1,7 @@ <?xml version="1.0" encoding="UTF-8"?> <xmi:XMI xmi:version="2.1" xmlns:xmi="http://schema.omg.org/spec/XMI/2.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:WikittyProfile="http:///schemas/WikittyProfile/_jQsKkIwQEd6QHYJLLUbpqw/0" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" xmlns:uml="http://www.eclipse.org/uml2/2.1.0/UML" xsi:schemaLocation="http:///schemas/WikittyProfile/_jQsKkIwQEd6QHYJLLUbpqw/0 ../wikitty-profile/WikittyProfile.uml#_jQsxoYwQEd6QHYJLLUbpqw"> <uml:Model xmi:id="_qb8akM37EdqwVrslYOdUDA"> - <packagedElement xmi:type="uml:Package" xmi:id="_w8IxIM37EdqwVrslYOdUDA" name="org.sharengo.wikitty"> + <packagedElement xmi:type="uml:Package" xmi:id="_w8IxIM37EdqwVrslYOdUDA" name="org.nuiton.wikitty"> <packagedElement xmi:type="uml:Class" xmi:id="_7vSlAIygEd6AV7_7yPcuUg" name="TreeNode"> <ownedAttribute xmi:id="_I_f20IyhEd6AV7_7yPcuUg" name="name"> <type xmi:type="uml:PrimitiveType" href="pathmap://UML_LIBRARIES/UMLPrimitiveTypes.library.uml#String"/> Modified: trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/api/AbstractTestApi.java =================================================================== --- trunk/wikitty-api/src/test/java/org/sharengo/wikitty/test/api/AbstractTestApi.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/api/AbstractTestApi.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,11 +1,11 @@ -package org.sharengo.wikitty.test.api; +package org.nuiton.wikitty.test.api; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.junit.internal.runners.JUnit4ClassRunner; import org.junit.runner.RunWith; -import org.sharengo.wikitty.WikittyService; -import org.sharengo.wikitty.WikittyServiceInMemory; +import org.nuiton.wikitty.WikittyService; +import org.nuiton.wikitty.WikittyServiceInMemory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.test.context.ContextConfiguration; Modified: trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/api/CommonTest.java =================================================================== --- trunk/wikitty-api/src/test/java/org/sharengo/wikitty/test/api/CommonTest.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/api/CommonTest.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.test.api; +package org.nuiton.wikitty.test.api; import static junit.framework.Assert.assertEquals; import static junit.framework.Assert.assertFalse; @@ -19,14 +19,14 @@ import org.apache.commons.logging.LogFactory; import org.junit.Before; import org.junit.Test; -import org.sharengo.wikitty.ExtensionFactory; -import org.sharengo.wikitty.FieldType; -import org.sharengo.wikitty.Wikitty; -import org.sharengo.wikitty.WikittyException; -import org.sharengo.wikitty.WikittyExtension; -import org.sharengo.wikitty.WikittyUtil; -import org.sharengo.wikitty.FieldType.TYPE; -import org.sharengo.wikitty.test.conform.StorageTest; +import org.nuiton.wikitty.ExtensionFactory; +import org.nuiton.wikitty.FieldType; +import org.nuiton.wikitty.Wikitty; +import org.nuiton.wikitty.WikittyException; +import org.nuiton.wikitty.WikittyExtension; +import org.nuiton.wikitty.WikittyUtil; +import org.nuiton.wikitty.FieldType.TYPE; +import org.nuiton.wikitty.test.conform.StorageTest; /** * Test Wikitty, Extensions, Field and FieldType through the Wikitty Object Modified: trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/api/ExtensionFactoryTest.java =================================================================== --- trunk/wikitty-api/src/test/java/org/sharengo/wikitty/test/api/ExtensionFactoryTest.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/api/ExtensionFactoryTest.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,13 +1,13 @@ -package org.sharengo.wikitty.test.api; +package org.nuiton.wikitty.test.api; import static junit.framework.Assert.assertEquals; import static junit.framework.Assert.assertNotNull; import org.junit.Test; -import org.sharengo.wikitty.ExtensionFactory; -import org.sharengo.wikitty.FieldType; -import org.sharengo.wikitty.WikittyExtension; -import org.sharengo.wikitty.FieldType.TYPE; +import org.nuiton.wikitty.ExtensionFactory; +import org.nuiton.wikitty.FieldType; +import org.nuiton.wikitty.WikittyExtension; +import org.nuiton.wikitty.FieldType.TYPE; public class ExtensionFactoryTest extends AbstractTestApi { Modified: trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/api/SearchCriteriaTest.java =================================================================== --- trunk/wikitty-api/src/test/java/org/sharengo/wikitty/test/api/SearchCriteriaTest.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/api/SearchCriteriaTest.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.test.api; +package org.nuiton.wikitty.test.api; import static junit.framework.Assert.assertEquals; import static junit.framework.Assert.assertNotNull; @@ -7,16 +7,16 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.junit.Test; -import org.sharengo.wikitty.Criteria; -import org.sharengo.wikitty.search.And; -import org.sharengo.wikitty.search.AssociatedRestriction; -import org.sharengo.wikitty.search.Between; -import org.sharengo.wikitty.search.BinaryOperator; -import org.sharengo.wikitty.search.Equals; -import org.sharengo.wikitty.search.Or; -import org.sharengo.wikitty.search.Restriction; -import org.sharengo.wikitty.search.RestrictionName; -import org.sharengo.wikitty.search.Search; +import org.nuiton.wikitty.Criteria; +import org.nuiton.wikitty.search.And; +import org.nuiton.wikitty.search.AssociatedRestriction; +import org.nuiton.wikitty.search.Between; +import org.nuiton.wikitty.search.BinaryOperator; +import org.nuiton.wikitty.search.Equals; +import org.nuiton.wikitty.search.Or; +import org.nuiton.wikitty.search.Restriction; +import org.nuiton.wikitty.search.RestrictionName; +import org.nuiton.wikitty.search.Search; public class SearchCriteriaTest extends AbstractTestApi { Modified: trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/api/WikittyUtilTest.java =================================================================== --- trunk/wikitty-api/src/test/java/org/sharengo/wikitty/test/api/WikittyUtilTest.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/api/WikittyUtilTest.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,7 +15,7 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. */ -package org.sharengo.wikitty.test.api; +package org.nuiton.wikitty.test.api; import static junit.framework.Assert.assertEquals; import static junit.framework.Assert.assertNotNull; @@ -29,14 +29,14 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.junit.Test; -import org.sharengo.wikitty.AbstractWikittyService; -import org.sharengo.wikitty.LabelBean; -import org.sharengo.wikitty.TreeNodeImpl; -import org.sharengo.wikitty.FieldType; -import org.sharengo.wikitty.Label; -import org.sharengo.wikitty.TreeNode; -import org.sharengo.wikitty.WikittyExtension; -import org.sharengo.wikitty.WikittyUtil; +import org.nuiton.wikitty.AbstractWikittyService; +import org.nuiton.wikitty.FieldType; +import org.nuiton.wikitty.WikittyExtension; +import org.nuiton.wikitty.WikittyUtil; +import org.nuiton.wikitty.LabelBean; +import org.nuiton.wikitty.TreeNodeImpl; +import org.nuiton.wikitty.Label; +import org.nuiton.wikitty.TreeNode; /** * Modified: trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/conform/AbstractTestConformance.java =================================================================== --- trunk/wikitty-api/src/test/java/org/sharengo/wikitty/test/conform/AbstractTestConformance.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/conform/AbstractTestConformance.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.test.conform; +package org.nuiton.wikitty.test.conform; import java.text.ParseException; import java.text.SimpleDateFormat; @@ -12,12 +12,12 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.junit.runner.RunWith; -import org.sharengo.wikitty.FieldType; -import org.sharengo.wikitty.Wikitty; -import org.sharengo.wikitty.WikittyExtension; -import org.sharengo.wikitty.WikittyService; -import org.sharengo.wikitty.WikittyUtil; -import org.sharengo.wikitty.FieldType.TYPE; +import org.nuiton.wikitty.FieldType; +import org.nuiton.wikitty.Wikitty; +import org.nuiton.wikitty.WikittyExtension; +import org.nuiton.wikitty.WikittyService; +import org.nuiton.wikitty.WikittyUtil; +import org.nuiton.wikitty.FieldType.TYPE; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; Modified: trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/conform/ImportExportTest.java =================================================================== --- trunk/wikitty-api/src/test/java/org/sharengo/wikitty/test/conform/ImportExportTest.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/conform/ImportExportTest.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.test.conform; +package org.nuiton.wikitty.test.conform; import static junit.framework.Assert.assertEquals; import static junit.framework.Assert.assertNotNull; @@ -17,10 +17,10 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.junit.Test; -import org.sharengo.wikitty.Criteria; -import org.sharengo.wikitty.Wikitty; -import org.sharengo.wikitty.search.Element; -import org.sharengo.wikitty.search.Search; +import org.nuiton.wikitty.Criteria; +import org.nuiton.wikitty.Wikitty; +import org.nuiton.wikitty.search.Element; +import org.nuiton.wikitty.search.Search; import org.w3c.dom.Document; import org.w3c.dom.NamedNodeMap; import org.w3c.dom.Node; Modified: trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/conform/PerformanceTest.java =================================================================== --- trunk/wikitty-api/src/test/java/org/sharengo/wikitty/test/conform/PerformanceTest.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/conform/PerformanceTest.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,7 +15,7 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.test.conform; +package org.nuiton.wikitty.test.conform; import java.util.ArrayList; import java.util.Collection; @@ -24,10 +24,10 @@ import org.apache.commons.logging.LogFactory; import org.junit.Test; import org.junit.runner.RunWith; -import org.sharengo.wikitty.FieldType; -import org.sharengo.wikitty.Wikitty; -import org.sharengo.wikitty.WikittyExtension; -import org.sharengo.wikitty.WikittyService; +import org.nuiton.wikitty.FieldType; +import org.nuiton.wikitty.Wikitty; +import org.nuiton.wikitty.WikittyExtension; +import org.nuiton.wikitty.WikittyService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; Modified: trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/conform/SearchTest.java =================================================================== --- trunk/wikitty-api/src/test/java/org/sharengo/wikitty/test/conform/SearchTest.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/conform/SearchTest.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.test.conform; +package org.nuiton.wikitty.test.conform; import static junit.framework.Assert.assertEquals; @@ -6,13 +6,13 @@ import java.util.List; import org.junit.Test; -import org.sharengo.wikitty.Criteria; -import org.sharengo.wikitty.ExtensionFactory; -import org.sharengo.wikitty.PagedResult; -import org.sharengo.wikitty.Wikitty; -import org.sharengo.wikitty.WikittyExtension; -import org.sharengo.wikitty.FieldType.TYPE; -import org.sharengo.wikitty.search.Search; +import org.nuiton.wikitty.Criteria; +import org.nuiton.wikitty.ExtensionFactory; +import org.nuiton.wikitty.PagedResult; +import org.nuiton.wikitty.Wikitty; +import org.nuiton.wikitty.WikittyExtension; +import org.nuiton.wikitty.FieldType.TYPE; +import org.nuiton.wikitty.search.Search; public class SearchTest extends AbstractTestConformance { Modified: trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/conform/StorageTest.java =================================================================== --- trunk/wikitty-api/src/test/java/org/sharengo/wikitty/test/conform/StorageTest.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/conform/StorageTest.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.test.conform; +package org.nuiton.wikitty.test.conform; import static junit.framework.Assert.assertEquals; import static junit.framework.Assert.assertFalse; @@ -22,18 +22,18 @@ import org.apache.commons.logging.LogFactory; import org.junit.Assert; import org.junit.Test; -import org.sharengo.wikitty.TreeNodeImpl; -import org.sharengo.wikitty.Criteria; -import org.sharengo.wikitty.PagedResult; -import org.sharengo.wikitty.Tree; -import org.sharengo.wikitty.TreeNode; -import org.sharengo.wikitty.UpdateResponse; -import org.sharengo.wikitty.Wikitty; -import org.sharengo.wikitty.WikittyException; -import org.sharengo.wikitty.WikittyExtension; -import org.sharengo.wikitty.WikittyService; -import org.sharengo.wikitty.WikittyUtil; -import org.sharengo.wikitty.search.Search; +import org.nuiton.wikitty.Criteria; +import org.nuiton.wikitty.PagedResult; +import org.nuiton.wikitty.Tree; +import org.nuiton.wikitty.UpdateResponse; +import org.nuiton.wikitty.Wikitty; +import org.nuiton.wikitty.WikittyException; +import org.nuiton.wikitty.WikittyExtension; +import org.nuiton.wikitty.WikittyService; +import org.nuiton.wikitty.WikittyUtil; +import org.nuiton.wikitty.search.Search; +import org.nuiton.wikitty.TreeNodeImpl; +import org.nuiton.wikitty.TreeNode; public class StorageTest extends AbstractTestConformance { Modified: trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/memory/InMemoryStorageTest.java =================================================================== --- trunk/wikitty-api/src/test/java/org/sharengo/wikitty/test/memory/InMemoryStorageTest.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-api/src/test/java/org/nuiton/wikitty/test/memory/InMemoryStorageTest.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.test.memory; +package org.nuiton.wikitty.test.memory; import static junit.framework.Assert.assertEquals; import static junit.framework.Assert.assertTrue; @@ -14,16 +14,16 @@ import org.junit.Before; import org.junit.Test; -import org.sharengo.wikitty.Criteria; -import org.sharengo.wikitty.ExtensionFactory; -import org.sharengo.wikitty.PagedResult; -import org.sharengo.wikitty.Wikitty; -import org.sharengo.wikitty.WikittyExtension; -import org.sharengo.wikitty.WikittyServiceInMemory; -import org.sharengo.wikitty.WikittyUtil; -import org.sharengo.wikitty.FieldType.TYPE; -import org.sharengo.wikitty.search.Search; -import org.sharengo.wikitty.test.api.AbstractTestApi; +import org.nuiton.wikitty.Criteria; +import org.nuiton.wikitty.ExtensionFactory; +import org.nuiton.wikitty.PagedResult; +import org.nuiton.wikitty.Wikitty; +import org.nuiton.wikitty.WikittyExtension; +import org.nuiton.wikitty.WikittyServiceInMemory; +import org.nuiton.wikitty.WikittyUtil; +import org.nuiton.wikitty.FieldType.TYPE; +import org.nuiton.wikitty.search.Search; +import org.nuiton.wikitty.test.api.AbstractTestApi; public class InMemoryStorageTest extends AbstractTestApi { Modified: trunk/wikitty-api/src/test/resources/META-INF/spring/wikitty-test.xml =================================================================== --- trunk/wikitty-api/src/test/resources/META-INF/spring/wikitty-test.xml 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/test/resources/META-INF/spring/wikitty-test.xml 2010-05-12 15:08:48 UTC (rev 53) @@ -7,9 +7,9 @@ http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd"> - <bean id="wikittyService" class="org.sharengo.wikitty.WikittyServiceInMemory" /> + <bean id="wikittyService" class="org.nuiton.wikitty.WikittyServiceInMemory" /> <context:annotation-config/> - <context:component-scan base-package="org.sharengo.wikitty"/> + <context:component-scan base-package="org.nuiton.wikitty"/> </beans> \ No newline at end of file Modified: trunk/wikitty-api/src/test/resources/log4j.properties =================================================================== --- trunk/wikitty-api/src/test/resources/log4j.properties 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-api/src/test/resources/log4j.properties 2010-05-12 15:08:48 UTC (rev 53) @@ -5,4 +5,4 @@ # Configuration by components log4j.rootLogger=ERROR, logConsole -log4j.category.org.sharengo.wikitty=DEBUG +log4j.category.org.nuiton.wikitty=DEBUG Deleted: trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/BusinessEntityBeanGenerator.java =================================================================== --- trunk/wikitty-generators/src/main/java/org/sharengo/wikitty/generator/BusinessEntityBeanGenerator.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/BusinessEntityBeanGenerator.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,307 +0,0 @@ -package org.sharengo.wikitty.generator; - -import java.beans.PropertyChangeListener; -import java.beans.PropertyChangeSupport; -import java.io.File; -import java.io.IOException; -import java.io.Serializable; -import java.io.Writer; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.HashSet; -import java.util.List; -import java.util.Set; - -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; -import org.nuiton.eugene.GeneratorUtil; -import org.nuiton.eugene.models.object.ObjectModelAttribute; -import org.nuiton.eugene.models.object.ObjectModelClass; - -/** - * Generate pure Bean Object (no wikitty object internaly stored) - * - * @author poussin - */ -public class BusinessEntityBeanGenerator extends WikengoCommonGenerator { - - private static final Log log = LogFactory.getLog(BusinessEntityBeanGenerator.class); - - protected String EXT_NAME; - - /** - * A flag to generate on setter a propertyChangeEvent. - */ - protected Boolean generatePropertyChangeListener; - - @Override - public String getFilenameForClass(ObjectModelClass clazz) { - String fqn = clazz.getQualifiedName(); - log.info( "Filename for " + clazz.getName() + " is " + fqn.replace('.', File.separatorChar) + ".java"); - return fqn.replace('.', File.separatorChar) + "Bean.java"; - } - - public void generateFromClass(Writer output, ObjectModelClass clazz) - throws IOException { - if (!EugengoUtils.isBusinessEntity(clazz)) { - log.info( clazz.getName() + " is not a business entity"); - return; - } - - log.info("Generate Bean Business entity " + clazz.getName() + "... "); - String genPCS = EugengoUtils.findTagValue("generatePropertyChangeListener",clazz,model); - generatePropertyChangeListener = genPCS != null && "true".equals(genPCS.trim()); - - generateCopyright(output); - - String packageName = clazz.getPackageName(); - String name = clazz.getName() + "Bean"; -/*{package <%=packageName%>; - -}*/ - ObjectModelClass superClass = findSuperClass(clazz); - - clearImports(); - addImport(clazz); - addImport(superClass); - addImport("org.sharengo.wikitty.BusinessEntityBean"); - String parentBean = null; - for (ObjectModelClass parent : clazz.getSuperclasses()) { - if (EugengoUtils.isBusinessEntity(parent)) { - addImport(parent); - parentBean = parent.getQualifiedName() + "Bean"; - addImport( parentBean ); - } - } - if (generatePropertyChangeListener) { - addImport(PropertyChangeSupport.class.getName()); - addImport(PropertyChangeListener.class.getName()); - } - lookForAttributeImports(clazz); - generateImports(output, packageName); - - generateClazzDocumentation(output, clazz); - String extendsString = " extends " + ( parentBean != null ? parentBean : getType("org.sharengo.wikitty.BusinessEntityBean") ); - String abstractString = ""; - if (clazz.isAbstract()) { - abstractString += "abstract "; - } - - String implementsString = "implements " + getType(clazz.getQualifiedName()); - for (ObjectModelClass parent : clazz.getSuperclasses()) { - if (EugengoUtils.isBusinessEntity(parent)) { - implementsString += ", " + getType(parent.getQualifiedName()); - } - } - -/*{public <%=abstractString%>class <%=name%><%=extendsString%> <%=implementsString%> { - -}*/ - - String svUID = GeneratorUtil.computeSerialVersionUID(clazz); -/*{ private static final long serialVersionUID = <%=svUID%>; - - public <%=name%>() { - super(); - } - -}*/ - if (generatePropertyChangeListener) { - -/*{ protected transient PropertyChangeSupport propertyChange = new PropertyChangeSupport(this); - - public void addPropertyChangeListener(PropertyChangeListener listener) { - propertyChange.addPropertyChangeListener(listener); - } - - public void removePropertyChangeListener(PropertyChangeListener listener) { - propertyChange.removePropertyChangeListener(listener); - } - - public void addPropertyChangeListener(String propertyName,PropertyChangeListener listener) { - propertyChange.addPropertyChangeListener(propertyName, listener); - } - - public void removePropertyChangeListener(String propertyName,PropertyChangeListener listener) { - propertyChange.removePropertyChangeListener(propertyName, listener); - } - -}*/ - } - generateFieldAndMethod(output, clazz); - -/*{ -} //<%=name%> -}*/ - - } - - - - // Utilitarian methods - - private void generateFieldAndMethod(Writer output, - ObjectModelClass clazz) throws IOException { - generateWikittyField(output, clazz); - generateAttributeAccessMethod(output, clazz); - - // we must generate method for parent of parent - for (ObjectModelClass parent : clazz.getSuperclasses()) { - if (EugengoUtils.isBusinessEntity(parent)) { - generateFieldAndMethod(output, parent); - } - } - - } - - - private void generateWikittyField(Writer output, - ObjectModelClass clazz) throws IOException { - - for (ObjectModelAttribute attr : clazz.getAttributes()) { - if (attr.isNavigable() && !attr.isStatic() && - (attr.getStereotypes() == null || attr.getStereotypes().isEmpty())) { - generateAttribute(output, attr); - } - } - } - - private void generateAttributeAccessMethod(Writer output, ObjectModelClass clazz) throws IOException { - for (ObjectModelAttribute attr : clazz.getAttributes()) { - if (attr.isNavigable() && !attr.isStatic() - && (attr.getStereotypes() == null || attr.getStereotypes().isEmpty())) { - if ((attr.getMaxMultiplicity() != 0 && attr.getMaxMultiplicity() != 1)) { - //TODO ymartel 20090812: when dataType "List", "Set" or "Collection" in model, must be here! - generateCollectionAttributeAccessors(output, attr); - } else { - generateWikittyAttributeAccessors(output, attr); - } - } - } - } - - private void generateAttribute(Writer output, ObjectModelAttribute attr) - throws IOException { - EXT_NAME = attr.getDeclaringElement().getName(); - - String attrType = computeType(attr); - if (EugengoUtils.notEmpty(attrType)) { - attrType = getType(attrType, true); - } else { - return; - } - - String attrName = EXT_NAME + "$" + attr.getName(); -/*{ public <%=attrType%> <%=attrName%>; - -}*/ - } - - private void generateWikittyAttributeAccessors(Writer output, - ObjectModelAttribute attr) throws IOException { - - EXT_NAME = attr.getDeclaringElement().getName(); - - String attrType = computeType(attr); - if (EugengoUtils.notEmpty(attrType)) { - attrType = getType(attrType, true); - } else { - return; - } - - String simpleAttrName = attr.getName(); - String attrNameCapitalized = EugengoUtils.toUpperCaseFirstLetter(simpleAttrName); - String attrName = EXT_NAME + "$" + simpleAttrName; - String genPCS = ""; - if(!generatePropertyChangeListener) { - genPCS = "//"; - } - -/*{ - public void set<%=attrNameCapitalized%>(<%=attrType%> value) { - <%=genPCS%>Object oldValue = <%=attrName%>; - this.<%=attrName%> = value; - <%=genPCS%>propertyChange.firePropertyChange("<%=simpleAttrName%>", oldValue, value); - } - - public <%=attrType%> get<%=attrNameCapitalized%>() { - return <%=attrName%>; - } - -}*/ - } - - private void generateCollectionAttributeAccessors(Writer output, - ObjectModelAttribute attr) throws IOException { - - EXT_NAME = attr.getDeclaringElement().getName(); - - String attrType = computeType(attr); - if (EugengoUtils.notEmpty(attrType)) { - attrType = getType(attrType, true); - } else { - return; - } - - // get collection element type for add and remove method arguement type - String elementType = getType(attr.getType(), true); - - String simpleAttrName = attr.getName(); - String attrNameCapitalized = EugengoUtils.toUpperCaseFirstLetter(simpleAttrName ); - String attrName = EXT_NAME + "$" + simpleAttrName; - String genPCS = ""; - if(!generatePropertyChangeListener) { - genPCS = "//"; - } - -/*{ public <%=attrType%> get<%=attrNameCapitalized%>() { - return <%=attrName%>; - } - - public void add<%=attrNameCapitalized%>(<%=elementType%> element) { - <%=attrName%>.add(element); - <%=genPCS%>propertyChange.firePropertyChange("<%=simpleAttrName%>", null, <%=attrName%>); - } - - public void remove<%=attrNameCapitalized%>(<%=elementType%> element) { - <%=attrName%>.remove(element); - <%=genPCS%>propertyChange.firePropertyChange("<%=simpleAttrName%>", null, <%=attrName%>); - } - - public void clear<%=attrNameCapitalized%>() { - <%=attrName%>.clear(); - <%=genPCS%>propertyChange.firePropertyChange("<%=simpleAttrName%>", null, <%=attrName%>); - } - -}*/ - } - - private static Set<String> commonTypes; - static { - commonTypes = new HashSet<String>(); - commonTypes.add("byte"); - commonTypes.add("Byte"); - commonTypes.add("short"); - commonTypes.add("Short"); - commonTypes.add("int"); - commonTypes.add("Integer"); - commonTypes.add("long"); - commonTypes.add("Long"); - commonTypes.add("float"); - commonTypes.add("Float"); - commonTypes.add("double"); - commonTypes.add("Double"); - - commonTypes.add("char"); - commonTypes.add("Char"); - - commonTypes.add("boolean"); - commonTypes.add("Boolean"); - - commonTypes.add("Date"); - commonTypes.add("String"); - } - -} Copied: trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/BusinessEntityBeanGenerator.java (from rev 52, trunk/wikitty-generators/src/main/java/org/sharengo/wikitty/generator/BusinessEntityBeanGenerator.java) =================================================================== --- trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/BusinessEntityBeanGenerator.java (rev 0) +++ trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/BusinessEntityBeanGenerator.java 2010-05-12 15:08:48 UTC (rev 53) @@ -0,0 +1,314 @@ +package org.nuiton.wikitty.generator; + +import java.beans.PropertyChangeListener; +import java.beans.PropertyChangeSupport; +import java.io.File; +import java.io.IOException; +import java.io.Serializable; +import java.io.Writer; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.nuiton.eugene.GeneratorUtil; +import org.nuiton.eugene.models.object.ObjectModelAttribute; +import org.nuiton.eugene.models.object.ObjectModelClass; + +/** + * Generate pure Bean Object (no wikitty object internaly stored) + * + * @author poussin + * + * @deprecated since 2.0 will be removed soon + */ +@Deprecated +public class BusinessEntityBeanGenerator extends WikengoCommonGenerator { + + private static final Log log = LogFactory.getLog(BusinessEntityBeanGenerator.class); + + protected String EXT_NAME; + + /** + * A flag to generate on setter a propertyChangeEvent. + */ + protected Boolean generatePropertyChangeListener; + + @Override + public String getFilenameForClass(ObjectModelClass clazz) { + String fqn = clazz.getQualifiedName(); + log.info( "Filename for " + clazz.getName() + " is " + fqn.replace('.', File.separatorChar) + ".java"); + return fqn.replace('.', File.separatorChar) + "Bean.java"; + } + + public void generateFromClass(Writer output, ObjectModelClass clazz) + throws IOException { + if (!EugengoUtils.isBusinessEntity(clazz)) { + log.info( clazz.getName() + " is not a business entity"); + return; + } + + log.info("Generate Bean Business entity " + clazz.getName() + "... "); + String genPCS = EugengoUtils.findTagValue("generatePropertyChangeListener",clazz,model); + generatePropertyChangeListener = genPCS != null && "true".equals(genPCS.trim()); + + generateCopyright(output); + + String packageName = clazz.getPackageName(); + String name = clazz.getName() + "Bean"; +/*{package <%=packageName%>; + +}*/ + ObjectModelClass superClass = findSuperClass(clazz); + + clearImports(); + addImport(clazz); + addImport(superClass); + addImport("org.nuiton.wikitty.BusinessEntityBean"); + String parentBean = null; + for (ObjectModelClass parent : clazz.getSuperclasses()) { + if (EugengoUtils.isBusinessEntity(parent)) { + addImport(parent); + parentBean = parent.getQualifiedName() + "Bean"; + addImport( parentBean ); + } + } + if (generatePropertyChangeListener) { + addImport(PropertyChangeSupport.class.getName()); + addImport(PropertyChangeListener.class.getName()); + } + lookForAttributeImports(clazz); + generateImports(output, packageName); + + generateClazzDocumentation(output, clazz); + String extendsString = " extends " + ( parentBean != null ? parentBean : getType("org.nuiton.wikitty.BusinessEntityBean") ); + String abstractString = ""; + if (clazz.isAbstract()) { + abstractString += "abstract "; + } + + String implementsString = "implements " + getType(clazz.getQualifiedName()); + for (ObjectModelClass parent : clazz.getSuperclasses()) { + if (EugengoUtils.isBusinessEntity(parent)) { + implementsString += ", " + getType(parent.getQualifiedName()); + } + } + +/*{/** + * @deprecated since 2.0 will be removed soon + *) +@Deprecated +public <%=abstractString%>class <%=name%><%=extendsString%> <%=implementsString%> { + +}*/ + + String svUID = GeneratorUtil.computeSerialVersionUID(clazz); +/*{ private static final long serialVersionUID = <%=svUID%>; + + public <%=name%>() { + super(); + } + +}*/ + if (generatePropertyChangeListener) { + +/*{ protected transient PropertyChangeSupport propertyChange = new PropertyChangeSupport(this); + + public void addPropertyChangeListener(PropertyChangeListener listener) { + propertyChange.addPropertyChangeListener(listener); + } + + public void removePropertyChangeListener(PropertyChangeListener listener) { + propertyChange.removePropertyChangeListener(listener); + } + + public void addPropertyChangeListener(String propertyName,PropertyChangeListener listener) { + propertyChange.addPropertyChangeListener(propertyName, listener); + } + + public void removePropertyChangeListener(String propertyName,PropertyChangeListener listener) { + propertyChange.removePropertyChangeListener(propertyName, listener); + } + +}*/ + } + generateFieldAndMethod(output, clazz); + +/*{ +} //<%=name%> +}*/ + + } + + + + // Utilitarian methods + + private void generateFieldAndMethod(Writer output, + ObjectModelClass clazz) throws IOException { + generateWikittyField(output, clazz); + generateAttributeAccessMethod(output, clazz); + + // we must generate method for parent of parent + for (ObjectModelClass parent : clazz.getSuperclasses()) { + if (EugengoUtils.isBusinessEntity(parent)) { + generateFieldAndMethod(output, parent); + } + } + + } + + + private void generateWikittyField(Writer output, + ObjectModelClass clazz) throws IOException { + + for (ObjectModelAttribute attr : clazz.getAttributes()) { + if (attr.isNavigable() && !attr.isStatic() && + (attr.getStereotypes() == null || attr.getStereotypes().isEmpty())) { + generateAttribute(output, attr); + } + } + } + + private void generateAttributeAccessMethod(Writer output, ObjectModelClass clazz) throws IOException { + for (ObjectModelAttribute attr : clazz.getAttributes()) { + if (attr.isNavigable() && !attr.isStatic() + && (attr.getStereotypes() == null || attr.getStereotypes().isEmpty())) { + if ((attr.getMaxMultiplicity() != 0 && attr.getMaxMultiplicity() != 1)) { + //TODO ymartel 20090812: when dataType "List", "Set" or "Collection" in model, must be here! + generateCollectionAttributeAccessors(output, attr); + } else { + generateWikittyAttributeAccessors(output, attr); + } + } + } + } + + private void generateAttribute(Writer output, ObjectModelAttribute attr) + throws IOException { + EXT_NAME = attr.getDeclaringElement().getName(); + + String attrType = computeType(attr); + if (EugengoUtils.notEmpty(attrType)) { + attrType = getType(attrType, true); + } else { + return; + } + + String attrName = EXT_NAME + "$" + attr.getName(); +/*{ public <%=attrType%> <%=attrName%>; + +}*/ + } + + private void generateWikittyAttributeAccessors(Writer output, + ObjectModelAttribute attr) throws IOException { + + EXT_NAME = attr.getDeclaringElement().getName(); + + String attrType = computeType(attr); + if (EugengoUtils.notEmpty(attrType)) { + attrType = getType(attrType, true); + } else { + return; + } + + String simpleAttrName = attr.getName(); + String attrNameCapitalized = EugengoUtils.toUpperCaseFirstLetter(simpleAttrName); + String attrName = EXT_NAME + "$" + simpleAttrName; + String genPCS = ""; + if(!generatePropertyChangeListener) { + genPCS = "//"; + } + +/*{ + public void set<%=attrNameCapitalized%>(<%=attrType%> value) { + <%=genPCS%>Object oldValue = <%=attrName%>; + this.<%=attrName%> = value; + <%=genPCS%>propertyChange.firePropertyChange("<%=simpleAttrName%>", oldValue, value); + } + + public <%=attrType%> get<%=attrNameCapitalized%>() { + return <%=attrName%>; + } + +}*/ + } + + private void generateCollectionAttributeAccessors(Writer output, + ObjectModelAttribute attr) throws IOException { + + EXT_NAME = attr.getDeclaringElement().getName(); + + String attrType = computeType(attr); + if (EugengoUtils.notEmpty(attrType)) { + attrType = getType(attrType, true); + } else { + return; + } + + // get collection element type for add and remove method arguement type + String elementType = getType(attr.getType(), true); + + String simpleAttrName = attr.getName(); + String attrNameCapitalized = EugengoUtils.toUpperCaseFirstLetter(simpleAttrName ); + String attrName = EXT_NAME + "$" + simpleAttrName; + String genPCS = ""; + if(!generatePropertyChangeListener) { + genPCS = "//"; + } + +/*{ public <%=attrType%> get<%=attrNameCapitalized%>() { + return <%=attrName%>; + } + + public void add<%=attrNameCapitalized%>(<%=elementType%> element) { + <%=attrName%>.add(element); + <%=genPCS%>propertyChange.firePropertyChange("<%=simpleAttrName%>", null, <%=attrName%>); + } + + public void remove<%=attrNameCapitalized%>(<%=elementType%> element) { + <%=attrName%>.remove(element); + <%=genPCS%>propertyChange.firePropertyChange("<%=simpleAttrName%>", null, <%=attrName%>); + } + + public void clear<%=attrNameCapitalized%>() { + <%=attrName%>.clear(); + <%=genPCS%>propertyChange.firePropertyChange("<%=simpleAttrName%>", null, <%=attrName%>); + } + +}*/ + } + + private static Set<String> commonTypes; + static { + commonTypes = new HashSet<String>(); + commonTypes.add("byte"); + commonTypes.add("Byte"); + commonTypes.add("short"); + commonTypes.add("Short"); + commonTypes.add("int"); + commonTypes.add("Integer"); + commonTypes.add("long"); + commonTypes.add("Long"); + commonTypes.add("float"); + commonTypes.add("Float"); + commonTypes.add("double"); + commonTypes.add("Double"); + + commonTypes.add("char"); + commonTypes.add("Char"); + + commonTypes.add("boolean"); + commonTypes.add("Boolean"); + + commonTypes.add("Date"); + commonTypes.add("String"); + } + +} Modified: trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/BusinessEntityGenerator.java =================================================================== --- trunk/wikitty-generators/src/main/java/org/sharengo/wikitty/generator/BusinessEntityGenerator.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/BusinessEntityGenerator.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.generator; +package org.nuiton.wikitty.generator; import java.io.File; import java.io.IOException; @@ -64,10 +64,10 @@ clearImports(); addImport(clazz); addImport(superClass); - addImport("org.sharengo.wikitty.WikittyUtil"); - addImport("org.sharengo.wikitty.Wikitty"); - addImport("org.sharengo.wikitty.BusinessEntityWikitty"); - addImport("org.sharengo.wikitty.WikittyExtension"); + addImport("org.nuiton.wikitty.WikittyUtil"); + addImport("org.nuiton.wikitty.Wikitty"); + addImport("org.nuiton.wikitty.BusinessEntityWikitty"); + addImport("org.nuiton.wikitty.WikittyExtension"); addImport(Collection.class); addImport(Collections.class); addImport(List.class); @@ -84,7 +84,7 @@ generateImports(output, packageName); generateClazzDocumentation(output, clazz); - String extendsString = " extends " + ( parentImpl != null ? parentImpl : getType("org.sharengo.wikitty.BusinessEntityWikitty") ); + String extendsString = " extends " + ( parentImpl != null ? parentImpl : getType("org.nuiton.wikitty.BusinessEntityWikitty") ); String abstractString = ""; if (clazz.isAbstract()) { abstractString += "abstract "; Modified: trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/BusinessEntityInterfaceGenerator.java =================================================================== --- trunk/wikitty-generators/src/main/java/org/sharengo/wikitty/generator/BusinessEntityInterfaceGenerator.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/BusinessEntityInterfaceGenerator.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.generator; +package org.nuiton.wikitty.generator; import java.io.File; import java.io.IOException; @@ -47,7 +47,7 @@ clearImports(); addImport(superClass); - addImport("org.sharengo.wikitty.BusinessEntity"); + addImport("org.nuiton.wikitty.BusinessEntity"); for (ObjectModelClass parent : clazz.getSuperclasses()) { if (EugengoUtils.isBusinessEntity(parent)) { @@ -57,7 +57,7 @@ lookForAttributeImports(clazz); generateImports(output, packageName); - String extendsString = "extends " + getType("org.sharengo.wikitty.BusinessEntity"); + String extendsString = "extends " + getType("org.nuiton.wikitty.BusinessEntity"); for (ObjectModelClass parent : clazz.getSuperclasses()) { if (EugengoUtils.isBusinessEntity(parent)) { extendsString += ", " + getType(parent.getName()); Modified: trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/EnumGenerator.java =================================================================== --- trunk/wikitty-generators/src/main/java/org/sharengo/wikitty/generator/EnumGenerator.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/EnumGenerator.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.generator; +package org.nuiton.wikitty.generator; import java.io.File; import java.io.IOException; Modified: trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/EugengoConstants.java =================================================================== --- trunk/wikitty-generators/src/main/java/org/sharengo/wikitty/generator/EugengoConstants.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/EugengoConstants.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.generator; +package org.nuiton.wikitty.generator; public class EugengoConstants { Modified: trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/EugengoUtils.java =================================================================== --- trunk/wikitty-generators/src/main/java/org/sharengo/wikitty/generator/EugengoUtils.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/EugengoUtils.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.generator; +package org.nuiton.wikitty.generator; import java.util.HashSet; import java.util.Set; @@ -14,7 +14,7 @@ /** * Cherches et renvoie le copyright a utiliser sur le model. * - * @param model le modele utilisé + * @param model le modele utilise * @return le texte du copyright ou null */ public static String getCopyright(Model model) { Modified: trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/InterfaceGenerator.java =================================================================== --- trunk/wikitty-generators/src/main/java/org/sharengo/wikitty/generator/InterfaceGenerator.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/InterfaceGenerator.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.generator; +package org.nuiton.wikitty.generator; import java.io.File; import java.io.IOException; Modified: trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikengoCommonGenerator.java =================================================================== --- trunk/wikitty-generators/src/main/java/org/sharengo/wikitty/generator/WikengoCommonGenerator.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikengoCommonGenerator.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.generator; +package org.nuiton.wikitty.generator; import java.io.IOException; import java.io.Writer; @@ -101,7 +101,7 @@ */ protected String getType(String fqn, boolean convert) { // if type is Wikitty then we used String - if ("org.sharengo.wikitty.Wikitty".equals(fqn) + if ("org.nuiton.wikitty.Wikitty".equals(fqn) || "Wikitty".equals(fqn)) { fqn = "String"; } else if (convert && null != getModel().getEnumeration(fqn)) { @@ -350,7 +350,7 @@ String result = param.getType(); // if type is Wikitty then we used String - if ("org.sharengo.wikitty.Wikitty".equals(result) + if ("org.nuiton.wikitty.Wikitty".equals(result) || "Wikitty".equals(result)) { result = "String"; } Modified: trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyMetaGenerator.java =================================================================== --- trunk/wikitty-generators/src/main/java/org/sharengo/wikitty/generator/WikittyMetaGenerator.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-generators/src/main/java/org/nuiton/wikitty/generator/WikittyMetaGenerator.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.generator; +package org.nuiton.wikitty.generator; import java.io.File; import java.io.IOException; Modified: trunk/wikitty-hbase-impl/src/main/java/org/nuiton/wikitty/hbase/WikittyExtensionStorageHBase.java =================================================================== --- trunk/wikitty-hbase-impl/src/main/java/org/sharengo/wikitty/hbase/WikittyExtensionStorageHBase.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-hbase-impl/src/main/java/org/nuiton/wikitty/hbase/WikittyExtensionStorageHBase.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.hbase; +package org.nuiton.wikitty.hbase; /* *##% * Copyright (c) 2009 poussin. All rights reserved. @@ -17,13 +17,13 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -import static org.sharengo.wikitty.hbase.WikittyHBaseUtil.F_ADMIN; -import static org.sharengo.wikitty.hbase.WikittyHBaseUtil.F_DATA; -import static org.sharengo.wikitty.hbase.WikittyHBaseUtil.Q_NAME; -import static org.sharengo.wikitty.hbase.WikittyHBaseUtil.Q_REQUIRES; -import static org.sharengo.wikitty.hbase.WikittyHBaseUtil.Q_TAGVALUES; -import static org.sharengo.wikitty.hbase.WikittyHBaseUtil.Q_VERSION; -import static org.sharengo.wikitty.hbase.WikittyHBaseUtil.T_EXTENSION; +import static org.nuiton.wikitty.hbase.WikittyHBaseUtil.F_ADMIN; +import static org.nuiton.wikitty.hbase.WikittyHBaseUtil.F_DATA; +import static org.nuiton.wikitty.hbase.WikittyHBaseUtil.Q_NAME; +import static org.nuiton.wikitty.hbase.WikittyHBaseUtil.Q_REQUIRES; +import static org.nuiton.wikitty.hbase.WikittyHBaseUtil.Q_TAGVALUES; +import static org.nuiton.wikitty.hbase.WikittyHBaseUtil.Q_VERSION; +import static org.nuiton.wikitty.hbase.WikittyHBaseUtil.T_EXTENSION; import java.io.IOException; import java.util.ArrayList; @@ -43,13 +43,13 @@ import org.apache.hadoop.hbase.client.Result; import org.apache.hadoop.hbase.client.ResultScanner; import org.apache.hadoop.hbase.util.Bytes; -import org.sharengo.wikitty.FieldType; -import org.sharengo.wikitty.UpdateResponse; -import org.sharengo.wikitty.WikittyException; -import org.sharengo.wikitty.WikittyExtension; -import org.sharengo.wikitty.WikittyExtensionStorage; -import org.sharengo.wikitty.WikittyTransaction; -import org.sharengo.wikitty.WikittyUtil; +import org.nuiton.wikitty.FieldType; +import org.nuiton.wikitty.UpdateResponse; +import org.nuiton.wikitty.WikittyException; +import org.nuiton.wikitty.WikittyExtension; +import org.nuiton.wikitty.WikittyExtensionStorage; +import org.nuiton.wikitty.WikittyTransaction; +import org.nuiton.wikitty.WikittyUtil; /** * Modified: trunk/wikitty-hbase-impl/src/main/java/org/nuiton/wikitty/hbase/WikittyHBaseUtil.java =================================================================== --- trunk/wikitty-hbase-impl/src/main/java/org/sharengo/wikitty/hbase/WikittyHBaseUtil.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-hbase-impl/src/main/java/org/nuiton/wikitty/hbase/WikittyHBaseUtil.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,7 +15,7 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.hbase; +package org.nuiton.wikitty.hbase; import java.io.ByteArrayInputStream; @@ -28,9 +28,9 @@ import org.apache.commons.logging.LogFactory; import org.apache.hadoop.hbase.HBaseConfiguration; import org.apache.hadoop.hbase.util.Bytes; -import org.sharengo.wikitty.FieldType; -import org.sharengo.wikitty.WikittyException; -import org.sharengo.wikitty.WikittyUtil; +import org.nuiton.wikitty.FieldType; +import org.nuiton.wikitty.WikittyException; +import org.nuiton.wikitty.WikittyUtil; /** * Modified: trunk/wikitty-hbase-impl/src/main/java/org/nuiton/wikitty/hbase/WikittyServiceHBase.java =================================================================== --- trunk/wikitty-hbase-impl/src/main/java/org/sharengo/wikitty/hbase/WikittyServiceHBase.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-hbase-impl/src/main/java/org/nuiton/wikitty/hbase/WikittyServiceHBase.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,16 +15,16 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.hbase; +package org.nuiton.wikitty.hbase; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.sharengo.wikitty.AbstractWikittyService; -import org.sharengo.wikitty.WikittyExtensionStorage; -import org.sharengo.wikitty.WikittySearchEngin; -import org.sharengo.wikitty.WikittyStorage; -import org.sharengo.wikitty.solr.WikittySearchEnginSolr; +import org.nuiton.wikitty.AbstractWikittyService; +import org.nuiton.wikitty.WikittyExtensionStorage; +import org.nuiton.wikitty.WikittySearchEngin; +import org.nuiton.wikitty.WikittyStorage; +import org.nuiton.wikitty.solr.WikittySearchEnginSolr; /** * HBase must have 2 definitions, one for extension and one for wikitty object. Modified: trunk/wikitty-hbase-impl/src/main/java/org/nuiton/wikitty/hbase/WikittyStorageHBase.java =================================================================== --- trunk/wikitty-hbase-impl/src/main/java/org/sharengo/wikitty/hbase/WikittyStorageHBase.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-hbase-impl/src/main/java/org/nuiton/wikitty/hbase/WikittyStorageHBase.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,12 +15,13 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.hbase; +package org.nuiton.wikitty.hbase; import org.apache.hadoop.hbase.client.Result; import org.apache.hadoop.hbase.client.ResultScanner; -import static org.sharengo.wikitty.hbase.WikittyHBaseUtil.*; +import static org.nuiton.wikitty.hbase.WikittyHBaseUtil.*; + import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; @@ -37,15 +38,15 @@ import org.apache.hadoop.hbase.client.Put; import org.apache.hadoop.hbase.client.Scan; import org.apache.hadoop.hbase.util.Bytes; -import org.sharengo.wikitty.FieldType; -import org.sharengo.wikitty.UpdateResponse; -import org.sharengo.wikitty.Wikitty; -import org.sharengo.wikitty.WikittyException; -import org.sharengo.wikitty.WikittyExtension; -import org.sharengo.wikitty.WikittyExtensionStorage; -import org.sharengo.wikitty.WikittyStorage; -import org.sharengo.wikitty.WikittyTransaction; -import org.sharengo.wikitty.WikittyUtil; +import org.nuiton.wikitty.FieldType; +import org.nuiton.wikitty.UpdateResponse; +import org.nuiton.wikitty.Wikitty; +import org.nuiton.wikitty.WikittyException; +import org.nuiton.wikitty.WikittyExtension; +import org.nuiton.wikitty.WikittyExtensionStorage; +import org.nuiton.wikitty.WikittyStorage; +import org.nuiton.wikitty.WikittyTransaction; +import org.nuiton.wikitty.WikittyUtil; /** * Modified: trunk/wikitty-hbase-impl/src/test/java/org/nuiton/wikitty/hbase/test/AbstractTestHbase.java =================================================================== --- trunk/wikitty-hbase-impl/src/test/java/org/sharengo/wikitty/hbase/test/AbstractTestHbase.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-hbase-impl/src/test/java/org/nuiton/wikitty/hbase/test/AbstractTestHbase.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,13 +1,13 @@ -package org.sharengo.wikitty.hbase.test; +package org.nuiton.wikitty.hbase.test; import org.junit.runner.RunWith; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import org.junit.Before; -import org.sharengo.wikitty.WikittySearchEngin; -import org.sharengo.wikitty.WikittyService; -import org.sharengo.wikitty.hbase.WikittyServiceHBase; +import org.nuiton.wikitty.WikittySearchEngin; +import org.nuiton.wikitty.WikittyService; +import org.nuiton.wikitty.hbase.WikittyServiceHBase; import org.springframework.beans.factory.annotation.Autowired; @RunWith(SpringJUnit4ClassRunner.class) Modified: trunk/wikitty-hbase-impl/src/test/java/org/nuiton/wikitty/hbase/test/HBaseConnectorTest.java =================================================================== --- trunk/wikitty-hbase-impl/src/test/java/org/sharengo/wikitty/hbase/test/HBaseConnectorTest.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-hbase-impl/src/test/java/org/nuiton/wikitty/hbase/test/HBaseConnectorTest.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.hbase.test; +package org.nuiton.wikitty.hbase.test; import static junit.framework.Assert.assertEquals; @@ -18,7 +18,7 @@ import org.apache.hadoop.hbase.util.Bytes; import org.junit.Before; import org.junit.Test; -import org.sharengo.wikitty.hbase.WikittyHBaseUtil; +import org.nuiton.wikitty.hbase.WikittyHBaseUtil; public class HBaseConnectorTest extends AbstractTestHbase { Modified: trunk/wikitty-hbase-impl/src/test/java/org/nuiton/wikitty/hbase/test/ServiceFactory.java =================================================================== --- trunk/wikitty-hbase-impl/src/test/java/org/sharengo/wikitty/hbase/test/ServiceFactory.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-hbase-impl/src/test/java/org/nuiton/wikitty/hbase/test/ServiceFactory.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,10 +1,10 @@ -package org.sharengo.wikitty.hbase.test; +package org.nuiton.wikitty.hbase.test; import java.util.Properties; import org.apache.hadoop.hbase.HConstants; -import org.sharengo.wikitty.WikittyService; -import org.sharengo.wikitty.hbase.WikittyServiceHBase; +import org.nuiton.wikitty.WikittyService; +import org.nuiton.wikitty.hbase.WikittyServiceHBase; public class ServiceFactory { Modified: trunk/wikitty-hbase-impl/src/test/java/org/nuiton/wikitty/hbase/test/StandAloneServer.java =================================================================== --- trunk/wikitty-hbase-impl/src/test/java/org/sharengo/wikitty/hbase/test/StandAloneServer.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-hbase-impl/src/test/java/org/nuiton/wikitty/hbase/test/StandAloneServer.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.hbase.test; +package org.nuiton.wikitty.hbase.test; import java.io.FileInputStream; import java.util.Properties; @@ -91,7 +91,7 @@ /* if ( "true".equals(props.getProperty(DataIhmProperty)) ) { - // new org.sharengo.wikitty.hbase.admin.HBaseAdmin( sas.conf ); // launch a visual admin + // new org.nuiton.wikitty.hbase.admin.HBaseAdmin( sas.conf ); // launch a visual admin } */ Modified: trunk/wikitty-hbase-impl/src/test/java/org/nuiton/wikitty/hbase/test/StorageHbaseTest.java =================================================================== --- trunk/wikitty-hbase-impl/src/test/java/org/sharengo/wikitty/hbase/test/StorageHbaseTest.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-hbase-impl/src/test/java/org/nuiton/wikitty/hbase/test/StorageHbaseTest.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,11 +15,11 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.hbase.test; +package org.nuiton.wikitty.hbase.test; import org.junit.Before; -import org.sharengo.wikitty.hbase.WikittyServiceHBase; -import org.sharengo.wikitty.test.conform.StorageTest; +import org.nuiton.wikitty.hbase.WikittyServiceHBase; +import org.nuiton.wikitty.test.conform.StorageTest; /** * Modified: trunk/wikitty-hbase-impl/src/test/resources/META-INF/spring/wikitty-test.xml =================================================================== --- trunk/wikitty-hbase-impl/src/test/resources/META-INF/spring/wikitty-test.xml 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-hbase-impl/src/test/resources/META-INF/spring/wikitty-test.xml 2010-05-12 15:08:48 UTC (rev 53) @@ -6,10 +6,10 @@ xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd"> - <bean name="serviceFactory" class="org.sharengo.wikitty.hbase.test.ServiceFactory" init-method="init" /> + <bean name="serviceFactory" class="org.nuiton.wikitty.hbase.test.ServiceFactory" init-method="init" /> <bean name="wikittyService" factory-bean="serviceFactory" factory-method="getService"/> <context:annotation-config/> - <context:component-scan base-package="org.sharengo.wikitty"/> + <context:component-scan base-package="org.nuiton.wikitty"/> </beans> Modified: trunk/wikitty-hbase-impl/src/test/resources/log4j.properties =================================================================== --- trunk/wikitty-hbase-impl/src/test/resources/log4j.properties 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-hbase-impl/src/test/resources/log4j.properties 2010-05-12 15:08:48 UTC (rev 53) @@ -5,5 +5,5 @@ # Configuration by components log4j.rootLogger=ERROR, logConsole -log4j.category.org.sharengo.wikitty=DEBUG +log4j.category.org.nuiton.wikitty=DEBUG #log4j.category.org.apache.solr=DEBUG Modified: trunk/wikitty-jdbc-impl/src/main/java/org/nuiton/wikitty/jdbc/WikittyExtensionStorageJDBC.java =================================================================== --- trunk/wikitty-jdbc-impl/src/main/java/org/sharengo/wikitty/jdbc/WikittyExtensionStorageJDBC.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jdbc-impl/src/main/java/org/nuiton/wikitty/jdbc/WikittyExtensionStorageJDBC.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.jdbc; +package org.nuiton.wikitty.jdbc; /* *##% * Copyright (c) 2009 morin. All rights reserved. @@ -16,28 +16,28 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.COL_FIELDTYPE; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.COL_ID; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.COL_NAME; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.COL_REQUIRES; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.COL_TAGVALUES; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.COL_VERSION; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.JDBC_DRIVER; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.QUERY_CLEAR_EXTENSION; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.QUERY_CREATION_EXTENSION_ADMIN; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.QUERY_CREATION_EXTENSION_DATA; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.QUERY_INSERT_EXTENSION_ADMIN; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.QUERY_INSERT_EXTENSION_DATA; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.QUERY_SELECT; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.QUERY_SELECT_WHERE; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.TABLE_EXTENSION_ADMIN; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.TABLE_EXTENSION_DATA; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.commitJDBCConnection; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.doQuery; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.getConnection; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.getJDBCConnection; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.loadProperties; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.rollbackJDBCConnection; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.COL_FIELDTYPE; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.COL_ID; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.COL_NAME; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.COL_REQUIRES; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.COL_TAGVALUES; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.COL_VERSION; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.JDBC_DRIVER; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.QUERY_CLEAR_EXTENSION; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.QUERY_CREATION_EXTENSION_ADMIN; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.QUERY_CREATION_EXTENSION_DATA; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.QUERY_INSERT_EXTENSION_ADMIN; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.QUERY_INSERT_EXTENSION_DATA; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.QUERY_SELECT; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.QUERY_SELECT_WHERE; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.TABLE_EXTENSION_ADMIN; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.TABLE_EXTENSION_DATA; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.commitJDBCConnection; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.doQuery; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.getConnection; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.getJDBCConnection; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.loadProperties; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.rollbackJDBCConnection; import java.sql.Connection; import java.sql.PreparedStatement; @@ -54,13 +54,13 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.sharengo.wikitty.FieldType; -import org.sharengo.wikitty.UpdateResponse; -import org.sharengo.wikitty.WikittyException; -import org.sharengo.wikitty.WikittyExtension; -import org.sharengo.wikitty.WikittyExtensionStorage; -import org.sharengo.wikitty.WikittyTransaction; -import org.sharengo.wikitty.WikittyUtil; +import org.nuiton.wikitty.FieldType; +import org.nuiton.wikitty.UpdateResponse; +import org.nuiton.wikitty.WikittyException; +import org.nuiton.wikitty.WikittyExtension; +import org.nuiton.wikitty.WikittyExtensionStorage; +import org.nuiton.wikitty.WikittyTransaction; +import org.nuiton.wikitty.WikittyUtil; /** * Modified: trunk/wikitty-jdbc-impl/src/main/java/org/nuiton/wikitty/jdbc/WikittyJDBCUtil.java =================================================================== --- trunk/wikitty-jdbc-impl/src/main/java/org/sharengo/wikitty/jdbc/WikittyJDBCUtil.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jdbc-impl/src/main/java/org/nuiton/wikitty/jdbc/WikittyJDBCUtil.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,7 +15,7 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.jdbc; +package org.nuiton.wikitty.jdbc; import java.io.IOException; import java.io.InputStream; @@ -33,7 +33,7 @@ import org.apache.commons.logging.LogFactory; import org.enhydra.jdbc.pool.StandardXAPoolDataSource; import org.enhydra.jdbc.standard.StandardXADataSource; -import org.sharengo.wikitty.WikittyException; +import org.nuiton.wikitty.WikittyException; /** * Modified: trunk/wikitty-jdbc-impl/src/main/java/org/nuiton/wikitty/jdbc/WikittyServiceJDBC.java =================================================================== --- trunk/wikitty-jdbc-impl/src/main/java/org/sharengo/wikitty/jdbc/WikittyServiceJDBC.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jdbc-impl/src/main/java/org/nuiton/wikitty/jdbc/WikittyServiceJDBC.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,15 +15,15 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.jdbc; +package org.nuiton.wikitty.jdbc; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.sharengo.wikitty.AbstractWikittyService; -import org.sharengo.wikitty.WikittyExtensionStorage; -import org.sharengo.wikitty.WikittySearchEngin; -import org.sharengo.wikitty.WikittyStorage; -import org.sharengo.wikitty.solr.WikittySearchEnginSolr; +import org.nuiton.wikitty.AbstractWikittyService; +import org.nuiton.wikitty.WikittyExtensionStorage; +import org.nuiton.wikitty.WikittySearchEngin; +import org.nuiton.wikitty.WikittyStorage; +import org.nuiton.wikitty.solr.WikittySearchEnginSolr; /** * @author poussin Modified: trunk/wikitty-jdbc-impl/src/main/java/org/nuiton/wikitty/jdbc/WikittyStorageJDBC.java =================================================================== --- trunk/wikitty-jdbc-impl/src/main/java/org/sharengo/wikitty/jdbc/WikittyStorageJDBC.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jdbc-impl/src/main/java/org/nuiton/wikitty/jdbc/WikittyStorageJDBC.java 2010-05-12 15:08:48 UTC (rev 53) @@ -14,37 +14,37 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.jdbc; +package org.nuiton.wikitty.jdbc; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.COL_BOOLEAN_VALUE; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.COL_DATE_VALUE; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.COL_DELETION_DATE; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.COL_EXTENSION; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.COL_FIELDNAME; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.COL_ID; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.COL_NUMBER_VALUE; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.COL_TEXT_VALUE; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.COL_VERSION; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.JDBC_DRIVER; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.QUERY_CLEAR_WIKITTY; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.QUERY_CREATION_WIKITTY_ADMIN; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.QUERY_CREATION_WIKITTY_DATA; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.QUERY_DELETE_WIKITTY_ADMIN; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.QUERY_DELETE_WIKITTY_DATA; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.QUERY_INSERT_WIKITTY_ADMIN; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.QUERY_INSERT_WIKITTY_DATA; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.QUERY_SELECT_NOTDELETED; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.QUERY_SELECT_WHERE; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.QUERY_SELECT_WHERE_NOTDELETED; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.QUERY_UPDATE_WIKITTY_ADMIN; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.TABLE_WIKITTY_ADMIN; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.TABLE_WIKITTY_DATA; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.commitJDBCConnection; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.doQuery; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.getConnection; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.getJDBCConnection; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.loadProperties; -import static org.sharengo.wikitty.jdbc.WikittyJDBCUtil.rollbackJDBCConnection; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.COL_BOOLEAN_VALUE; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.COL_DATE_VALUE; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.COL_DELETION_DATE; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.COL_EXTENSION; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.COL_FIELDNAME; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.COL_ID; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.COL_NUMBER_VALUE; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.COL_TEXT_VALUE; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.COL_VERSION; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.JDBC_DRIVER; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.QUERY_CLEAR_WIKITTY; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.QUERY_CREATION_WIKITTY_ADMIN; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.QUERY_CREATION_WIKITTY_DATA; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.QUERY_DELETE_WIKITTY_ADMIN; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.QUERY_DELETE_WIKITTY_DATA; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.QUERY_INSERT_WIKITTY_ADMIN; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.QUERY_INSERT_WIKITTY_DATA; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.QUERY_SELECT_NOTDELETED; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.QUERY_SELECT_WHERE; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.QUERY_SELECT_WHERE_NOTDELETED; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.QUERY_UPDATE_WIKITTY_ADMIN; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.TABLE_WIKITTY_ADMIN; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.TABLE_WIKITTY_DATA; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.commitJDBCConnection; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.doQuery; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.getConnection; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.getJDBCConnection; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.loadProperties; +import static org.nuiton.wikitty.jdbc.WikittyJDBCUtil.rollbackJDBCConnection; import java.sql.Connection; import java.sql.PreparedStatement; @@ -66,15 +66,15 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.sharengo.wikitty.FieldType; -import org.sharengo.wikitty.UpdateResponse; -import org.sharengo.wikitty.Wikitty; -import org.sharengo.wikitty.WikittyException; -import org.sharengo.wikitty.WikittyExtension; -import org.sharengo.wikitty.WikittyExtensionStorage; -import org.sharengo.wikitty.WikittyStorage; -import org.sharengo.wikitty.WikittyTransaction; -import org.sharengo.wikitty.WikittyUtil; +import org.nuiton.wikitty.FieldType; +import org.nuiton.wikitty.UpdateResponse; +import org.nuiton.wikitty.Wikitty; +import org.nuiton.wikitty.WikittyException; +import org.nuiton.wikitty.WikittyExtension; +import org.nuiton.wikitty.WikittyExtensionStorage; +import org.nuiton.wikitty.WikittyStorage; +import org.nuiton.wikitty.WikittyTransaction; +import org.nuiton.wikitty.WikittyUtil; /** * Modified: trunk/wikitty-jdbc-impl/src/test/java/org/nuiton/wikitty/jdbc/test/StorageJDBCTest.java =================================================================== --- trunk/wikitty-jdbc-impl/src/test/java/org/sharengo/wikitty/jdbc/test/StorageJDBCTest.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jdbc-impl/src/test/java/org/nuiton/wikitty/jdbc/test/StorageJDBCTest.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,11 +15,11 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.jdbc.test; +package org.nuiton.wikitty.jdbc.test; import org.junit.Before; -import org.sharengo.wikitty.jdbc.WikittyServiceJDBC; -import org.sharengo.wikitty.test.conform.StorageTest; +import org.nuiton.wikitty.jdbc.WikittyServiceJDBC; +import org.nuiton.wikitty.test.conform.StorageTest; /** * Modified: trunk/wikitty-jdbc-impl/src/test/resources/META-INF/spring/wikitty-test.xml =================================================================== --- trunk/wikitty-jdbc-impl/src/test/resources/META-INF/spring/wikitty-test.xml 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-jdbc-impl/src/test/resources/META-INF/spring/wikitty-test.xml 2010-05-12 15:08:48 UTC (rev 53) @@ -6,9 +6,9 @@ xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd"> - <bean name="wikittyService" class="org.sharengo.wikitty.jdbc.WikittyServiceJDBC"/> + <bean name="wikittyService" class="org.nuiton.wikitty.jdbc.WikittyServiceJDBC"/> <context:annotation-config/> - <context:component-scan base-package="org.sharengo.wikitty"/> + <context:component-scan base-package="org.nuiton.wikitty"/> </beans> Modified: trunk/wikitty-jdbc-impl/src/test/resources/log4j.properties =================================================================== --- trunk/wikitty-jdbc-impl/src/test/resources/log4j.properties 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-jdbc-impl/src/test/resources/log4j.properties 2010-05-12 15:08:48 UTC (rev 53) @@ -5,5 +5,5 @@ # Configuration by components log4j.rootLogger=DEBUG, logConsole -log4j.category.org.sharengo.wikitty=DEBUG +log4j.category.org.nuiton.wikitty=DEBUG log4j.category.org.enhydra=DEBUG Modified: trunk/wikitty-jms-impl/src/main/java/org/nuiton/wikitty/jms/WikittyActionMessage.java =================================================================== --- trunk/wikitty-jms-impl/src/main/java/org/sharengo/wikitty/jms/WikittyActionMessage.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jms-impl/src/main/java/org/nuiton/wikitty/jms/WikittyActionMessage.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,13 +15,15 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.jms; +package org.nuiton.wikitty.jms; import java.io.Serializable; import java.util.HashMap; import javax.jms.JMSException; import javax.jms.ObjectMessage; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.*; + +import static org.nuiton.wikitty.jms.WikittyJMSUtil.*; + import org.apache.activemq.command.ActiveMQObjectMessage; /** Modified: trunk/wikitty-jms-impl/src/main/java/org/nuiton/wikitty/jms/WikittyBrokerFactory.java =================================================================== --- trunk/wikitty-jms-impl/src/main/java/org/sharengo/wikitty/jms/WikittyBrokerFactory.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jms-impl/src/main/java/org/nuiton/wikitty/jms/WikittyBrokerFactory.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,7 +15,7 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.jms; +package org.nuiton.wikitty.jms; import java.net.URI; import java.util.Map; Modified: trunk/wikitty-jms-impl/src/main/java/org/nuiton/wikitty/jms/WikittyExtensionStorageJMS.java =================================================================== --- trunk/wikitty-jms-impl/src/main/java/org/sharengo/wikitty/jms/WikittyExtensionStorageJMS.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jms-impl/src/main/java/org/nuiton/wikitty/jms/WikittyExtensionStorageJMS.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,13 +15,13 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.jms; +package org.nuiton.wikitty.jms; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.ACTION_CLEAR; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.ACTION_STORE; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.JNDI_PROVIDER_URL; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.PARAM_EXTENSIONS; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.TOPIC_EXTENSION_STORAGE; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.ACTION_CLEAR; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.ACTION_STORE; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.JNDI_PROVIDER_URL; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.PARAM_EXTENSIONS; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.TOPIC_EXTENSION_STORAGE; import java.util.ArrayList; import java.util.Collection; @@ -39,11 +39,11 @@ import org.apache.activemq.ActiveMQXAConnectionFactory; import org.apache.activemq.command.ActiveMQTopic; -import org.sharengo.wikitty.UpdateResponse; -import org.sharengo.wikitty.WikittyException; -import org.sharengo.wikitty.WikittyExtension; -import org.sharengo.wikitty.WikittyExtensionStorage; -import org.sharengo.wikitty.WikittyTransaction; +import org.nuiton.wikitty.UpdateResponse; +import org.nuiton.wikitty.WikittyException; +import org.nuiton.wikitty.WikittyExtension; +import org.nuiton.wikitty.WikittyExtensionStorage; +import org.nuiton.wikitty.WikittyTransaction; /** * @author ruchaud Modified: trunk/wikitty-jms-impl/src/main/java/org/nuiton/wikitty/jms/WikittyExtensionSubscriberJMS.java =================================================================== --- trunk/wikitty-jms-impl/src/main/java/org/sharengo/wikitty/jms/WikittyExtensionSubscriberJMS.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jms-impl/src/main/java/org/nuiton/wikitty/jms/WikittyExtensionSubscriberJMS.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,13 +15,13 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.jms; +package org.nuiton.wikitty.jms; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.ACTION_CLEAR; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.ACTION_STORE; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.JNDI_PROVIDER_URL; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.PARAM_EXTENSIONS; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.TOPIC_EXTENSION_STORAGE; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.ACTION_CLEAR; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.ACTION_STORE; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.JNDI_PROVIDER_URL; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.PARAM_EXTENSIONS; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.TOPIC_EXTENSION_STORAGE; import java.util.ArrayList; import java.util.Properties; @@ -42,10 +42,10 @@ import org.apache.activemq.command.ActiveMQTopic; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.sharengo.wikitty.WikittyException; -import org.sharengo.wikitty.WikittyExtension; -import org.sharengo.wikitty.WikittyExtensionStorage; -import org.sharengo.wikitty.WikittyTransaction; +import org.nuiton.wikitty.WikittyException; +import org.nuiton.wikitty.WikittyExtension; +import org.nuiton.wikitty.WikittyExtensionStorage; +import org.nuiton.wikitty.WikittyTransaction; /** * WikittyExtensionSubscriberJMS. Modified: trunk/wikitty-jms-impl/src/main/java/org/nuiton/wikitty/jms/WikittyJMSUtil.java =================================================================== --- trunk/wikitty-jms-impl/src/main/java/org/sharengo/wikitty/jms/WikittyJMSUtil.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jms-impl/src/main/java/org/nuiton/wikitty/jms/WikittyJMSUtil.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,7 +15,7 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.jms; +package org.nuiton.wikitty.jms; import java.util.Date; import java.util.Enumeration; @@ -30,7 +30,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.sharengo.wikitty.WikittyTransaction; +import org.nuiton.wikitty.WikittyTransaction; /** * @author ruchaud Modified: trunk/wikitty-jms-impl/src/main/java/org/nuiton/wikitty/jms/WikittyStorageJMS.java =================================================================== --- trunk/wikitty-jms-impl/src/main/java/org/sharengo/wikitty/jms/WikittyStorageJMS.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jms-impl/src/main/java/org/nuiton/wikitty/jms/WikittyStorageJMS.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,16 +15,16 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.jms; +package org.nuiton.wikitty.jms; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.ACTION_CLEAR; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.ACTION_DELETE; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.ACTION_STORE; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.JNDI_PROVIDER_URL; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.PARAM_DISABLE_AUTO_VERSION_INCREMENT; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.PARAM_IDS; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.PARAM_WIKITTIES; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.TOPIC_WIKITTY_STORAGE; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.ACTION_CLEAR; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.ACTION_DELETE; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.ACTION_STORE; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.JNDI_PROVIDER_URL; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.PARAM_DISABLE_AUTO_VERSION_INCREMENT; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.PARAM_IDS; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.PARAM_WIKITTIES; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.TOPIC_WIKITTY_STORAGE; import java.util.ArrayList; import java.util.Collection; @@ -41,11 +41,11 @@ import org.apache.activemq.ActiveMQXAConnectionFactory; import org.apache.activemq.command.ActiveMQTopic; -import org.sharengo.wikitty.UpdateResponse; -import org.sharengo.wikitty.Wikitty; -import org.sharengo.wikitty.WikittyException; -import org.sharengo.wikitty.WikittyStorage; -import org.sharengo.wikitty.WikittyTransaction; +import org.nuiton.wikitty.UpdateResponse; +import org.nuiton.wikitty.Wikitty; +import org.nuiton.wikitty.WikittyException; +import org.nuiton.wikitty.WikittyStorage; +import org.nuiton.wikitty.WikittyTransaction; /** * @author ruchaud Modified: trunk/wikitty-jms-impl/src/main/java/org/nuiton/wikitty/jms/WikittyStorageSubscriberJMS.java =================================================================== --- trunk/wikitty-jms-impl/src/main/java/org/sharengo/wikitty/jms/WikittyStorageSubscriberJMS.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jms-impl/src/main/java/org/nuiton/wikitty/jms/WikittyStorageSubscriberJMS.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,16 +15,16 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.jms; +package org.nuiton.wikitty.jms; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.ACTION_CLEAR; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.ACTION_DELETE; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.ACTION_STORE; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.JNDI_PROVIDER_URL; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.PARAM_DISABLE_AUTO_VERSION_INCREMENT; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.PARAM_IDS; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.PARAM_WIKITTIES; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.TOPIC_WIKITTY_STORAGE; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.ACTION_CLEAR; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.ACTION_DELETE; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.ACTION_STORE; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.JNDI_PROVIDER_URL; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.PARAM_DISABLE_AUTO_VERSION_INCREMENT; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.PARAM_IDS; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.PARAM_WIKITTIES; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.TOPIC_WIKITTY_STORAGE; import java.util.ArrayList; import java.util.Properties; @@ -45,10 +45,10 @@ import org.apache.activemq.command.ActiveMQTopic; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.sharengo.wikitty.Wikitty; -import org.sharengo.wikitty.WikittyException; -import org.sharengo.wikitty.WikittyStorage; -import org.sharengo.wikitty.WikittyTransaction; +import org.nuiton.wikitty.Wikitty; +import org.nuiton.wikitty.WikittyException; +import org.nuiton.wikitty.WikittyStorage; +import org.nuiton.wikitty.WikittyTransaction; /** * WikittyStorageSubscriberJMS. Modified: trunk/wikitty-jms-impl/src/main/resources/META-INF/services/org/apache/activemq/broker/wikitty =================================================================== --- trunk/wikitty-jms-impl/src/main/resources/META-INF/services/org/apache/activemq/broker/wikitty 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-jms-impl/src/main/resources/META-INF/services/org/apache/activemq/broker/wikitty 2010-05-12 15:08:48 UTC (rev 53) @@ -1 +1 @@ -class=org.sharengo.wikitty.jms.WikittyBrokerFactory +class=org.nuiton.wikitty.jms.WikittyBrokerFactory Modified: trunk/wikitty-jms-impl/src/test/java/org/nuiton/wikitty/jms/test/TopicSendReceiveTCPTest.java =================================================================== --- trunk/wikitty-jms-impl/src/test/java/org/sharengo/wikitty/jms/test/TopicSendReceiveTCPTest.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jms-impl/src/test/java/org/nuiton/wikitty/jms/test/TopicSendReceiveTCPTest.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,9 +15,9 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.jms.test; +package org.nuiton.wikitty.jms.test; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.JNDI_PROVIDER_URL; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.JNDI_PROVIDER_URL; import java.util.Properties; import org.apache.activemq.broker.BrokerFactory; Modified: trunk/wikitty-jms-impl/src/test/java/org/nuiton/wikitty/jms/test/TopicSendReceiveTestSupport.java =================================================================== --- trunk/wikitty-jms-impl/src/test/java/org/sharengo/wikitty/jms/test/TopicSendReceiveTestSupport.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jms-impl/src/test/java/org/nuiton/wikitty/jms/test/TopicSendReceiveTestSupport.java 2010-05-12 15:08:48 UTC (rev 53) @@ -14,7 +14,7 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.jms.test; +package org.nuiton.wikitty.jms.test; import java.util.ArrayList; import java.util.Collection; @@ -25,17 +25,17 @@ import org.junit.Assert; import org.junit.Test; -import org.sharengo.wikitty.UpdateResponse; -import org.sharengo.wikitty.Wikitty; -import org.sharengo.wikitty.WikittyException; -import org.sharengo.wikitty.WikittyExtension; -import org.sharengo.wikitty.WikittyExtensionStorage; -import org.sharengo.wikitty.WikittyStorage; -import org.sharengo.wikitty.WikittyTransaction; -import org.sharengo.wikitty.jms.WikittyExtensionStorageJMS; -import org.sharengo.wikitty.jms.WikittyExtensionSubscriberJMS; -import org.sharengo.wikitty.jms.WikittyStorageJMS; -import org.sharengo.wikitty.jms.WikittyStorageSubscriberJMS; +import org.nuiton.wikitty.UpdateResponse; +import org.nuiton.wikitty.Wikitty; +import org.nuiton.wikitty.WikittyException; +import org.nuiton.wikitty.WikittyExtension; +import org.nuiton.wikitty.WikittyExtensionStorage; +import org.nuiton.wikitty.WikittyStorage; +import org.nuiton.wikitty.WikittyTransaction; +import org.nuiton.wikitty.jms.WikittyExtensionStorageJMS; +import org.nuiton.wikitty.jms.WikittyExtensionSubscriberJMS; +import org.nuiton.wikitty.jms.WikittyStorageJMS; +import org.nuiton.wikitty.jms.WikittyStorageSubscriberJMS; /** * TopicSendReceiveTestSupport. Modified: trunk/wikitty-jms-impl/src/test/java/org/nuiton/wikitty/jms/test/TopicSendReceiveVMTest.java =================================================================== --- trunk/wikitty-jms-impl/src/test/java/org/sharengo/wikitty/jms/test/TopicSendReceiveVMTest.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jms-impl/src/test/java/org/nuiton/wikitty/jms/test/TopicSendReceiveVMTest.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,9 +15,9 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.jms.test; +package org.nuiton.wikitty.jms.test; -import static org.sharengo.wikitty.jms.WikittyJMSUtil.JNDI_PROVIDER_URL; +import static org.nuiton.wikitty.jms.WikittyJMSUtil.JNDI_PROVIDER_URL; import java.util.Properties; import org.apache.activemq.broker.BrokerFactory; Modified: trunk/wikitty-jms-impl/src/test/java/org/nuiton/wikitty/jms/test/WikittyExtensionStorageAdapter.java =================================================================== --- trunk/wikitty-jms-impl/src/test/java/org/sharengo/wikitty/jms/test/WikittyExtensionStorageAdapter.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jms-impl/src/test/java/org/nuiton/wikitty/jms/test/WikittyExtensionStorageAdapter.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,13 +1,13 @@ -package org.sharengo.wikitty.jms.test; +package org.nuiton.wikitty.jms.test; import java.util.Collection; import java.util.List; -import org.sharengo.wikitty.UpdateResponse; -import org.sharengo.wikitty.WikittyException; -import org.sharengo.wikitty.WikittyExtension; -import org.sharengo.wikitty.WikittyExtensionStorage; -import org.sharengo.wikitty.WikittyTransaction; +import org.nuiton.wikitty.UpdateResponse; +import org.nuiton.wikitty.WikittyException; +import org.nuiton.wikitty.WikittyExtension; +import org.nuiton.wikitty.WikittyExtensionStorage; +import org.nuiton.wikitty.WikittyTransaction; /** * WikittyExtensionStorageAdapter. @@ -19,7 +19,7 @@ public class WikittyExtensionStorageAdapter implements WikittyExtensionStorage { /* (non-Javadoc) - * @see org.sharengo.wikitty.WikittyExtensionStorage#store(org.sharengo.wikitty.WikittyTransaction, java.util.Collection) + * @see org.nuiton.wikitty.WikittyExtensionStorage#store(org.sharengo.wikitty.WikittyTransaction, java.util.Collection) */ @Override public UpdateResponse store(WikittyTransaction transaction, @@ -28,7 +28,7 @@ } /* (non-Javadoc) - * @see org.sharengo.wikitty.WikittyExtensionStorage#exists(org.sharengo.wikitty.WikittyTransaction, java.lang.String) + * @see org.nuiton.wikitty.WikittyExtensionStorage#exists(org.sharengo.wikitty.WikittyTransaction, java.lang.String) */ @Override public boolean exists(WikittyTransaction transaction, String id) { @@ -36,7 +36,7 @@ } /* (non-Javadoc) - * @see org.sharengo.wikitty.WikittyExtensionStorage#getAllExtensionIds(org.sharengo.wikitty.WikittyTransaction) + * @see org.nuiton.wikitty.WikittyExtensionStorage#getAllExtensionIds(org.sharengo.wikitty.WikittyTransaction) */ @Override public List<String> getAllExtensionIds(WikittyTransaction transaction) { @@ -44,7 +44,7 @@ } /* (non-Javadoc) - * @see org.sharengo.wikitty.WikittyExtensionStorage#getAllExtensionsRequires(org.sharengo.wikitty.WikittyTransaction, java.lang.String) + * @see org.nuiton.wikitty.WikittyExtensionStorage#getAllExtensionsRequires(org.sharengo.wikitty.WikittyTransaction, java.lang.String) */ @Override public List<String> getAllExtensionsRequires( @@ -53,7 +53,7 @@ } /* (non-Javadoc) - * @see org.sharengo.wikitty.WikittyExtensionStorage#getLastVersion(org.sharengo.wikitty.WikittyTransaction, java.lang.String) + * @see org.nuiton.wikitty.WikittyExtensionStorage#getLastVersion(org.sharengo.wikitty.WikittyTransaction, java.lang.String) */ @Override public String getLastVersion(WikittyTransaction transaction, String extName) { @@ -61,7 +61,7 @@ } /* (non-Javadoc) - * @see org.sharengo.wikitty.WikittyExtensionStorage#restore(org.sharengo.wikitty.WikittyTransaction, java.lang.String, java.lang.String) + * @see org.nuiton.wikitty.WikittyExtensionStorage#restore(org.sharengo.wikitty.WikittyTransaction, java.lang.String, java.lang.String) */ @Override public WikittyExtension restore(WikittyTransaction transaction, @@ -70,7 +70,7 @@ } /* (non-Javadoc) - * @see org.sharengo.wikitty.WikittyExtensionStorage#clear(org.sharengo.wikitty.WikittyTransaction) + * @see org.nuiton.wikitty.WikittyExtensionStorage#clear(org.sharengo.wikitty.WikittyTransaction) */ @Override public void clear(WikittyTransaction transaction) { Modified: trunk/wikitty-jms-impl/src/test/java/org/nuiton/wikitty/jms/test/WikittyStorageAdapter.java =================================================================== --- trunk/wikitty-jms-impl/src/test/java/org/sharengo/wikitty/jms/test/WikittyStorageAdapter.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jms-impl/src/test/java/org/nuiton/wikitty/jms/test/WikittyStorageAdapter.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,12 +1,12 @@ -package org.sharengo.wikitty.jms.test; +package org.nuiton.wikitty.jms.test; import java.util.Collection; -import org.sharengo.wikitty.UpdateResponse; -import org.sharengo.wikitty.Wikitty; -import org.sharengo.wikitty.WikittyException; -import org.sharengo.wikitty.WikittyStorage; -import org.sharengo.wikitty.WikittyTransaction; +import org.nuiton.wikitty.UpdateResponse; +import org.nuiton.wikitty.Wikitty; +import org.nuiton.wikitty.WikittyException; +import org.nuiton.wikitty.WikittyStorage; +import org.nuiton.wikitty.WikittyTransaction; /** * WikittyStorageAdapter. @@ -18,7 +18,7 @@ public class WikittyStorageAdapter implements WikittyStorage { /* (non-Javadoc) - * @see org.sharengo.wikitty.WikittyStorage#store(org.sharengo.wikitty.WikittyTransaction, java.util.Collection, boolean) + * @see org.nuiton.wikitty.WikittyStorage#store(org.sharengo.wikitty.WikittyTransaction, java.util.Collection, boolean) */ @Override public UpdateResponse store(WikittyTransaction transaction, @@ -27,7 +27,7 @@ } /* (non-Javadoc) - * @see org.sharengo.wikitty.WikittyStorage#exists(org.sharengo.wikitty.WikittyTransaction, java.lang.String) + * @see org.nuiton.wikitty.WikittyStorage#exists(org.sharengo.wikitty.WikittyTransaction, java.lang.String) */ @Override public boolean exists(WikittyTransaction transaction, String id) { @@ -35,7 +35,7 @@ } /* (non-Javadoc) - * @see org.sharengo.wikitty.WikittyStorage#isDeleted(org.sharengo.wikitty.WikittyTransaction, java.lang.String) + * @see org.nuiton.wikitty.WikittyStorage#isDeleted(org.sharengo.wikitty.WikittyTransaction, java.lang.String) */ @Override public boolean isDeleted(WikittyTransaction transaction, String id) { @@ -43,7 +43,7 @@ } /* (non-Javadoc) - * @see org.sharengo.wikitty.WikittyStorage#restore(org.sharengo.wikitty.WikittyTransaction, java.lang.String, java.lang.String[]) + * @see org.nuiton.wikitty.WikittyStorage#restore(org.sharengo.wikitty.WikittyTransaction, java.lang.String, java.lang.String[]) */ @Override public Wikitty restore(WikittyTransaction transaction, String id, @@ -52,7 +52,7 @@ } /* (non-Javadoc) - * @see org.sharengo.wikitty.WikittyStorage#delete(org.sharengo.wikitty.WikittyTransaction, java.util.Collection) + * @see org.nuiton.wikitty.WikittyStorage#delete(org.sharengo.wikitty.WikittyTransaction, java.util.Collection) */ @Override public UpdateResponse delete(WikittyTransaction transaction, @@ -61,7 +61,7 @@ } /* (non-Javadoc) - * @see org.sharengo.wikitty.WikittyStorage#scanWikitties(org.sharengo.wikitty.WikittyTransaction, org.sharengo.wikitty.WikittyStorage.Scanner) + * @see org.nuiton.wikitty.WikittyStorage#scanWikitties(org.sharengo.wikitty.WikittyTransaction, org.sharengo.wikitty.WikittyStorage.Scanner) */ @Override public void scanWikitties(WikittyTransaction transaction, Scanner scanner) { @@ -69,7 +69,7 @@ } /* (non-Javadoc) - * @see org.sharengo.wikitty.WikittyStorage#clear(org.sharengo.wikitty.WikittyTransaction) + * @see org.nuiton.wikitty.WikittyStorage#clear(org.sharengo.wikitty.WikittyTransaction) */ @Override public void clear(WikittyTransaction transaction) { Modified: trunk/wikitty-jms-impl/src/test/resources/log4j.properties =================================================================== --- trunk/wikitty-jms-impl/src/test/resources/log4j.properties 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-jms-impl/src/test/resources/log4j.properties 2010-05-12 15:08:48 UTC (rev 53) @@ -5,6 +5,6 @@ # Configuration by components log4j.rootLogger=INFO, logConsole -log4j.logger.org.sharengo.wikitty=DEBUG +log4j.logger.org.nuiton.wikitty=DEBUG log4j.logger.org.apache.activemq=INFO Modified: trunk/wikitty-jpa-impl/src/main/java/org/nuiton/wikitty/jpa/JBossTMFactoryBean.java =================================================================== --- trunk/wikitty-jpa-impl/src/main/java/org/sharengo/wikitty/jpa/JBossTMFactoryBean.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jpa-impl/src/main/java/org/nuiton/wikitty/jpa/JBossTMFactoryBean.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,7 +15,7 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.jpa; +package org.nuiton.wikitty.jpa; import javax.transaction.TransactionManager; import org.springframework.beans.factory.FactoryBean; Modified: trunk/wikitty-jpa-impl/src/main/java/org/nuiton/wikitty/jpa/JBossUTFactoryBean.java =================================================================== --- trunk/wikitty-jpa-impl/src/main/java/org/sharengo/wikitty/jpa/JBossUTFactoryBean.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jpa-impl/src/main/java/org/nuiton/wikitty/jpa/JBossUTFactoryBean.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,7 +15,7 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.jpa; +package org.nuiton.wikitty.jpa; import javax.transaction.UserTransaction; import org.springframework.beans.factory.FactoryBean; Modified: trunk/wikitty-jpa-impl/src/main/java/org/nuiton/wikitty/jpa/JtaPersistenceUnitPostProcessor.java =================================================================== --- trunk/wikitty-jpa-impl/src/main/java/org/sharengo/wikitty/jpa/JtaPersistenceUnitPostProcessor.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jpa-impl/src/main/java/org/nuiton/wikitty/jpa/JtaPersistenceUnitPostProcessor.java 2010-05-12 15:08:48 UTC (rev 53) @@ -14,7 +14,7 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.jpa; +package org.nuiton.wikitty.jpa; import javax.sql.DataSource; import org.springframework.orm.jpa.persistenceunit.MutablePersistenceUnitInfo; Modified: trunk/wikitty-jpa-impl/src/main/java/org/nuiton/wikitty/jpa/TransactionManagerLookup.java =================================================================== --- trunk/wikitty-jpa-impl/src/main/java/org/sharengo/wikitty/jpa/TransactionManagerLookup.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jpa-impl/src/main/java/org/nuiton/wikitty/jpa/TransactionManagerLookup.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,7 +15,7 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.jpa; +package org.nuiton.wikitty.jpa; import java.util.Properties; import javax.transaction.Transaction; Modified: trunk/wikitty-jpa-impl/src/main/java/org/nuiton/wikitty/jpa/WikittyExtensionStorageJPA.java =================================================================== --- trunk/wikitty-jpa-impl/src/main/java/org/sharengo/wikitty/jpa/WikittyExtensionStorageJPA.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jpa-impl/src/main/java/org/nuiton/wikitty/jpa/WikittyExtensionStorageJPA.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.jpa; +package org.nuiton.wikitty.jpa; /* *##% * Copyright (c) 2009 ruchaud. All rights reserved. @@ -31,12 +31,12 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.sharengo.wikitty.UpdateResponse; -import org.sharengo.wikitty.WikittyException; -import org.sharengo.wikitty.WikittyExtension; -import org.sharengo.wikitty.WikittyExtensionStorage; -import org.sharengo.wikitty.WikittyTransaction; -import org.sharengo.wikitty.WikittyUtil; +import org.nuiton.wikitty.UpdateResponse; +import org.nuiton.wikitty.WikittyException; +import org.nuiton.wikitty.WikittyExtension; +import org.nuiton.wikitty.WikittyExtensionStorage; +import org.nuiton.wikitty.WikittyTransaction; +import org.nuiton.wikitty.WikittyUtil; /** * Modified: trunk/wikitty-jpa-impl/src/main/java/org/nuiton/wikitty/jpa/WikittyJPAUtil.java =================================================================== --- trunk/wikitty-jpa-impl/src/main/java/org/sharengo/wikitty/jpa/WikittyJPAUtil.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jpa-impl/src/main/java/org/nuiton/wikitty/jpa/WikittyJPAUtil.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,12 +15,13 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.jpa; +package org.nuiton.wikitty.jpa; import javax.persistence.EntityManager; import javax.persistence.EntityManagerFactory; -import org.sharengo.wikitty.WikittyTransaction; +import org.nuiton.wikitty.WikittyTransaction; + /** * * @author ruchaud Modified: trunk/wikitty-jpa-impl/src/main/java/org/nuiton/wikitty/jpa/WikittyServiceJPA.java =================================================================== --- trunk/wikitty-jpa-impl/src/main/java/org/sharengo/wikitty/jpa/WikittyServiceJPA.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jpa-impl/src/main/java/org/nuiton/wikitty/jpa/WikittyServiceJPA.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,14 +15,14 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.jpa; +package org.nuiton.wikitty.jpa; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.sharengo.wikitty.AbstractWikittyService; -import org.sharengo.wikitty.WikittyExtensionStorage; -import org.sharengo.wikitty.WikittySearchEngin; -import org.sharengo.wikitty.WikittyStorage; +import org.nuiton.wikitty.AbstractWikittyService; +import org.nuiton.wikitty.WikittyExtensionStorage; +import org.nuiton.wikitty.WikittySearchEngin; +import org.nuiton.wikitty.WikittyStorage; import org.springframework.beans.factory.annotation.Autowired; /** Modified: trunk/wikitty-jpa-impl/src/main/java/org/nuiton/wikitty/jpa/WikittyStorageJPA.java =================================================================== --- trunk/wikitty-jpa-impl/src/main/java/org/sharengo/wikitty/jpa/WikittyStorageJPA.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jpa-impl/src/main/java/org/nuiton/wikitty/jpa/WikittyStorageJPA.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,7 +15,7 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.jpa; +package org.nuiton.wikitty.jpa; import java.util.Collection; import java.util.Date; @@ -23,15 +23,16 @@ import java.util.List; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.sharengo.wikitty.FieldType; -import org.sharengo.wikitty.UpdateResponse; -import org.sharengo.wikitty.Wikitty; -import org.sharengo.wikitty.WikittyException; -import org.sharengo.wikitty.WikittyExtension; -import org.sharengo.wikitty.WikittyExtensionStorage; -import org.sharengo.wikitty.WikittyStorage; -import org.sharengo.wikitty.WikittyTransaction; -import org.sharengo.wikitty.WikittyUtil; +import org.nuiton.wikitty.FieldType; +import org.nuiton.wikitty.UpdateResponse; +import org.nuiton.wikitty.Wikitty; +import org.nuiton.wikitty.WikittyException; +import org.nuiton.wikitty.WikittyExtension; +import org.nuiton.wikitty.WikittyExtensionStorage; +import org.nuiton.wikitty.WikittyStorage; +import org.nuiton.wikitty.WikittyTransaction; +import org.nuiton.wikitty.WikittyUtil; + import javax.persistence.EntityManager; import javax.persistence.EntityManagerFactory; import javax.persistence.PersistenceUnit; Modified: trunk/wikitty-jpa-impl/src/main/resources/META-INF/orm.xml =================================================================== --- trunk/wikitty-jpa-impl/src/main/resources/META-INF/orm.xml 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-jpa-impl/src/main/resources/META-INF/orm.xml 2010-05-12 15:08:48 UTC (rev 53) @@ -4,7 +4,7 @@ xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm orm_2_0.xsd" version="2.0"> - <entity name="WikittyExtension" class="org.sharengo.wikitty.WikittyExtension" access="FIELD"> + <entity name="WikittyExtension" class="org.nuiton.wikitty.WikittyExtension" access="FIELD"> <attributes> <id name="name"/> <id name="version"/> @@ -17,7 +17,7 @@ </attributes> </entity> - <entity name="Wikitty" class="org.sharengo.wikitty.Wikitty" access="FIELD"> + <entity name="Wikitty" class="org.nuiton.wikitty.Wikitty" access="FIELD"> <attributes> <id name="id"/> <basic name="deleteDate"> Modified: trunk/wikitty-jpa-impl/src/main/resources/META-INF/persistence.xml =================================================================== --- trunk/wikitty-jpa-impl/src/main/resources/META-INF/persistence.xml 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-jpa-impl/src/main/resources/META-INF/persistence.xml 2010-05-12 15:08:48 UTC (rev 53) @@ -1,11 +1,11 @@ <persistence xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" - xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://anonsvn.jboss.org/repos/hibernate/core/trunk/entitymanager/src/main/r..." + xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd" version="2.0"> <persistence-unit name="manager" transaction-type="JTA"> - <class>org.sharengo.wikitty.Wikitty</class> - <class>org.sharengo.wikitty.WikittyExtension</class> + <class>org.nuiton.wikitty.Wikitty</class> + <class>org.nuiton.wikitty.WikittyExtension</class> </persistence-unit> </persistence> Modified: trunk/wikitty-jpa-impl/src/test/java/org/nuiton/wikitty/jpa/test/StorageJPATest.java =================================================================== --- trunk/wikitty-jpa-impl/src/test/java/org/sharengo/wikitty/jpa/test/StorageJPATest.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jpa-impl/src/test/java/org/nuiton/wikitty/jpa/test/StorageJPATest.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,12 +15,12 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.jpa.test; +package org.nuiton.wikitty.jpa.test; import org.junit.Before; import org.junit.runner.RunWith; -import org.sharengo.wikitty.jpa.WikittyServiceJPA; -import org.sharengo.wikitty.test.conform.StorageTest; +import org.nuiton.wikitty.jpa.WikittyServiceJPA; +import org.nuiton.wikitty.test.conform.StorageTest; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; Modified: trunk/wikitty-jpa-impl/src/test/java/org/nuiton/wikitty/jpa/test/TestJTA.java =================================================================== --- trunk/wikitty-jpa-impl/src/test/java/org/sharengo/wikitty/jpa/test/TestJTA.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jpa-impl/src/test/java/org/nuiton/wikitty/jpa/test/TestJTA.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,7 +15,7 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.jpa.test; +package org.nuiton.wikitty.jpa.test; import com.arjuna.ats.arjuna.coordinator.BasicAction; @@ -39,8 +39,8 @@ import org.apache.commons.logging.LogFactory; import org.junit.Test; import org.junit.runner.RunWith; -import org.sharengo.wikitty.Wikitty; -import org.sharengo.wikitty.jpa.WikittyExtensionStorageJPA; +import org.nuiton.wikitty.Wikitty; +import org.nuiton.wikitty.jpa.WikittyExtensionStorageJPA; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; Modified: trunk/wikitty-jpa-impl/src/test/java/org/nuiton/wikitty/jpa/test/TestJTAWithSync.java =================================================================== --- trunk/wikitty-jpa-impl/src/test/java/org/sharengo/wikitty/jpa/test/TestJTAWithSync.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-jpa-impl/src/test/java/org/nuiton/wikitty/jpa/test/TestJTAWithSync.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,7 +15,7 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.jpa.test; +package org.nuiton.wikitty.jpa.test; import javax.persistence.EntityManager; @@ -30,8 +30,8 @@ import org.apache.commons.logging.LogFactory; import org.junit.Test; import org.junit.runner.RunWith; -import org.sharengo.wikitty.Wikitty; -import org.sharengo.wikitty.jpa.WikittyExtensionStorageJPA; +import org.nuiton.wikitty.Wikitty; +import org.nuiton.wikitty.jpa.WikittyExtensionStorageJPA; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; Modified: trunk/wikitty-jpa-impl/src/test/resources/META-INF/spring/wikitty-test.xml =================================================================== --- trunk/wikitty-jpa-impl/src/test/resources/META-INF/spring/wikitty-test.xml 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-jpa-impl/src/test/resources/META-INF/spring/wikitty-test.xml 2010-05-12 15:08:48 UTC (rev 53) @@ -41,8 +41,8 @@ <!-- required cos the standalone jbosstm transaction manager is not autodetected by the JtaTransactionManager cos it requires a static accessor method --> - <bean id="jbosstm" class="org.sharengo.wikitty.jpa.JBossTMFactoryBean"/> - <bean id="jbossut" class="org.sharengo.wikitty.jpa.JBossUTFactoryBean"/> + <bean id="jbosstm" class="org.nuiton.wikitty.jpa.JBossTMFactoryBean"/> + <bean id="jbossut" class="org.nuiton.wikitty.jpa.JBossUTFactoryBean"/> <!-- supplying the jbossut merely to the userTransaction property cos JtaTransactionManager --> <bean id="jtaTransactionManager" class="org.springframework.transaction.jta.JtaTransactionManager"> @@ -68,7 +68,7 @@ specify further Hibernate specific configuration properties --> <property name="jpaPropertyMap"> <map> - <entry key="hibernate.transaction.manager_lookup_class" value="org.sharengo.wikitty.jpa.TransactionManagerLookup"/> + <entry key="hibernate.transaction.manager_lookup_class" value="org.nuiton.wikitty.jpa.TransactionManagerLookup"/> <entry key="hibernate.transaction.flush_before_completion" value="true"/> <entry key="hibernate.transaction.auto_close_session" value="true"/> <entry key="hibernate.current_session_context_class" value="jta"/> @@ -87,7 +87,7 @@ datasource instead of using a JNDI name as requied by the jta-data-source setting in the persistence.xml file --> <property name="persistenceUnitPostProcessors"> - <bean class="org.sharengo.wikitty.jpa.JtaPersistenceUnitPostProcessor"> + <bean class="org.nuiton.wikitty.jpa.JtaPersistenceUnitPostProcessor"> <property name="jtaDataSource" ref="dataSource"/> </bean> </property> @@ -98,14 +98,14 @@ <tx:annotation-driven transaction-manager="jtaTransactionManager" proxy-target-class="false"/> <!-- Create service --> - <bean name="wikittyService" class="org.sharengo.wikitty.jpa.WikittyServiceJPA"/> - <bean name="wikittyStorage" class="org.sharengo.wikitty.jpa.WikittyStorageJPA" /> - <bean name="extensionStorage" class="org.sharengo.wikitty.jpa.WikittyExtensionStorageJPA"/> - <bean name="searchEngin" class="org.sharengo.wikitty.solr.WikittySearchEnginSolr"> + <bean name="wikittyService" class="org.nuiton.wikitty.jpa.WikittyServiceJPA"/> + <bean name="wikittyStorage" class="org.nuiton.wikitty.jpa.WikittyStorageJPA" /> + <bean name="extensionStorage" class="org.nuiton.wikitty.jpa.WikittyExtensionStorageJPA"/> + <bean name="searchEngin" class="org.nuiton.wikitty.solr.WikittySearchEnginSolr"> <constructor-arg ref="extensionStorage"/> </bean> <context:annotation-config/> - <context:component-scan base-package="org.sharengo.wikitty"/> + <context:component-scan base-package="org.nuiton.wikitty"/> </beans> Modified: trunk/wikitty-jpa-impl/src/test/resources/log4j.properties =================================================================== --- trunk/wikitty-jpa-impl/src/test/resources/log4j.properties 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-jpa-impl/src/test/resources/log4j.properties 2010-05-12 15:08:48 UTC (rev 53) @@ -5,6 +5,6 @@ # Configuration by components log4j.rootLogger=ERROR, logConsole -log4j.category.org.sharengo.wikitty=DEBUG +log4j.category.org.nuiton.wikitty=DEBUG log4j.category.org.hibernate=DEBUG log4j.category.org.enhydra=DEBUG Modified: trunk/wikitty-multistorage-impl/src/main/java/org/nuiton/wikitty/multistorage/MultiStorageConfiguration.java =================================================================== --- trunk/wikitty-multistorage-impl/src/main/java/org/sharengo/wikitty/multistorage/MultiStorageConfiguration.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-multistorage-impl/src/main/java/org/nuiton/wikitty/multistorage/MultiStorageConfiguration.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,14 +15,15 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.multistorage; +package org.nuiton.wikitty.multistorage; import java.util.ArrayList; import java.util.List; -import org.sharengo.wikitty.WikittyException; -import org.sharengo.wikitty.WikittyExtensionStorage; -import org.sharengo.wikitty.WikittyStorage; +import org.nuiton.wikitty.WikittyException; +import org.nuiton.wikitty.WikittyExtensionStorage; +import org.nuiton.wikitty.WikittyStorage; + /** * * @author ruchaud Modified: trunk/wikitty-multistorage-impl/src/main/java/org/nuiton/wikitty/multistorage/WikittyExtensionMultiStorage.java =================================================================== --- trunk/wikitty-multistorage-impl/src/main/java/org/sharengo/wikitty/multistorage/WikittyExtensionMultiStorage.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-multistorage-impl/src/main/java/org/nuiton/wikitty/multistorage/WikittyExtensionMultiStorage.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,18 +15,18 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.multistorage; +package org.nuiton.wikitty.multistorage; import java.util.Collection; import java.util.List; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.sharengo.wikitty.UpdateResponse; -import org.sharengo.wikitty.WikittyException; -import org.sharengo.wikitty.WikittyExtension; -import org.sharengo.wikitty.WikittyExtensionStorage; -import org.sharengo.wikitty.WikittyTransaction; +import org.nuiton.wikitty.UpdateResponse; +import org.nuiton.wikitty.WikittyException; +import org.nuiton.wikitty.WikittyExtension; +import org.nuiton.wikitty.WikittyExtensionStorage; +import org.nuiton.wikitty.WikittyTransaction; /** * Modified: trunk/wikitty-multistorage-impl/src/main/java/org/nuiton/wikitty/multistorage/WikittyMultiStorage.java =================================================================== --- trunk/wikitty-multistorage-impl/src/main/java/org/sharengo/wikitty/multistorage/WikittyMultiStorage.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-multistorage-impl/src/main/java/org/nuiton/wikitty/multistorage/WikittyMultiStorage.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,20 +15,20 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.multistorage; +package org.nuiton.wikitty.multistorage; import java.util.Collection; import java.util.List; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.sharengo.wikitty.UpdateResponse; -import org.sharengo.wikitty.Wikitty; -import org.sharengo.wikitty.WikittyException; -import org.sharengo.wikitty.WikittyExtension; -import org.sharengo.wikitty.WikittyExtensionStorage; -import org.sharengo.wikitty.WikittyStorage; -import org.sharengo.wikitty.WikittyTransaction; +import org.nuiton.wikitty.UpdateResponse; +import org.nuiton.wikitty.Wikitty; +import org.nuiton.wikitty.WikittyException; +import org.nuiton.wikitty.WikittyExtension; +import org.nuiton.wikitty.WikittyExtensionStorage; +import org.nuiton.wikitty.WikittyStorage; +import org.nuiton.wikitty.WikittyTransaction; /** * Modified: trunk/wikitty-multistorage-impl/src/main/java/org/nuiton/wikitty/multistorage/WikittyServiceMultiStorage.java =================================================================== --- trunk/wikitty-multistorage-impl/src/main/java/org/sharengo/wikitty/multistorage/WikittyServiceMultiStorage.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-multistorage-impl/src/main/java/org/nuiton/wikitty/multistorage/WikittyServiceMultiStorage.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,13 +15,13 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.multistorage; +package org.nuiton.wikitty.multistorage; -import org.sharengo.wikitty.AbstractWikittyService; -import org.sharengo.wikitty.WikittyExtensionStorage; -import org.sharengo.wikitty.WikittySearchEngin; -import org.sharengo.wikitty.WikittyStorage; -import org.sharengo.wikitty.solr.WikittySearchEnginSolr; +import org.nuiton.wikitty.AbstractWikittyService; +import org.nuiton.wikitty.WikittyExtensionStorage; +import org.nuiton.wikitty.WikittySearchEngin; +import org.nuiton.wikitty.WikittyStorage; +import org.nuiton.wikitty.solr.WikittySearchEnginSolr; /** * Modified: trunk/wikitty-multistorage-impl/src/test/java/org/nuiton/wikitty/multistorage/test/MultiStorageTest.java =================================================================== --- trunk/wikitty-multistorage-impl/src/test/java/org/sharengo/wikitty/multistorage/test/MultiStorageTest.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-multistorage-impl/src/test/java/org/nuiton/wikitty/multistorage/test/MultiStorageTest.java 2010-05-12 15:08:48 UTC (rev 53) @@ -14,7 +14,7 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.multistorage.test; +package org.nuiton.wikitty.multistorage.test; import java.io.InputStream; import java.net.URL; @@ -24,19 +24,19 @@ import org.junit.Assert; import org.junit.Before; import org.junit.Ignore; -import org.sharengo.wikitty.Wikitty; -import org.sharengo.wikitty.WikittyExtension; -import org.sharengo.wikitty.WikittyExtensionStorage; -import org.sharengo.wikitty.WikittyService; -import org.sharengo.wikitty.WikittyStorage; -import org.sharengo.wikitty.jdbc.WikittyExtensionStorageJDBC; -import org.sharengo.wikitty.jdbc.WikittyStorageJDBC; -import org.sharengo.wikitty.jms.WikittyExtensionStorageJMS; -import org.sharengo.wikitty.jms.WikittyJMSUtil; -import org.sharengo.wikitty.jms.WikittyStorageJMS; -import org.sharengo.wikitty.multistorage.MultiStorageConfiguration; -import org.sharengo.wikitty.multistorage.MultiStorageConfiguration.BasicConfiguration; -import org.sharengo.wikitty.multistorage.WikittyServiceMultiStorage; +import org.nuiton.wikitty.Wikitty; +import org.nuiton.wikitty.WikittyExtension; +import org.nuiton.wikitty.WikittyExtensionStorage; +import org.nuiton.wikitty.WikittyService; +import org.nuiton.wikitty.WikittyStorage; +import org.nuiton.wikitty.jdbc.WikittyExtensionStorageJDBC; +import org.nuiton.wikitty.jdbc.WikittyStorageJDBC; +import org.nuiton.wikitty.jms.WikittyExtensionStorageJMS; +import org.nuiton.wikitty.jms.WikittyJMSUtil; +import org.nuiton.wikitty.jms.WikittyStorageJMS; +import org.nuiton.wikitty.multistorage.MultiStorageConfiguration; +import org.nuiton.wikitty.multistorage.WikittyServiceMultiStorage; +import org.nuiton.wikitty.multistorage.MultiStorageConfiguration.BasicConfiguration; /** * MultiStorageTest build a multi-storage configuration using jdbc and jms Modified: trunk/wikitty-multistorage-impl/src/test/resources/log4j.properties =================================================================== --- trunk/wikitty-multistorage-impl/src/test/resources/log4j.properties 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-multistorage-impl/src/test/resources/log4j.properties 2010-05-12 15:08:48 UTC (rev 53) @@ -6,10 +6,10 @@ log4j.appender.stdout.layout.ConversionPattern=%-5p %-46.46c %4L - %m%n # wikitty -log4j.logger.org.sharengo.wikitty=ERROR -log4j.logger.org.sharengo.wikitty.solr.WikittySearchEngineSolr=DEBUG -log4j.logger.org.sharengo.wikitty.solr.SolrQParser=DEBUG -log4j.logger.org.sharengo.wikitty.jdbc.WikittyJDBCUtil=INFO +log4j.logger.org.nuiton.wikitty=ERROR +log4j.logger.org.nuiton.wikitty.solr.WikittySearchEngineSolr=DEBUG +log4j.logger.org.nuiton.wikitty.solr.SolrQParser=DEBUG +log4j.logger.org.nuiton.wikitty.jdbc.WikittyJDBCUtil=INFO # solr log4j.logger.org.apache.solr=WARN Modified: trunk/wikitty-solr-impl/src/main/java/org/nuiton/wikitty/solr/Restriction2Solr.java =================================================================== --- trunk/wikitty-solr-impl/src/main/java/org/sharengo/wikitty/solr/Restriction2Solr.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-solr-impl/src/main/java/org/nuiton/wikitty/solr/Restriction2Solr.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.solr; +package org.nuiton.wikitty.solr; import java.util.ArrayList; import java.util.Arrays; @@ -10,30 +10,30 @@ import org.apache.solr.client.solrj.response.QueryResponse; import org.apache.solr.common.SolrDocument; import org.apache.solr.common.SolrDocumentList; -import org.sharengo.wikitty.WikittyException; -import org.sharengo.wikitty.WikittyTransaction; -import org.sharengo.wikitty.search.And; -import org.sharengo.wikitty.search.AssociatedRestriction; -import org.sharengo.wikitty.search.Between; -import org.sharengo.wikitty.search.Contains; -import org.sharengo.wikitty.search.Element; -import org.sharengo.wikitty.search.EndsWith; -import org.sharengo.wikitty.search.Equals; -import org.sharengo.wikitty.search.Greater; -import org.sharengo.wikitty.search.GreaterOrEqual; -import org.sharengo.wikitty.search.In; -import org.sharengo.wikitty.search.Keyword; -import org.sharengo.wikitty.search.Less; -import org.sharengo.wikitty.search.LessOrEqual; -import org.sharengo.wikitty.search.Like; -import org.sharengo.wikitty.search.Not; -import org.sharengo.wikitty.search.NotEquals; -import org.sharengo.wikitty.search.Or; -import org.sharengo.wikitty.search.Restriction; -import org.sharengo.wikitty.search.RestrictionHelper; -import org.sharengo.wikitty.search.StartsWith; -import org.sharengo.wikitty.search.Unlike; -import org.sharengo.wikitty.search.Like.SearchAs; +import org.nuiton.wikitty.WikittyException; +import org.nuiton.wikitty.WikittyTransaction; +import org.nuiton.wikitty.search.And; +import org.nuiton.wikitty.search.AssociatedRestriction; +import org.nuiton.wikitty.search.Between; +import org.nuiton.wikitty.search.Contains; +import org.nuiton.wikitty.search.Element; +import org.nuiton.wikitty.search.EndsWith; +import org.nuiton.wikitty.search.Equals; +import org.nuiton.wikitty.search.Greater; +import org.nuiton.wikitty.search.GreaterOrEqual; +import org.nuiton.wikitty.search.In; +import org.nuiton.wikitty.search.Keyword; +import org.nuiton.wikitty.search.Less; +import org.nuiton.wikitty.search.LessOrEqual; +import org.nuiton.wikitty.search.Like; +import org.nuiton.wikitty.search.Not; +import org.nuiton.wikitty.search.NotEquals; +import org.nuiton.wikitty.search.Or; +import org.nuiton.wikitty.search.Restriction; +import org.nuiton.wikitty.search.RestrictionHelper; +import org.nuiton.wikitty.search.StartsWith; +import org.nuiton.wikitty.search.Unlike; +import org.nuiton.wikitty.search.Like.SearchAs; /** * @author "Nicolas Chapurlat" <nicolas.chapurlat@logica.com> Modified: trunk/wikitty-solr-impl/src/main/java/org/nuiton/wikitty/solr/WikittyQueryParser.java =================================================================== --- trunk/wikitty-solr-impl/src/main/java/org/sharengo/wikitty/solr/WikittyQueryParser.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-solr-impl/src/main/java/org/nuiton/wikitty/solr/WikittyQueryParser.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,4 +1,4 @@ -package org.sharengo.wikitty.solr; +package org.nuiton.wikitty.solr; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; Modified: trunk/wikitty-solr-impl/src/main/java/org/nuiton/wikitty/solr/WikittySearchEnginSolr.java =================================================================== --- trunk/wikitty-solr-impl/src/main/java/org/sharengo/wikitty/solr/WikittySearchEnginSolr.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-solr-impl/src/main/java/org/nuiton/wikitty/solr/WikittySearchEnginSolr.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,7 +15,7 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.solr; +package org.nuiton.wikitty.solr; import java.io.IOException; import java.util.ArrayList; @@ -39,21 +39,21 @@ import org.apache.solr.common.SolrDocumentList; import org.apache.solr.common.SolrInputDocument; import org.apache.solr.core.CoreContainer; -import org.sharengo.wikitty.Criteria; -import org.sharengo.wikitty.FacetTopic; -import org.sharengo.wikitty.FieldType; -import org.sharengo.wikitty.PagedResult; -import org.sharengo.wikitty.TreeNode; -import org.sharengo.wikitty.UpdateResponse; -import org.sharengo.wikitty.Wikitty; -import org.sharengo.wikitty.WikittyException; -import org.sharengo.wikitty.WikittyExtension; -import org.sharengo.wikitty.WikittyExtensionStorage; -import org.sharengo.wikitty.WikittySearchEngin; -import org.sharengo.wikitty.WikittyTransaction; -import org.sharengo.wikitty.FieldType.TYPE; -import org.sharengo.wikitty.search.Element; -import org.sharengo.wikitty.search.Search; +import org.nuiton.wikitty.Criteria; +import org.nuiton.wikitty.FacetTopic; +import org.nuiton.wikitty.FieldType; +import org.nuiton.wikitty.PagedResult; +import org.nuiton.wikitty.UpdateResponse; +import org.nuiton.wikitty.Wikitty; +import org.nuiton.wikitty.WikittyException; +import org.nuiton.wikitty.WikittyExtension; +import org.nuiton.wikitty.WikittyExtensionStorage; +import org.nuiton.wikitty.WikittySearchEngin; +import org.nuiton.wikitty.WikittyTransaction; +import org.nuiton.wikitty.FieldType.TYPE; +import org.nuiton.wikitty.search.Element; +import org.nuiton.wikitty.search.Search; +import org.nuiton.wikitty.TreeNode; import com.arjuna.ats.arjuna.coordinator.BasicAction; import com.arjuna.ats.arjuna.coordinator.OnePhaseResource; Modified: trunk/wikitty-solr-impl/src/main/resources/solrconfig.xml =================================================================== --- trunk/wikitty-solr-impl/src/main/resources/solrconfig.xml 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-solr-impl/src/main/resources/solrconfig.xml 2010-05-12 15:08:48 UTC (rev 53) @@ -678,7 +678,7 @@ </queryResponseWriter> - <queryParser name="wikitty" class="org.sharengo.wikitty.solr.WikittyQueryParser"/> + <queryParser name="wikitty" class="org.nuiton.wikitty.solr.WikittyQueryParser"/> <!-- example of registering a query parser <queryParser name="lucene" class="org.apache.solr.search.LuceneQParserPlugin"/> Modified: trunk/wikitty-solr-impl/src/test/java/org/nuiton/wikitty/solr/test/AbstractTestSolr.java =================================================================== --- trunk/wikitty-solr-impl/src/test/java/org/sharengo/wikitty/solr/test/AbstractTestSolr.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-solr-impl/src/test/java/org/nuiton/wikitty/solr/test/AbstractTestSolr.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,12 +1,12 @@ -package org.sharengo.wikitty.solr.test; +package org.nuiton.wikitty.solr.test; import org.junit.runner.RunWith; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import org.junit.Before; -import org.sharengo.wikitty.WikittySearchEngin; -import org.sharengo.wikitty.WikittyService; +import org.nuiton.wikitty.WikittySearchEngin; +import org.nuiton.wikitty.WikittyService; import org.springframework.beans.factory.annotation.Autowired; @RunWith(SpringJUnit4ClassRunner.class) Modified: trunk/wikitty-solr-impl/src/test/java/org/nuiton/wikitty/solr/test/SolrSearchTest.java =================================================================== --- trunk/wikitty-solr-impl/src/test/java/org/sharengo/wikitty/solr/test/SolrSearchTest.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-solr-impl/src/test/java/org/nuiton/wikitty/solr/test/SolrSearchTest.java 2010-05-12 15:08:48 UTC (rev 53) @@ -1,8 +1,7 @@ -package org.sharengo.wikitty.solr.test; +package org.nuiton.wikitty.solr.test; import static junit.framework.Assert.assertEquals; import static junit.framework.Assert.assertTrue; -import org.sharengo.wikitty.FacetTopic; import java.util.ArrayList; import java.util.List; @@ -11,18 +10,19 @@ import org.apache.commons.logging.LogFactory; import org.junit.Test; import org.junit.Before; -import org.sharengo.wikitty.Criteria; -import org.sharengo.wikitty.PagedResult; -import org.sharengo.wikitty.Wikitty; -import org.sharengo.wikitty.WikittyExtension; -import org.sharengo.wikitty.WikittyUtil; -import org.sharengo.wikitty.search.Element; -import org.sharengo.wikitty.search.Like; -import org.sharengo.wikitty.search.RestrictionHelper; -import org.sharengo.wikitty.search.Search; -import org.sharengo.wikitty.search.Like.SearchAs; -import org.sharengo.wikitty.test.conform.AbstractTestConformance; -import org.sharengo.wikitty.test.conform.StorageTest; +import org.nuiton.wikitty.Criteria; +import org.nuiton.wikitty.FacetTopic; +import org.nuiton.wikitty.PagedResult; +import org.nuiton.wikitty.Wikitty; +import org.nuiton.wikitty.WikittyExtension; +import org.nuiton.wikitty.WikittyUtil; +import org.nuiton.wikitty.search.Element; +import org.nuiton.wikitty.search.Like; +import org.nuiton.wikitty.search.RestrictionHelper; +import org.nuiton.wikitty.search.Search; +import org.nuiton.wikitty.search.Like.SearchAs; +import org.nuiton.wikitty.test.conform.AbstractTestConformance; +import org.nuiton.wikitty.test.conform.StorageTest; public class SolrSearchTest extends AbstractTestSolr { Modified: trunk/wikitty-solr-impl/src/test/java/org/nuiton/wikitty/solr/test/SolrServerTest.java =================================================================== --- trunk/wikitty-solr-impl/src/test/java/org/sharengo/wikitty/solr/test/SolrServerTest.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-solr-impl/src/test/java/org/nuiton/wikitty/solr/test/SolrServerTest.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,7 +15,7 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.solr.test; +package org.nuiton.wikitty.solr.test; import static junit.framework.Assert.assertNotNull; import static junit.framework.Assert.assertNull; Modified: trunk/wikitty-solr-impl/src/test/java/org/nuiton/wikitty/solr/test/TreeTest.java =================================================================== --- trunk/wikitty-solr-impl/src/test/java/org/sharengo/wikitty/solr/test/TreeTest.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-solr-impl/src/test/java/org/nuiton/wikitty/solr/test/TreeTest.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,7 +15,7 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.solr.test; +package org.nuiton.wikitty.solr.test; import java.util.Map.Entry; import java.util.Set; @@ -30,17 +30,16 @@ import org.apache.commons.logging.LogFactory; import org.junit.Before; import org.junit.Test; -import org.sharengo.wikitty.TreeNodeImpl; -import org.sharengo.wikitty.Criteria; -import org.sharengo.wikitty.ExtensionFactory; -import org.sharengo.wikitty.Tree; -import org.sharengo.wikitty.TreeNode; -import org.sharengo.wikitty.Wikitty; -import org.sharengo.wikitty.WikittyExtension; -import org.sharengo.wikitty.FieldType.TYPE; -import org.sharengo.wikitty.TreeNode; -import org.sharengo.wikitty.search.Search; -import org.sharengo.wikitty.test.conform.StorageTest; +import org.nuiton.wikitty.Criteria; +import org.nuiton.wikitty.ExtensionFactory; +import org.nuiton.wikitty.Tree; +import org.nuiton.wikitty.Wikitty; +import org.nuiton.wikitty.WikittyExtension; +import org.nuiton.wikitty.FieldType.TYPE; +import org.nuiton.wikitty.search.Search; +import org.nuiton.wikitty.test.conform.StorageTest; +import org.nuiton.wikitty.TreeNodeImpl; +import org.nuiton.wikitty.TreeNode; /** * Modified: trunk/wikitty-solr-impl/src/test/java/org/nuiton/wikitty/solr/test/WikittyServiceSolr.java =================================================================== --- trunk/wikitty-solr-impl/src/test/java/org/sharengo/wikitty/solr/test/WikittyServiceSolr.java 2010-05-11 17:31:27 UTC (rev 49) +++ trunk/wikitty-solr-impl/src/test/java/org/nuiton/wikitty/solr/test/WikittyServiceSolr.java 2010-05-12 15:08:48 UTC (rev 53) @@ -15,16 +15,16 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. *##%*/ -package org.sharengo.wikitty.solr.test; +package org.nuiton.wikitty.solr.test; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.sharengo.wikitty.AbstractWikittyService; -import org.sharengo.wikitty.WikittyExtensionStorage; -import org.sharengo.wikitty.WikittySearchEngin; -import org.sharengo.wikitty.WikittyServiceInMemory; -import org.sharengo.wikitty.WikittyStorage; -import org.sharengo.wikitty.solr.WikittySearchEnginSolr; +import org.nuiton.wikitty.AbstractWikittyService; +import org.nuiton.wikitty.WikittyExtensionStorage; +import org.nuiton.wikitty.WikittySearchEngin; +import org.nuiton.wikitty.WikittyServiceInMemory; +import org.nuiton.wikitty.WikittyStorage; +import org.nuiton.wikitty.solr.WikittySearchEnginSolr; /** * Modified: trunk/wikitty-solr-impl/src/test/resources/META-INF/spring/wikitty-test.xml =================================================================== --- trunk/wikitty-solr-impl/src/test/resources/META-INF/spring/wikitty-test.xml 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-solr-impl/src/test/resources/META-INF/spring/wikitty-test.xml 2010-05-12 15:08:48 UTC (rev 53) @@ -6,9 +6,9 @@ xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd"> - <bean name="wikittyService" class="org.sharengo.wikitty.solr.test.WikittyServiceSolr"/> + <bean name="wikittyService" class="org.nuiton.wikitty.solr.test.WikittyServiceSolr"/> <context:annotation-config/> - <context:component-scan base-package="org.sharengo.wikitty"/> + <context:component-scan base-package="org.nuiton.wikitty"/> </beans> \ No newline at end of file Modified: trunk/wikitty-solr-impl/src/test/resources/log4j.properties =================================================================== --- trunk/wikitty-solr-impl/src/test/resources/log4j.properties 2010-05-12 10:19:55 UTC (rev 52) +++ trunk/wikitty-solr-impl/src/test/resources/log4j.properties 2010-05-12 15:08:48 UTC (rev 53) @@ -5,5 +5,5 @@ # Configuration by components log4j.rootLogger=DEBUG, logConsole -log4j.category.org.sharengo.wikitty=DEBUG +log4j.category.org.nuiton.wikitty=DEBUG #log4j.category.org.apache.solr=DEBUG