Author: tchemit Date: 2012-08-22 18:20:46 +0200 (Wed, 22 Aug 2012) New Revision: 457 Url: http://forge.codelutin.com/repositories/revision/sammoa/457 Log: refs #1269: Import/Export base H2 (review import/export) Added: trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/SammoaImportModelFactory.java trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/strategy/ trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/strategy/AbstractImportStrategy.java trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/strategy/DataImportStrategy.java trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/strategy/ReferentialImportStrategy.java trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/output/application/SammoaPrepareDataForExport.java trunk/sammoa-persistence/src/main/java/fr/ulr/sammoa/persistence/SammoaDbMeta.java trunk/sammoa-persistence/src/test/java/fr/ulr/sammoa/persistence/SammoaDbMetaTest.java Removed: trunk/sammoa-persistence/src/main/java/fr/ulr/sammoa/persistence/SammoaDbMetas.java trunk/sammoa-persistence/src/test/java/fr/ulr/sammoa/persistence/SammoaDbMetasTest.java Modified: trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/FlightService.java trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/CampaignStorage.java trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/FlightStorage.java trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/SammoaStorage.java trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/SammoaStorages.java trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/ImportApplicationModel.java trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/ImportApplicationService.java trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/output/application/ExportApplicationService.java trunk/sammoa-persistence/src/main/java/fr/ulr/sammoa/persistence/SammoaPersistence.java trunk/sammoa-persistence/src/main/java/fr/ulr/sammoa/persistence/SammoaPersistenceHelper.java trunk/sammoa-ui-swing/src/main/java/fr/ulr/sammoa/ui/swing/io/input/application/ImportApplicationUIHandler.java trunk/sammoa-ui-swing/src/main/java/fr/ulr/sammoa/ui/swing/io/input/application/ImportApplicationUIModel.java trunk/src/site/rst/import-export.rst Modified: trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/FlightService.java =================================================================== --- trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/FlightService.java 2012-08-22 09:08:00 UTC (rev 456) +++ trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/FlightService.java 2012-08-22 16:20:46 UTC (rev 457) @@ -31,7 +31,6 @@ import com.google.common.collect.Lists; import com.google.common.collect.Sets; import fr.ulr.sammoa.application.io.CampaignStorage; -import fr.ulr.sammoa.application.io.FlightStorage; import fr.ulr.sammoa.application.io.SammoaStorages; import fr.ulr.sammoa.persistence.AutoSaveListener; import fr.ulr.sammoa.persistence.Campaign; @@ -71,7 +70,6 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import java.io.IOException; import java.util.Collection; import java.util.Collections; import java.util.Date; @@ -312,15 +310,7 @@ // delete flight storage CampaignStorage campaignStorage = getCampaignStorage(campaignId); - FlightStorage flightStorage = - campaignStorage.getFlightStorage(flightId); - - try { - flightStorage.delete(); - } catch (IOException e) { - throw new SammoaTechnicalException( - "Could not delete flight storage", e); - } + campaignStorage.deleteFlightStorage(flightId); } /** @@ -362,7 +352,6 @@ ObservationDAO observationDAO = SammoaDAOHelper.getObservationDAO(tx); observationDAO.deleteAll(observations); - // delete observationPositions ObserverPositionDAO observerPositionDAO = SammoaDAOHelper.getObserverPositionDAO(tx); observerPositionDAO.deleteAll(positions); Modified: trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/CampaignStorage.java =================================================================== --- trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/CampaignStorage.java 2012-08-22 09:08:00 UTC (rev 456) +++ trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/CampaignStorage.java 2012-08-22 16:20:46 UTC (rev 457) @@ -29,8 +29,10 @@ import com.google.common.collect.Maps; import com.google.common.collect.Sets; import fr.ulr.sammoa.application.DecoratorService; +import fr.ulr.sammoa.application.SammoaTechnicalException; import fr.ulr.sammoa.persistence.Campaign; import fr.ulr.sammoa.persistence.Region; +import org.apache.commons.io.FileUtils; import org.apache.commons.io.filefilter.DirectoryFileFilter; import org.apache.commons.lang3.builder.ToStringBuilder; import org.nuiton.util.decorator.Decorator; @@ -38,6 +40,7 @@ import org.slf4j.LoggerFactory; import java.io.File; +import java.io.IOException; import java.util.Iterator; import java.util.Map; import java.util.Set; @@ -52,7 +55,9 @@ private static final long serialVersionUID = 1L; - /** Logger. */ + /** + * Logger. + */ private static final Logger logger = LoggerFactory.getLogger(CampaignStorage.class); @@ -74,10 +79,6 @@ return new File(getDirectory(), "flight"); } - public File getCsvDirectory() { - return new File(getDirectory(), "csv"); - } - public Set<String> getFlightIds() { String[] files = getFlightDirectory().list(DirectoryFileFilter.INSTANCE); Set<String> result = files == null ? @@ -162,4 +163,25 @@ append("nbFlightStoragesLoaded", flightStorages == null ? 0 : flightStorages.size()). toString(); } + + public void deleteFlightStorage(String flightId) { + Preconditions.checkNotNull(flightId); + Preconditions.checkArgument(getFlightIds().contains(flightId)); + FlightStorage flightStorage = getFlightStorage(flightId); + try { + flightStorage.delete(); + } catch (IOException e) { + throw new SammoaTechnicalException( + "Could not delete flight storage", e); + } + } + + public void deletePropertiesFiles() { + + FileUtils.deleteQuietly(getPropertiesFile()); + + for (FlightStorage flightStorage : this) { + FileUtils.deleteQuietly(flightStorage.getPropertiesFile()); + } + } } Modified: trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/FlightStorage.java =================================================================== --- trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/FlightStorage.java 2012-08-22 09:08:00 UTC (rev 456) +++ trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/FlightStorage.java 2012-08-22 16:20:46 UTC (rev 457) @@ -28,8 +28,8 @@ import fr.ulr.sammoa.persistence.Campaign; import fr.ulr.sammoa.persistence.Flight; import fr.ulr.sammoa.persistence.Region; +import fr.ulr.sammoa.persistence.Route; import org.apache.commons.lang3.builder.ToStringBuilder; -import fr.ulr.sammoa.persistence.Route; import org.nuiton.util.decorator.Decorator; import java.io.File; Modified: trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/SammoaStorage.java =================================================================== --- trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/SammoaStorage.java 2012-08-22 09:08:00 UTC (rev 456) +++ trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/SammoaStorage.java 2012-08-22 16:20:46 UTC (rev 457) @@ -49,16 +49,24 @@ private static final long serialVersionUID = 1L; - /** Root directory for this storage. */ + /** + * Root directory for this storage. + */ private final File directory; - /** Id of the storage. */ + /** + * Id of the storage. + */ private final String id; - /** Properties of the storage. */ + /** + * Properties of the storage. + */ private final Properties properties; - /** Name of the properties file of the storage. */ + /** + * Name of the properties file of the storage. + */ private final String propertiesFilename; public abstract Map<String, Object> getNaturalId(); @@ -83,6 +91,10 @@ return directory; } + public File getCsvDirectory() { + return new File(getDirectory(), "csv"); + } + public File getPropertiesFile() { return new File(directory, propertiesFilename); } Modified: trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/SammoaStorages.java =================================================================== --- trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/SammoaStorages.java 2012-08-22 09:08:00 UTC (rev 456) +++ trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/SammoaStorages.java 2012-08-22 16:20:46 UTC (rev 457) @@ -54,40 +54,41 @@ } } - public static CampaignStorage copyCampaignStorage(CampaignStorage source, - File targetDirectory, - boolean createCsvDirectory, - Iterable<String> flightIds) { + public static void copyCampaignStorage(CampaignStorage source, + CampaignStorage target, + Iterable<String> flightIds) { try { - CampaignStorage target = new CampaignStorage(targetDirectory, - source.getId()); - createEmptyCampaignStructure(target); + FileUtils.copyDirectory(source.getMapDirectory(), target.getMapDirectory()); - if (createCsvDirectory) { - FileUtils.forceMkdir(target.getCsvDirectory()); - } - if (source.getCsvDirectory().exists()) { - FileUtils.copyDirectory(source.getCsvDirectory(), - target.getCsvDirectory()); - } for (String flightId : flightIds) { FlightStorage flightStorage = source.getFlightStorage(flightId); FlightStorage targetFlightStorage = target.getFlightStorage(flightStorage.getId()); - FileUtils.copyDirectory(flightStorage.getDirectory(), - targetFlightStorage.getDirectory()); + copyFlightStorage(flightStorage, targetFlightStorage); + } - return target; } catch (IOException e) { throw new SammoaTechnicalException("Could not copy campaign storage", e); } } + public static void copyFlightStorage(FlightStorage source, + FlightStorage target) { + + try { + + FileUtils.copyDirectory(source.getAudioDirectory(), + target.getAudioDirectory()); + } catch (IOException e) { + throw new SammoaTechnicalException("Could not copy flight storage", e); + } + } + public static FlightStorage createFlightStorage(CampaignStorage source, String flightId) { try { Modified: trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/ImportApplicationModel.java =================================================================== --- trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/ImportApplicationModel.java 2012-08-22 09:08:00 UTC (rev 456) +++ trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/ImportApplicationModel.java 2012-08-22 16:20:46 UTC (rev 457) @@ -34,26 +34,54 @@ */ public class ImportApplicationModel { - public static ImportApplicationModel newModel(CampaignStorage storage, - Iterable<String> flightIds) { + public static ImportApplicationModel newModel( + CampaignStorage storage, + CampaignStorage oldStorage, + Iterable<String> flightIds, + Iterable<String> flightToRemoveIds + ) { ImportApplicationModel result = new ImportApplicationModel(); result.storage = storage; + result.oldStorage = oldStorage; result.flightIds = flightIds; + result.flightToRemoveIds = flightToRemoveIds; return result; } - /** Loaded campaign storage. */ + /** + * Loaded campaign storage. + */ protected CampaignStorage storage; + /** + * Existing storage (where to remove old flight. + */ + protected CampaignStorage oldStorage; - /** All flight ids to import from the import file. */ + /** + * All flight ids to import from the import file. + */ + protected Iterable<String> flightToRemoveIds; + + /** + * All flight ids to remove from application. + */ protected Iterable<String> flightIds; + public CampaignStorage getStorage() { return storage; } + public CampaignStorage getOldStorage() { + return oldStorage; + } + public Iterable<String> getFlightIds() { return flightIds; } + + public Iterable<String> getFlightToRemoveIds() { + return flightToRemoveIds; + } } \ No newline at end of file Modified: trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/ImportApplicationService.java =================================================================== --- trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/ImportApplicationService.java 2012-08-22 09:08:00 UTC (rev 456) +++ trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/ImportApplicationService.java 2012-08-22 16:20:46 UTC (rev 457) @@ -25,33 +25,30 @@ import com.google.common.base.Preconditions; import com.google.common.collect.Lists; -import com.google.common.collect.Maps; import com.google.common.io.Files; +import fr.ulr.sammoa.application.FlightService; +import fr.ulr.sammoa.application.ReferentialService; +import fr.ulr.sammoa.application.SammoaContext; import fr.ulr.sammoa.application.SammoaServiceSupport; import fr.ulr.sammoa.application.SammoaTechnicalException; import fr.ulr.sammoa.application.io.CampaignStorage; import fr.ulr.sammoa.application.io.SammoaStorages; -import fr.ulr.sammoa.persistence.SammoaDbMetas; +import fr.ulr.sammoa.application.io.input.application.strategy.DataImportStrategy; +import fr.ulr.sammoa.application.io.input.application.strategy.ReferentialImportStrategy; +import fr.ulr.sammoa.persistence.Campaign; +import fr.ulr.sammoa.persistence.SammoaDbMeta; import fr.ulr.sammoa.persistence.SammoaEntityEnum; -import fr.ulr.sammoa.persistence.SammoaPersistenceHelper; import org.apache.commons.io.Charsets; +import org.apache.commons.io.FileUtils; import org.apache.commons.io.filefilter.DirectoryFileFilter; import org.nuiton.topia.TopiaContext; import org.nuiton.topia.TopiaException; -import org.nuiton.topia.persistence.TopiaDAO; -import org.nuiton.topia.persistence.TopiaEntity; -import org.nuiton.topia.persistence.csv.EntityCsvModel; -import org.nuiton.topia.persistence.csv.in.ImportModelFactory; import org.nuiton.topia.persistence.csv.in.TopiaCsvImports; import org.nuiton.topia.persistence.metadata.AssociationMeta; -import org.nuiton.topia.persistence.metadata.ColumnMeta; -import org.nuiton.topia.persistence.metadata.DbMeta; import org.nuiton.topia.persistence.metadata.MetaFilenameAware; import org.nuiton.topia.persistence.metadata.TableMeta; import org.nuiton.util.TimeLog; import org.nuiton.util.ZipUtil; -import org.nuiton.util.csv.Import; -import org.nuiton.util.csv.ImportModel; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -59,7 +56,6 @@ import java.io.FileFilter; import java.io.IOException; import java.io.Reader; -import java.util.Date; import java.util.List; import java.util.Map; @@ -78,6 +74,17 @@ private static final TimeLog timeLog = new TimeLog(ImportApplicationService.class); + private FlightService flightService; + + private ReferentialService referentialService; + + @Override + public void setSammoaContext(SammoaContext context) { + super.setSammoaContext(context); + flightService = getService(FlightService.class); + referentialService = getService(ReferentialService.class); + } + public CampaignStorage loadCampaignStorage(File file) { File tmpDirectory = context.getConfig().getTmpDirectory(); File deflateDirectory = new File(tmpDirectory, file.getName() + "_" + System.nanoTime()); @@ -104,50 +111,101 @@ public void importApplication(ImportApplicationModel model) { - CampaignStorage storage = model.getStorage(); - if (logger.isInfoEnabled()) { logger.info("Start Application import to {} :: {}", - storage); + model.getStorage()); } long startTime = TimeLog.getTime(); - DbMeta<SammoaEntityEnum> dbMetas = persistence.getDbMetas(); - SammoaPersistenceHelper persistenceHelper = persistence.getPersistenceHelper(); - MetaFilenameAware<SammoaEntityEnum>[] referencialEntries = SammoaDbMetas.getReferencialEntries(dbMetas); + importDb(model); - List<String> missingEntries = Lists.newArrayList(); - Map<MetaFilenameAware<SammoaEntityEnum>, File> fileMap = TopiaCsvImports.discoverEntries( - referencialEntries, - storage.getCsvDirectory(), - missingEntries); + startTime = timeLog.log(startTime, "importApplication", "after db import"); - Preconditions.checkState( - missingEntries.isEmpty(), - "It miss some csv files for referential import :" + - missingEntries); + try { + importStorages(model); - Map<SammoaEntityEnum, Map<String, TopiaEntity>> universe = Maps.newTreeMap(); - SammoaImportModelFactory modelFactory = new SammoaImportModelFactory(universe); + } catch (IOException e) { + throw new SammoaTechnicalException( + "Could not delete storage", e); + } + timeLog.log(startTime, "importApplication", "after import storages"); + } + + protected void importDb(ImportApplicationModel model) { + TopiaContext tx = beginTransaction(); try { - for (MetaFilenameAware<SammoaEntityEnum> entry : referencialEntries) { + long startTime = TimeLog.getTime(); - File entryFile = fileMap.get(entry); - TopiaDAO<? extends TopiaEntity> dao = persistenceHelper.getDAO(tx, entry.getSource().getContract()); - importReferential(dao, - modelFactory, - entryFile, - (TableMeta<SammoaEntityEnum>) entry); + CampaignStorage oldStorage = model.getOldStorage(); + if (oldStorage != null) { + + // there is an existing campaign + // revmoe old flights which will be imported + + Iterable<String> flightToRemoveIds = model.getFlightToRemoveIds(); + for (String flightId : flightToRemoveIds) { + flightService.deleteFlightInDb(tx, flightId); + } } tx.commitTransaction(); - startTime = timeLog.log(startTime, "importApplication", "after referential import"); + startTime = timeLog.log(startTime, "importDb", + "after flights delete"); + + CampaignStorage storage = model.getStorage(); + + SammoaDbMeta dbMetas = persistence.getDbMetas(); + + Map<TableMeta<SammoaEntityEnum>, File> tableMap; + Map<AssociationMeta<SammoaEntityEnum>, File> associationMap; + + tableMap = getEntries(dbMetas.getReferentialTables(), storage); + associationMap = getEntries(dbMetas.getReferentialAssociations(), storage); + Preconditions.checkArgument( + associationMap.isEmpty(), + "No association to import from referential"); + + SammoaImportModelFactory modelFactory = + new SammoaImportModelFactory(config.getCsvSeparator(), + tx, + dbMetas); + + try { + importReferentials(tx, modelFactory, tableMap); + + tx.commitTransaction(); + + startTime = timeLog.log(startTime, "importDb", + "after referential import"); + + tableMap = getEntries(dbMetas.getDataTables(), storage); + associationMap = getEntries(dbMetas.getDataAssociations(), storage); + + DataImportStrategy strategy = new DataImportStrategy( + modelFactory, tx, persistence.getPersistenceHelper() + ); + for (String flightId : model.getFlightIds()) { + + importFlight(tx, + strategy, + tableMap, + associationMap, + flightId); + } + } finally { + modelFactory.close(); + } + + tx.commitTransaction(); + + timeLog.log(startTime, "importDb", "after data import"); + } catch (TopiaException e) { throw new SammoaTechnicalException("Could not import", e); } catch (IOException e) { @@ -155,139 +213,126 @@ } finally { endTransaction(tx); } + } - try { - storage.delete(); - } catch (IOException e) { - throw new SammoaTechnicalException( - "Could not delete storage", e); - } + private void importFlight(TopiaContext tx, + DataImportStrategy strategy, + Map<TableMeta<SammoaEntityEnum>, File> tableMap, + Map<AssociationMeta<SammoaEntityEnum>, File> associationMap, + String flightId) throws IOException, TopiaException { - timeLog.log(startTime, "importApplication", "after Callback execution"); - } + for (Map.Entry<TableMeta<SammoaEntityEnum>, File> entry : tableMap.entrySet()) { + TableMeta<SammoaEntityEnum> meta = entry.getKey(); + File file = entry.getValue(); - protected <E extends TopiaEntity> void importReferential(TopiaDAO<E> dao, - SammoaImportModelFactory modelFactory, - File entryFile, - TableMeta<SammoaEntityEnum> meta) throws IOException, TopiaException { + Reader reader = Files.newReader(file, Charsets.UTF_8); + try { - SammoaEntityEnum entityEnum = meta.getSource(); + TopiaCsvImports.importTable(reader, strategy, meta, null); - // create new universe - Map<String, TopiaEntity> universe = Maps.newTreeMap(); - modelFactory.getUniverse().put(entityEnum, universe); + } finally { + reader.close(); - Reader reader = Files.newReader(entryFile, Charsets.UTF_8); - try { - long s0 = TimeLog.getTime(); + } + } - if (logger.isInfoEnabled()) { - logger.info("Will import " + meta); - } - ImportModel<TopiaEntity> model = modelFactory.buildForImport(meta); - Import<TopiaEntity> importer = Import.newImport(model, reader); + for (Map.Entry<AssociationMeta<SammoaEntityEnum>, File> entry : associationMap.entrySet()) { + AssociationMeta<SammoaEntityEnum> meta = entry.getKey(); + File file = entry.getValue(); + + Reader reader = Files.newReader(file, Charsets.UTF_8); try { - for (TopiaEntity entity : importer) { + TopiaCsvImports.importAssociation(reader, strategy, meta, null); - String topiaId = entity.getTopiaId(); + } finally { + reader.close(); + } + } - Map<String, Object> properties = meta.prepareCreate(entity, null); - E existingEntity = dao.findByProperties(properties); - if (existingEntity == null) { + } - // new entity to create - E entityToSave = dao.create(properties); - String newTopiaId = entityToSave.getTopiaId(); - Date topiaCreateDate = entityToSave.getTopiaCreateDate(); - meta.copy(entity, entityToSave); - entityToSave.setTopiaId(newTopiaId); - entityToSave.setTopiaCreateDate(topiaCreateDate); + private void importReferentials(TopiaContext tx, + SammoaImportModelFactory modelFactory, + Map<TableMeta<SammoaEntityEnum>, File> tableMap) throws IOException, TopiaException { - if (logger.isInfoEnabled()) { - logger.info("Create entity [{} becomes {}] with naturalId {}", new Object[]{topiaId, newTopiaId, properties}); - } - universe.put(topiaId, entityToSave); - } else { - // existing entity, nothing to create - // just add a ref into universe to make translation possible by foreign keys + ReferentialImportStrategy strategy = new ReferentialImportStrategy( + modelFactory, tx, persistence.getPersistenceHelper() + ); - if (logger.isDebugEnabled()) { - logger.debug("Existing entity [{}] with naturalId {}, do not create anything", topiaId, properties); - } - universe.put(topiaId, existingEntity); - } + for (Map.Entry<TableMeta<SammoaEntityEnum>, File> entry : tableMap.entrySet()) { + TableMeta<SammoaEntityEnum> meta = entry.getKey(); + File file = entry.getValue(); - } + Reader reader = Files.newReader(file, Charsets.UTF_8); + try { + TopiaCsvImports.importTable(reader, strategy, meta, null); + } finally { - importer.close(); + reader.close(); + } + } + } - timeLog.log(s0, "importFile::done"); + protected <M extends MetaFilenameAware<SammoaEntityEnum>> Map<M, File> getEntries( + List<M> metas, CampaignStorage storage) { - s0 = TimeLog.getTime(); + List<String> missingEntries = Lists.newArrayList(); + Map<M, File> result = TopiaCsvImports.discoverEntries( + metas, + storage.getCsvDirectory(), + missingEntries); + Preconditions.checkState( + missingEntries.isEmpty(), + "There is some csv files for import:" + missingEntries); + return result; + } - persistence.flushTransaction(dao.getContext()); + protected void importStorages(ImportApplicationModel model) throws IOException { - timeLog.log(s0, "importFile::flushTransaction"); - } finally { - reader.close(); - } - } + //storage to copy + CampaignStorage storageToCopy = model.getStorage(); + try { + CampaignStorage oldStorage = model.getOldStorage(); + if (oldStorage != null) { - protected class SammoaImportModelFactory implements ImportModelFactory<SammoaEntityEnum> { + // there is an existing campaign - final Map<SammoaEntityEnum, Map<String, TopiaEntity>> universe; + Iterable<String> flightToRemoveIds = model.getFlightToRemoveIds(); + for (String flightId : flightToRemoveIds) { + oldStorage.deleteFlightStorage(flightId); + } - private SammoaImportModelFactory(Map<SammoaEntityEnum, Map<String, TopiaEntity>> universe) { - this.universe = universe; - } + FileUtils.deleteDirectory(oldStorage.getMapDirectory()); + } - public Map<SammoaEntityEnum, Map<String, TopiaEntity>> getUniverse() { - return universe; - } + FileUtils.deleteDirectory(storageToCopy.getCsvDirectory()); - public <E extends TopiaEntity> Import<E> newModel(TableMeta<SammoaEntityEnum> meta, Reader reader) { - ImportModel<E> model = buildForImport(meta); - Import<E> importer = Import.newImport(model, reader); - return importer; - } + // get the new campaign from db using his naturalId + Campaign newCampaign = referentialService.getCampaignByNaturalId( + storageToCopy.getNaturalId()); + Preconditions.checkNotNull(newCampaign); - @Override - public <E extends TopiaEntity> ImportModel<E> buildForImport(TableMeta<SammoaEntityEnum> meta) { + // create the new empty (or not) campaign storage + CampaignStorage newStorage = SammoaStorages.createCampaignStorage( + config.getCampaignDirectory(), newCampaign.getTopiaId()); - EntityCsvModel<SammoaEntityEnum, E> model = EntityCsvModel.newModel( - config.getCsvSeparator(), - meta, - TopiaEntity.TOPIA_ID - ); + // remove properties files from storage + storageToCopy.deletePropertiesFiles(); - for (ColumnMeta columnMeta : meta) { - String propertyName = columnMeta.getName(); - Class<?> type = columnMeta.getType(); - if (!columnMeta.isFK()) { - model.addDefaultColumn(propertyName, type); - } else { + // recopy storage (and selected flight ids) to new storage + SammoaStorages.copyCampaignStorage(storageToCopy, + newStorage, + model.getFlightIds()); + } finally { - Class<TopiaEntity> entityType = (Class<TopiaEntity>) type; - SammoaEntityEnum entityEnum = SammoaEntityEnum.valueOf(entityType); - Map<String, TopiaEntity> entitiesbyId = universe.get(entityEnum); - model.addForeignKeyForImport(propertyName, entityType, entitiesbyId); - } - } - return model; + // at the end remove the storage to copy + storageToCopy.delete(); } + } - @Override - public ImportModel<Map<String, Object>> buildForImport(AssociationMeta<SammoaEntityEnum> meta) { - return null; - } - @Override - public boolean isNMAssociationMeta(AssociationMeta<SammoaEntityEnum> meta) { - return false; - } - } } \ No newline at end of file Added: trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/SammoaImportModelFactory.java =================================================================== --- trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/SammoaImportModelFactory.java (rev 0) +++ trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/SammoaImportModelFactory.java 2012-08-22 16:20:46 UTC (rev 457) @@ -0,0 +1,139 @@ +package fr.ulr.sammoa.application.io.input.application; +/* + * #%L + * SAMMOA :: Application + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2012 UMS 3462, Code Lutin + * %% + * 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/gpl-3.0.html>. + * #L% + */ + +import com.google.common.collect.Maps; +import fr.ulr.sammoa.persistence.SammoaDbMeta; +import fr.ulr.sammoa.persistence.SammoaEntityEnum; +import org.nuiton.topia.TopiaContext; +import org.nuiton.topia.TopiaException; +import org.nuiton.topia.TopiaRuntimeException; +import org.nuiton.topia.persistence.TopiaEntity; +import org.nuiton.topia.persistence.csv.EntityCsvModel; +import org.nuiton.topia.persistence.csv.in.EntityAssociationImportModel; +import org.nuiton.topia.persistence.csv.in.ImportModelFactory; +import org.nuiton.topia.persistence.metadata.AssociationMeta; +import org.nuiton.topia.persistence.metadata.ColumnMeta; +import org.nuiton.topia.persistence.metadata.TableMeta; +import org.nuiton.util.csv.Import; +import org.nuiton.util.csv.ImportModel; + +import java.io.Reader; +import java.util.List; +import java.util.Map; + +/** + * To produce csv import model. + * + * @author tchemit <chemit@codelutin.com> + * @since 0.6 + */ +public class SammoaImportModelFactory implements ImportModelFactory<SammoaEntityEnum> { + + private final char csvSeparator; + + private final Map<SammoaEntityEnum, Map<String, TopiaEntity>> universe; + + private final TopiaContext tx; + + private final SammoaDbMeta dbMetas; + + SammoaImportModelFactory(char csvSeparator, + TopiaContext tx, + SammoaDbMeta dbMetas) { + this.dbMetas = dbMetas; + this.universe = Maps.newTreeMap(); + this.csvSeparator = csvSeparator; + this.tx = tx; + } + + public Map<SammoaEntityEnum, Map<String, TopiaEntity>> getUniverse() { + return universe; + } + + public <E extends TopiaEntity> Import<E> newModel(TableMeta<SammoaEntityEnum> meta, Reader reader) { + ImportModel<E> model = buildForImport(meta); + Import<E> importer = Import.newImport(model, reader); + return importer; + } + + @Override + public <E extends TopiaEntity> ImportModel<E> buildForImport(TableMeta<SammoaEntityEnum> meta) { + + EntityCsvModel<SammoaEntityEnum, E> model = EntityCsvModel.newModel( + csvSeparator, + meta, + TopiaEntity.TOPIA_ID + ); + + for (ColumnMeta columnMeta : meta) { + String propertyName = columnMeta.getName(); + Class<?> type = columnMeta.getType(); + if (!columnMeta.isFK()) { + model.addDefaultColumn(propertyName, type); + } else { + + Class<TopiaEntity> entityType = (Class<TopiaEntity>) type; + SammoaEntityEnum entityEnum = SammoaEntityEnum.valueOf(entityType); + + if (dbMetas.isReferential(entityEnum)) { + + // referential is always loaded by incoming universe (and not from db) + //since we need to do some topiaId translations + Map<String, TopiaEntity> entitiesbyId = universe.get(entityEnum); + model.addForeignKeyForImport(propertyName, entityType, entitiesbyId); + } else { + + // foreign keys on data are always coming from db + try { + List<TopiaEntity> entities = dbMetas.getPersistenceHelper().getDAO(tx, entityType).findAll(); + model.addForeignKeyForImport(propertyName, entityType, entities); + } catch (TopiaException e) { + throw new TopiaRuntimeException(e); + } + } + } + } + return model; + } + + @Override + public ImportModel<Map<String, Object>> buildForImport(AssociationMeta<SammoaEntityEnum> meta) { + ImportModel<Map<String, Object>> model = + EntityAssociationImportModel.newImportModel( + csvSeparator, + meta + ); + return model; + } + + @Override + public boolean isNMAssociationMeta(AssociationMeta<SammoaEntityEnum> meta) { + return false; + } + + public void close() { + universe.clear(); + } +} Property changes on: trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/SammoaImportModelFactory.java ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision HeadURL Added: svn:eol-style + native Added: trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/strategy/AbstractImportStrategy.java =================================================================== --- trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/strategy/AbstractImportStrategy.java (rev 0) +++ trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/strategy/AbstractImportStrategy.java 2012-08-22 16:20:46 UTC (rev 457) @@ -0,0 +1,92 @@ +package fr.ulr.sammoa.application.io.input.application.strategy; +/* + * #%L + * SAMMOA :: Application + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2012 UMS 3462, Code Lutin + * %% + * 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/gpl-3.0.html>. + * #L% + */ + +import fr.ulr.sammoa.application.io.input.application.SammoaImportModelFactory; +import fr.ulr.sammoa.persistence.SammoaEntityEnum; +import fr.ulr.sammoa.persistence.SammoaPersistenceHelper; +import org.nuiton.topia.TopiaContext; +import org.nuiton.topia.TopiaException; +import org.nuiton.topia.persistence.TopiaDAO; +import org.nuiton.topia.persistence.TopiaEntity; +import org.nuiton.topia.persistence.csv.in.CsvImportResult; +import org.nuiton.topia.persistence.csv.in.ImportStrategy; +import org.nuiton.topia.persistence.metadata.AssociationMeta; +import org.nuiton.topia.persistence.metadata.TableMeta; +import org.nuiton.util.csv.Import; +import org.nuiton.util.csv.ImportToMap; + +import java.io.Reader; + +/** + * Base import stragey for sammo application import. + * + * @author tchemit <chemit@codelutin.com> + * @since 0.6 + */ +abstract class AbstractImportStrategy implements ImportStrategy<SammoaEntityEnum> { + + private final TopiaContext tx; + + private final SammoaPersistenceHelper persistenceHelper; + + private final SammoaImportModelFactory modelFactory; + + AbstractImportStrategy(SammoaImportModelFactory modelFactory, + TopiaContext tx, + SammoaPersistenceHelper persistenceHelper) { + this.tx = tx; + this.persistenceHelper = persistenceHelper; + this.modelFactory = modelFactory; + } + + @Override + public SammoaImportModelFactory getModelFactory() { + return modelFactory; + } + + @Override + public <E extends TopiaEntity> void importTable(Import<E> importer, + TableMeta<SammoaEntityEnum> meta, + Reader reader, + CsvImportResult<SammoaEntityEnum> csvResult) throws TopiaException { + throw new UnsupportedOperationException(); + } + + @Override + public void importAssociation(AssociationMeta<SammoaEntityEnum> meta, + ImportToMap importer, + CsvImportResult<SammoaEntityEnum> csvResult) throws TopiaException { + throw new UnsupportedOperationException(); + } + + protected TopiaContext getTx() { + return tx; + } + + protected <E extends TopiaEntity> TopiaDAO<E> getDAO(SammoaEntityEnum type) { + return persistenceHelper.getDAO(tx, type); + } + +} Property changes on: trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/strategy/AbstractImportStrategy.java ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision HeadURL Added: svn:eol-style + native Added: trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/strategy/DataImportStrategy.java =================================================================== --- trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/strategy/DataImportStrategy.java (rev 0) +++ trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/strategy/DataImportStrategy.java 2012-08-22 16:20:46 UTC (rev 457) @@ -0,0 +1,80 @@ +package fr.ulr.sammoa.application.io.input.application.strategy; +/* + * #%L + * SAMMOA :: Application + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2012 UMS 3462, Code Lutin + * %% + * 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/gpl-3.0.html>. + * #L% + */ + +import fr.ulr.sammoa.application.io.input.application.SammoaImportModelFactory; +import fr.ulr.sammoa.persistence.SammoaEntityEnum; +import fr.ulr.sammoa.persistence.SammoaPersistenceHelper; +import org.nuiton.topia.TopiaContext; +import org.nuiton.topia.TopiaException; +import org.nuiton.topia.persistence.TopiaDAO; +import org.nuiton.topia.persistence.TopiaEntity; +import org.nuiton.topia.persistence.csv.in.CsvImportResult; +import org.nuiton.topia.persistence.csv.in.TopiaCsvImports; +import org.nuiton.topia.persistence.metadata.AssociationMeta; +import org.nuiton.topia.persistence.metadata.TableMeta; +import org.nuiton.util.csv.Import; +import org.nuiton.util.csv.ImportToMap; + +import java.io.Reader; + +/** + * Strategy to import data (create all entites, no update possible). + * + * @author tchemit <chemit@codelutin.com> + * @since 0.6 + */ +public class DataImportStrategy extends AbstractImportStrategy { + + public DataImportStrategy(SammoaImportModelFactory modelFactory, + TopiaContext tx, + SammoaPersistenceHelper persistenceHelper) { + super(modelFactory, tx, persistenceHelper); + } + + @Override + public <E extends TopiaEntity> void importTable(Import<E> importer, + TableMeta<SammoaEntityEnum> meta, + Reader reader, + CsvImportResult<SammoaEntityEnum> csvResult) throws TopiaException { + + TopiaDAO<E> dao = getDAO(meta.getSource()); + + TopiaCsvImports.importAllEntities(dao, meta, importer, csvResult); + + } + + @Override + public void importAssociation(AssociationMeta<SammoaEntityEnum> meta, + ImportToMap importer, + CsvImportResult<SammoaEntityEnum> csvResult) throws TopiaException { + TopiaCsvImports.importAssociation(getTx(), + meta, + importer, + csvResult, + 1000); + } + + +} Property changes on: trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/strategy/DataImportStrategy.java ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision HeadURL Added: svn:eol-style + native Added: trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/strategy/ReferentialImportStrategy.java =================================================================== --- trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/strategy/ReferentialImportStrategy.java (rev 0) +++ trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/strategy/ReferentialImportStrategy.java 2012-08-22 16:20:46 UTC (rev 457) @@ -0,0 +1,81 @@ +package fr.ulr.sammoa.application.io.input.application.strategy; +/* + * #%L + * SAMMOA :: Application + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2012 UMS 3462, Code Lutin + * %% + * 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/gpl-3.0.html>. + * #L% + */ + +import com.google.common.collect.Maps; +import fr.ulr.sammoa.application.io.input.application.SammoaImportModelFactory; +import fr.ulr.sammoa.persistence.SammoaEntityEnum; +import fr.ulr.sammoa.persistence.SammoaPersistenceHelper; +import org.nuiton.topia.TopiaContext; +import org.nuiton.topia.TopiaException; +import org.nuiton.topia.persistence.TopiaDAO; +import org.nuiton.topia.persistence.TopiaEntity; +import org.nuiton.topia.persistence.csv.in.CsvImportResult; +import org.nuiton.topia.persistence.csv.in.TopiaCsvImports; +import org.nuiton.topia.persistence.metadata.TableMeta; +import org.nuiton.util.csv.Import; + +import java.io.Reader; +import java.util.Map; + +/** + * Strategy for referential import: + * <p/> + * No update (for the moment) just add new entities and for other get their + * db topiaid using the natural id of it. + * + * @author tchemit <chemit@codelutin.com> + * @since 0.6 + */ +public class ReferentialImportStrategy extends AbstractImportStrategy { + + public ReferentialImportStrategy(SammoaImportModelFactory modelFactory, + TopiaContext tx, + SammoaPersistenceHelper persistenceHelper) { + super(modelFactory, tx, persistenceHelper); + } + + @Override + public <E extends TopiaEntity> void importTable(Import<E> importer, + TableMeta<SammoaEntityEnum> meta, + Reader reader, + CsvImportResult<SammoaEntityEnum> csvResult) throws TopiaException { + TopiaDAO<E> dao = getDAO(meta.getSource()); + + SammoaEntityEnum entityEnum = meta.getSource(); + + // create new universe + Map<String, TopiaEntity> universe = Maps.newTreeMap(); + + // keep it in model factory (will be used for foreign keys imports) + getModelFactory().getUniverse().put(entityEnum, universe); + + TopiaCsvImports.importNotExistingEntities(dao, + meta, + universe, + importer, + csvResult); + } + +} Property changes on: trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/input/application/strategy/ReferentialImportStrategy.java ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision HeadURL Added: svn:eol-style + native Modified: trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/output/application/ExportApplicationService.java =================================================================== --- trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/output/application/ExportApplicationService.java 2012-08-22 09:08:00 UTC (rev 456) +++ trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/output/application/ExportApplicationService.java 2012-08-22 16:20:46 UTC (rev 457) @@ -39,25 +39,20 @@ import fr.ulr.sammoa.persistence.Observation; import fr.ulr.sammoa.persistence.Route; import fr.ulr.sammoa.persistence.SammoaDAOHelper; -import fr.ulr.sammoa.persistence.SammoaDbMetas; +import fr.ulr.sammoa.persistence.SammoaDbMeta; import fr.ulr.sammoa.persistence.SammoaEntityEnum; import org.apache.commons.io.FileUtils; import org.apache.commons.io.IOUtils; -import org.apache.commons.lang3.StringUtils; import org.nuiton.topia.TopiaContext; import org.nuiton.topia.TopiaException; -import org.nuiton.topia.persistence.TopiaDAO; import org.nuiton.topia.persistence.TopiaEntity; import org.nuiton.topia.persistence.csv.EntityCsvModel; import org.nuiton.topia.persistence.csv.out.EntityAssociationExportModel; import org.nuiton.topia.persistence.csv.out.ExportEntityVisitor; import org.nuiton.topia.persistence.csv.out.ExportModelFactory; -import org.nuiton.topia.persistence.csv.out.PrepareDataForExport; import org.nuiton.topia.persistence.csv.out.TopiaCsvExports; import org.nuiton.topia.persistence.metadata.AssociationMeta; import org.nuiton.topia.persistence.metadata.ColumnMeta; -import org.nuiton.topia.persistence.metadata.DbMeta; -import org.nuiton.topia.persistence.metadata.MetaFilenameAware; import org.nuiton.topia.persistence.metadata.TableMeta; import org.nuiton.util.TimeLog; import org.nuiton.util.ZipUtil; @@ -85,6 +80,42 @@ private static final TimeLog TIME_LOG = new TimeLog(ExportApplicationService.class); + private final ExportModelFactory<SammoaEntityEnum> defaultExportModelFactory = new ExportModelFactory<SammoaEntityEnum>() { + @Override + public <E extends TopiaEntity> ExportModel<E> buildForExport(TableMeta<SammoaEntityEnum> meta) { + EntityCsvModel<SammoaEntityEnum, E> model = + EntityCsvModel.newModel(config.getCsvSeparator(), + meta, + TopiaEntity.TOPIA_ID); + + + for (ColumnMeta columnMeta : meta) { + String propertyName = columnMeta.getName(); + Class<?> type = columnMeta.getType(); + if (columnMeta.isFK()) { + + Class<TopiaEntity> entityType = (Class<TopiaEntity>) type; + + // export foreign key value as his topiaId + model.addForeignKeyForExport(propertyName, entityType); + + } else { + model.addDefaultColumn(propertyName, type); + } + } + return model; + } + + @Override + public <E extends TopiaEntity> ExportModel<E> buildForExport(AssociationMeta<SammoaEntityEnum> associationMeta) { + ExportModel<E> model = EntityAssociationExportModel.newExportModel( + config.getCsvSeparator(), + associationMeta + ); + return model; + } + }; + public void exportApplication(ExportApplicationModel model) { Preconditions.checkNotNull(model); Preconditions.checkNotNull(model.getExportFile()); @@ -111,33 +142,45 @@ Iterable<String> flightIds = model.getFlightIds(); - CampaignStorage targetStorage = SammoaStorages.copyCampaignStorage( - storage, targetDirectory, true, flightIds); + CampaignStorage targetStorage = + SammoaStorages.createCampaignStorage(targetDirectory, + storage.getId()); - fillAndsaveStorageProperties(targetStorage); + SammoaStorages.copyCampaignStorage(storage, + targetStorage, + flightIds); + fillAndSaveStorageProperties(targetStorage); + startTime = TIME_LOG.log(startTime, "exportApplication", "after create Storage structure"); - File csvDirectory = targetStorage.getCsvDirectory(); - TopiaContext tx = beginTransaction(); try { - exportReferential(tx, csvDirectory); - exportData(tx, csvDirectory, flightIds); + + exportReferential(tx, targetStorage); + + for (String flightId : flightIds) { + FlightStorage flightStorage = + targetStorage.getFlightStorage(flightId); + exportFlightData(tx, + flightStorage, + flightId); + } + } catch (IOException e) { + throw new SammoaTechnicalException("Could not create export file", e); } finally { endTransaction(tx); } compressZipFile(model.getExportFile(), - targetStorage.getDirectory(), - false); + targetStorage.getDirectory()); TIME_LOG.log(startTime, "exportApplication", "after export db to csv files "); } - private void fillAndsaveStorageProperties(CampaignStorage storage) { + private void fillAndSaveStorageProperties(CampaignStorage storage) { TopiaContext tx = beginTransaction(); @@ -166,58 +209,52 @@ } finally { endTransaction(tx); } + } + protected void exportReferential(TopiaContext tx, CampaignStorage storage) throws IOException { - } + File csvDirectory = storage.getCsvDirectory(); - protected void exportReferential(TopiaContext tx, File csvDirectory) { + FileUtils.forceMkdir(csvDirectory); - DbMeta<SammoaEntityEnum> dbMetas = persistence.getDbMetas(); + SammoaDbMeta dbMetas = persistence.getDbMetas(); - SammoaEntityEnumPrepareDataForExport prepareDataForExport = - new SammoaEntityEnumPrepareDataForExport(dbMetas, tx); + SammoaPrepareDataForExport prepareDataForExport = + new SammoaPrepareDataForExport(dbMetas, tx); - MetaFilenameAware<SammoaEntityEnum>[] referencialEntries = - SammoaDbMetas.getReferencialEntries(dbMetas); + List<TableMeta<SammoaEntityEnum>> referencialEntries = + dbMetas.getReferentialTables(); - for (MetaFilenameAware<SammoaEntityEnum> entry : referencialEntries) { + for (TableMeta<SammoaEntityEnum> tableMeta : referencialEntries) { - File entryFile = new File(csvDirectory, entry.getFilename()); + File entryFile = new File(csvDirectory, tableMeta.getFilename()); if (logger.isInfoEnabled()) { - logger.info("Will export {} to {}", entry, entryFile); + logger.info("Will export {} to {}", tableMeta, entryFile); } - if (entry instanceof AssociationMeta) { - AssociationMeta<SammoaEntityEnum> associationMeta = - (AssociationMeta<SammoaEntityEnum>) entry; - TopiaCsvExports.exportData(associationMeta, - defaultExportModelFactory, - prepareDataForExport, - entryFile); - } else { - TableMeta<SammoaEntityEnum> tableMeta = - (TableMeta<SammoaEntityEnum>) entry; - - TopiaCsvExports.exportData(tableMeta, - defaultExportModelFactory, - prepareDataForExport, - entryFile); - } + TopiaCsvExports.exportData(tableMeta, + defaultExportModelFactory, + prepareDataForExport, + entryFile); } } - protected void exportData(TopiaContext tx, - File csvDirectory, - Iterable<String> flightIds) { + protected void exportFlightData(TopiaContext tx, + FlightStorage storage, + String flightId) throws IOException { - DbMeta<SammoaEntityEnum> dbMetas = persistence.getDbMetas(); + File csvDirectory = storage.getCsvDirectory(); + FileUtils.forceMkdir(csvDirectory); + + SammoaDbMeta dbMetas = persistence.getDbMetas(); + Map<SammoaEntityEnum, TopiaCsvExports.EntityExportContext<SammoaEntityEnum>> exportContexts = TopiaCsvExports.createReplicateEntityVisitorContexts( defaultExportModelFactory, - SammoaDbMetas.getDataEntries(dbMetas), - SammoaDbMetas.getDataAssociationsEntries(dbMetas), + dbMetas.getDataTables(), + dbMetas.getDataAssociations(), csvDirectory); ExportEntityVisitor<SammoaEntityEnum> exportVisitor = @@ -227,128 +264,40 @@ FlightService flightService = getService(FlightService.class); try { - for (String flightId : flightIds) { - Flight flight = flightService.getFlight(tx, flightId); - exportVisitor.export(flight); + Flight flight = flightService.getFlight(tx, flightId); + exportVisitor.export(flight); - List<GeoPoint> geoPoints = - flightService.getFlightGeoPoints(tx, flight); - exportVisitor.export(geoPoints); + List<GeoPoint> geoPoints = + flightService.getFlightGeoPoints(tx, flight); + exportVisitor.export(geoPoints); - List<Route> routes = flightService.getRoutes(tx, flight); - exportVisitor.export(routes); + List<Route> routes = flightService.getRoutes(tx, flight); + exportVisitor.export(routes); - List<Observation> observations = - flightService.getObservations(tx, flight); - exportVisitor.export(observations); + List<Observation> observations = + flightService.getObservations(tx, flight); + exportVisitor.export(observations); - } } finally { IOUtils.closeQuietly(exportVisitor); } } - private ExportModelFactory<SammoaEntityEnum> defaultExportModelFactory = new ExportModelFactory<SammoaEntityEnum>() { - @Override - public <E extends TopiaEntity> ExportModel<E> buildForExport(TableMeta<SammoaEntityEnum> meta) { - EntityCsvModel<SammoaEntityEnum, E> model = - EntityCsvModel.newModel(config.getCsvSeparator(), - meta, - TopiaEntity.TOPIA_ID); + protected void compressZipFile(File zipFile, File directory) { - - for (ColumnMeta columnMeta : meta) { - String propertyName = columnMeta.getName(); - Class<?> type = columnMeta.getType(); - if (columnMeta.isFK()) { - - Class<TopiaEntity> entityType = (Class<TopiaEntity>) type; - - // export foreign key value as his topiaId - model.addForeignKeyForExport(propertyName, entityType); - - } else { - model.addDefaultColumn(propertyName, type); - } - } - return model; - } - - @Override - public <E extends TopiaEntity> ExportModel<E> buildForExport(AssociationMeta<SammoaEntityEnum> associationMeta) { - ExportModel<E> model = EntityAssociationExportModel.newExportModel( - config.getCsvSeparator(), - associationMeta - ); - return model; - } - }; - - protected void compressZipFile(File zipFile, - File directory, - boolean delete) { - try { FileUtils.forceMkdir(zipFile.getParentFile()); try { ZipUtil.compress(zipFile, directory); } finally { - if (delete) { - FileUtils.deleteDirectory(directory); - } + FileUtils.deleteDirectory(directory); + } } catch (IOException e) { throw new SammoaTechnicalException("Could not compress directory", e); } } - protected static class SammoaEntityEnumPrepareDataForExport implements PrepareDataForExport<SammoaEntityEnum> { - - protected final DbMeta<SammoaEntityEnum> dbMetas; - - protected final TopiaContext tx; - - public SammoaEntityEnumPrepareDataForExport(DbMeta<SammoaEntityEnum> dbMetas, TopiaContext tx) { - this.dbMetas = dbMetas; - this.tx = tx; - } - - @Override - public <E extends TopiaEntity> List<E> prepareData(TableMeta<SammoaEntityEnum> tableMeta) { - - return getEntities(tx, tableMeta, null); - } - - @Override - public <E extends TopiaEntity> List<E> prepareData(AssociationMeta<SammoaEntityEnum> associationMeta) { - TableMeta<SammoaEntityEnum> tableMeta = dbMetas.getTable(associationMeta.getSource()); - return getEntities(tx, tableMeta, "size(e." + associationMeta.getName() + ") > 0"); - } - - protected <E extends TopiaEntity> List<E> getEntities(TopiaContext tx, - TableMeta<SammoaEntityEnum> tableMeta, - String extraWhereQuery) { - - SammoaEntityEnum entityEnum = tableMeta.getSource(); - try { - TopiaDAO<E> dao = SammoaDAOHelper.<E, TopiaDAO<E>>getDAO( - tx, (Class<E>) entityEnum.getContract()); - - // first query to count datas - - String hql = "FROM " + entityEnum.getImplementationFQN(); - - if (StringUtils.isNotEmpty(extraWhereQuery)) { - hql += " WHERE " + extraWhereQuery; - } - - List<E> result = dao.findAllByQuery(hql); - return result; - } catch (TopiaException eee) { - throw new SammoaTechnicalException("Could not obtain data", eee); - } - } - } } Added: trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/output/application/SammoaPrepareDataForExport.java =================================================================== --- trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/output/application/SammoaPrepareDataForExport.java (rev 0) +++ trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/output/application/SammoaPrepareDataForExport.java 2012-08-22 16:20:46 UTC (rev 457) @@ -0,0 +1,91 @@ +package fr.ulr.sammoa.application.io.output.application; +/* + * #%L + * SAMMOA :: Application + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2012 UMS 3462, Code Lutin + * %% + * 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/gpl-3.0.html>. + * #L% + */ + +import fr.ulr.sammoa.application.SammoaTechnicalException; +import fr.ulr.sammoa.persistence.SammoaEntityEnum; +import org.apache.commons.lang3.StringUtils; +import org.nuiton.topia.TopiaContext; +import org.nuiton.topia.TopiaException; +import org.nuiton.topia.persistence.TopiaDAO; +import org.nuiton.topia.persistence.TopiaEntity; +import org.nuiton.topia.persistence.csv.out.PrepareDataForExport; +import org.nuiton.topia.persistence.metadata.AssociationMeta; +import org.nuiton.topia.persistence.metadata.DbMeta; +import org.nuiton.topia.persistence.metadata.TableMeta; + +import java.util.List; + +/** + * TODO + * + * @author tchemit <chemit@codelutin.com> + * @since 0.6 + */ +class SammoaPrepareDataForExport implements PrepareDataForExport<SammoaEntityEnum> { + + protected final DbMeta<SammoaEntityEnum> dbMetas; + + protected final TopiaContext tx; + + public SammoaPrepareDataForExport(DbMeta<SammoaEntityEnum> dbMetas, TopiaContext tx) { + this.dbMetas = dbMetas; + this.tx = tx; + } + + @Override + public <E extends TopiaEntity> List<E> prepareData(TableMeta<SammoaEntityEnum> tableMeta) { + + return getEntities(tx, tableMeta, null); + } + + @Override + public <E extends TopiaEntity> List<E> prepareData(AssociationMeta<SammoaEntityEnum> associationMeta) { + TableMeta<SammoaEntityEnum> tableMeta = dbMetas.getTable(associationMeta.getSource()); + return getEntities(tx, tableMeta, "size(e." + associationMeta.getName() + ") > 0"); + } + + protected <E extends TopiaEntity> List<E> getEntities(TopiaContext tx, + TableMeta<SammoaEntityEnum> tableMeta, + String extraWhereQuery) { + + SammoaEntityEnum entityEnum = tableMeta.getSource(); + try { + TopiaDAO<E> dao = dbMetas.getPersistenceHelper().getDAO(tx, entityEnum); + + // first query to count datas + + String hql = "FROM " + entityEnum.getImplementationFQN(); + + if (StringUtils.isNotEmpty(extraWhereQuery)) { + hql += " WHERE " + extraWhereQuery; + } + + List<E> result = dao.findAllByQuery(hql); + return result; + } catch (TopiaException eee) { + throw new SammoaTechnicalException("Could not obtain data", eee); + } + } +} Property changes on: trunk/sammoa-application/src/main/java/fr/ulr/sammoa/application/io/output/application/SammoaPrepareDataForExport.java ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision HeadURL Added: svn:eol-style + native Added: trunk/sammoa-persistence/src/main/java/fr/ulr/sammoa/persistence/SammoaDbMeta.java =================================================================== --- trunk/sammoa-persistence/src/main/java/fr/ulr/sammoa/persistence/SammoaDbMeta.java (rev 0) +++ trunk/sammoa-persistence/src/main/java/fr/ulr/sammoa/persistence/SammoaDbMeta.java 2012-08-22 16:20:46 UTC (rev 457) @@ -0,0 +1,131 @@ +package fr.ulr.sammoa.persistence; +/* + * #%L + * SAMMOA :: Persistence + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2012 UMS 3462, Code Lutin + * %% + * 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/gpl-3.0.html>. + * #L% + */ + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.Lists; +import org.nuiton.topia.persistence.TopiaPersistenceHelper; +import org.nuiton.topia.persistence.metadata.AssociationMeta; +import org.nuiton.topia.persistence.metadata.DbMeta; +import org.nuiton.topia.persistence.metadata.TableMeta; + +import java.util.Arrays; +import java.util.List; + +/** + * All db metas for the sammoa persistence unit. + * + * @author tchemit <chemit@codelutin.com> + * @since 0.6 + */ +public class SammoaDbMeta extends DbMeta<SammoaEntityEnum> { + + private static final List<SammoaEntityEnum> REFERENTIAL_TYPES = ImmutableList.copyOf(Arrays.asList( + SammoaEntityEnum.Region, + SammoaEntityEnum.Species, + SammoaEntityEnum.Campaign, + SammoaEntityEnum.Observer, + SammoaEntityEnum.Sector, + SammoaEntityEnum.Strate, + SammoaEntityEnum.Transect + )); + + private static final List<SammoaEntityEnum> DATA_TYPES = ImmutableList.copyOf(Arrays.asList( + SammoaEntityEnum.Flight, + SammoaEntityEnum.GeoPoint, + SammoaEntityEnum.ObserverPosition, + SammoaEntityEnum.TransectFlight, + SammoaEntityEnum.Observation, + SammoaEntityEnum.Route + )); + + private final List<TableMeta<SammoaEntityEnum>> referentialTables; + + private final List<AssociationMeta<SammoaEntityEnum>> referentialAssociations; + + private final List<TableMeta<SammoaEntityEnum>> dataTables; + + private final List<AssociationMeta<SammoaEntityEnum>> dataAssociations; + + public static SammoaDbMeta newDbMeta(TopiaPersistenceHelper<SammoaEntityEnum> persistenceHelper) { + return new SammoaDbMeta(persistenceHelper); + } + + SammoaDbMeta(TopiaPersistenceHelper<SammoaEntityEnum> persistenceHelper) { + super(persistenceHelper, SammoaEntityEnum.values()); + + { + // referential tables + + List<TableMeta<SammoaEntityEnum>> result = Lists.newArrayList(); + addTables(result, REFERENTIAL_TYPES); + referentialTables = ImmutableList.copyOf(result); + } + + { + // referential associations + + List<AssociationMeta<SammoaEntityEnum>> result = Lists.newArrayList(); + addAssociations(result, REFERENTIAL_TYPES); + referentialAssociations = ImmutableList.copyOf(result); + } + + { + // data tables + + List<TableMeta<SammoaEntityEnum>> result = Lists.newArrayList(); + addTables(result, DATA_TYPES); + dataTables = ImmutableList.copyOf(result); + } + + { + // data associations + + List<AssociationMeta<SammoaEntityEnum>> result = Lists.newArrayList(); + addAssociations(result, DATA_TYPES); + dataAssociations = ImmutableList.copyOf(result); + } + } + + public boolean isReferential(SammoaEntityEnum type) { + return REFERENTIAL_TYPES.contains(type); + } + + public List<TableMeta<SammoaEntityEnum>> getReferentialTables() { + return referentialTables; + } + + public List<AssociationMeta<SammoaEntityEnum>> getReferentialAssociations() { + return referentialAssociations; + } + + public List<TableMeta<SammoaEntityEnum>> getDataTables() { + return dataTables; + } + + public List<AssociationMeta<SammoaEntityEnum>> getDataAssociations() { + return dataAssociations; + } + +} Property changes on: trunk/sammoa-persistence/src/main/java/fr/ulr/sammoa/persistence/SammoaDbMeta.java ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision HeadURL Added: svn:eol-style + native Deleted: trunk/sammoa-persistence/src/main/java/fr/ulr/sammoa/persistence/SammoaDbMetas.java =================================================================== --- trunk/sammoa-persistence/src/main/java/fr/ulr/sammoa/persistence/SammoaDbMetas.java 2012-08-22 09:08:00 UTC (rev 456) +++ trunk/sammoa-persistence/src/main/java/fr/ulr/sammoa/persistence/SammoaDbMetas.java 2012-08-22 16:20:46 UTC (rev 457) @@ -1,136 +0,0 @@ -package fr.ulr.sammoa.persistence; -/* - * #%L - * SAMMOA :: Persistence - * $Id$ - * $HeadURL$ - * %% - * Copyright (C) 2012 UMS 3462, Code Lutin - * %% - * 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/gpl-3.0.html>. - * #L% - */ - -import com.google.common.collect.Lists; -import com.google.common.collect.Multimap; -import org.nuiton.topia.persistence.metadata.DbMeta; -import org.nuiton.topia.persistence.metadata.MetaFilenameAware; -import org.nuiton.topia.persistence.metadata.Metadatas; - -import java.util.List; -import java.util.Map; - -/** - * Useful methods aroun meta datas of sammoa entities. - * - * @author tchemit <chemit@codelutin.com> - * @since 0.6 - */ -public class SammoaDbMetas { - - private static final SammoaEntityEnum[] EMPTY_ENTITY_TYPE_ARRAY = - new SammoaEntityEnum[0]; - - public static DbMeta<SammoaEntityEnum> newDbMetas(SammoaPersistenceHelper persistenceHelper) { - return DbMeta.newDbMeta(persistenceHelper, - SammoaEntityEnum.values(), - EMPTY_ENTITY_TYPE_ARRAY - ); - } - - /** - * @return the entity types of data in correct order for replication - * purpose. - */ - public static SammoaEntityEnum[] getDataTypes() { - - List<SammoaEntityEnum> result = Lists.newLinkedList(); - - result.add(SammoaEntityEnum.TransectFlight); - result.add(SammoaEntityEnum.Flight); - result.add(SammoaEntityEnum.Route); - result.add(SammoaEntityEnum.Observation); - result.add(SammoaEntityEnum.ObserverPosition); - result.add(SammoaEntityEnum.GeoPoint); - - return result.toArray(new SammoaEntityEnum[result.size()]); - } - - /** - * @return the entity types of reference in correct order for copy - * purpose (says import / export of all a database. - */ - public static SammoaEntityEnum[] getReferenceTypes() { - List<SammoaEntityEnum> result = Lists.newLinkedList(); - - // with no dep - result.add(SammoaEntityEnum.Region); - result.add(SammoaEntityEnum.Species); - result.add(SammoaEntityEnum.Campaign); - result.add(SammoaEntityEnum.Observer); - result.add(SammoaEntityEnum.Sector); - result.add(SammoaEntityEnum.Strate); - result.add(SammoaEntityEnum.Transect); - - return result.toArray(new SammoaEntityEnum[result.size()]); - } - - public static MetaFilenameAware<SammoaEntityEnum>[] getAllEntries(DbMeta<SammoaEntityEnum> dbMeta) { - - List<MetaFilenameAware<SammoaEntityEnum>> entities = Lists.newArrayList(); - List<MetaFilenameAware<SammoaEntityEnum>> associations = Lists.newArrayList(); - - Metadatas.addEntries(dbMeta, entities, associations, getReferenceTypes()); - Metadatas.addEntries(dbMeta, entities, associations, getDataTypes()); - entities.addAll(associations); - return entities.toArray(new MetaFilenameAware[entities.size()]); - } - - public static MetaFilenameAware<SammoaEntityEnum>[] getReferencialEntries(DbMeta<SammoaEntityEnum> dbMeta) { - - List<MetaFilenameAware<SammoaEntityEnum>> entities = Lists.newArrayList(); - List<MetaFilenameAware<SammoaEntityEnum>> associations = Lists.newArrayList(); - entities.addAll(associations); - Metadatas.addEntries(dbMeta, entities, associations, getReferenceTypes()); - - return entities.toArray(new MetaFilenameAware[entities.size()]); - } - - public static Map<SammoaEntityEnum, MetaFilenameAware<SammoaEntityEnum>> getReferencialEntriesByType(DbMeta<SammoaEntityEnum> dbMeta) { - List<MetaFilenameAware<SammoaEntityEnum>> entities = Lists.newArrayList(); - List<MetaFilenameAware<SammoaEntityEnum>> associations = Lists.newArrayList(); - entities.addAll(associations); - Metadatas.addEntries(dbMeta, entities, associations, getReferenceTypes()); - return Metadatas.uniqueIndex(entities); - } - - - public static MetaFilenameAware<SammoaEntityEnum>[] getDataEntries(DbMeta<SammoaEntityEnum> dbMeta) { - - List<MetaFilenameAware<SammoaEntityEnum>> entities = Lists.newArrayList(); - - Metadatas.addEntries(dbMeta, entities, null, getDataTypes()); - return entities.toArray(new MetaFilenameAware[entities.size()]); - } - - public static Multimap<SammoaEntityEnum, MetaFilenameAware<SammoaEntityEnum>> getDataAssociationsEntries(DbMeta<SammoaEntityEnum> dbMeta) { - - List<MetaFilenameAware<SammoaEntityEnum>> associations = Lists.newArrayList(); - - Metadatas.addEntries(dbMeta, null, associations, getDataTypes()); - return Metadatas.split(associations); - } - -} Modified: trunk/sammoa-persistence/src/main/java/fr/ulr/sammoa/persistence/SammoaPersistence.java =================================================================== --- trunk/sammoa-persistence/src/main/java/fr/ulr/sammoa/persistence/SammoaPersistence.java 2012-08-22 09:08:00 UTC (rev 456) +++ trunk/sammoa-persistence/src/main/java/fr/ulr/sammoa/persistence/SammoaPersistence.java 2012-08-22 16:20:46 UTC (rev 457) @@ -32,7 +32,6 @@ import org.nuiton.topia.TopiaRuntimeException; import org.nuiton.topia.framework.TopiaContextImplementor; import org.nuiton.topia.persistence.TopiaEntity; -import org.nuiton.topia.persistence.metadata.DbMeta; import java.io.Closeable; import java.util.Properties; @@ -62,7 +61,7 @@ protected SammoaPersistenceHelper persistenceHelper; - protected DbMeta<SammoaEntityEnum> dbMetas; + protected SammoaDbMeta dbMetas; /** * Constructor of SammoaPersistence with {@code dbConfiguration} for @@ -201,9 +200,9 @@ return persistenceHelper; } - public DbMeta<SammoaEntityEnum> getDbMetas() { + public SammoaDbMeta getDbMetas() { if (dbMetas == null) { - dbMetas = SammoaDbMetas.newDbMetas(getPersistenceHelper()); + dbMetas = SammoaDbMeta.newDbMeta(getPersistenceHelper()); } return dbMetas; } Modified: trunk/sammoa-persistence/src/main/java/fr/ulr/sammoa/persistence/SammoaPersistenceHelper.java =================================================================== --- trunk/sammoa-persistence/src/main/java/fr/ulr/sammoa/persistence/SammoaPersistenceHelper.java 2012-08-22 09:08:00 UTC (rev 456) +++ trunk/sammoa-persistence/src/main/java/fr/ulr/sammoa/persistence/SammoaPersistenceHelper.java 2012-08-22 16:20:46 UTC (rev 457) @@ -1,4 +1,27 @@ package fr.ulr.sammoa.persistence; +/* + * #%L + * SAMMOA :: Persistence + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2012 UMS 3462, Code Lutin + * %% + * 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/gpl-3.0.html>. + * #L% + */ import org.nuiton.topia.TopiaContext; import org.nuiton.topia.TopiaException; @@ -28,4 +51,10 @@ throw new TopiaRuntimeException(e); } } + + @Override + public <E extends TopiaEntity> TopiaDAO<E> getDAO(TopiaContext tx, SammoaEntityEnum type) { + return (TopiaDAO<E>) getDAO(tx, type.getContract()); + } + } Property changes on: trunk/sammoa-persistence/src/main/java/fr/ulr/sammoa/persistence/SammoaPersistenceHelper.java ___________________________________________________________________ Modified: svn:keywords - Author Date Id Revision + Author Date Id Revision HeadURL Copied: trunk/sammoa-persistence/src/test/java/fr/ulr/sammoa/persistence/SammoaDbMetaTest.java (from rev 455, trunk/sammoa-persistence/src/test/java/fr/ulr/sammoa/persistence/SammoaDbMetasTest.java) =================================================================== --- trunk/sammoa-persistence/src/test/java/fr/ulr/sammoa/persistence/SammoaDbMetaTest.java (rev 0) +++ trunk/sammoa-persistence/src/test/java/fr/ulr/sammoa/persistence/SammoaDbMetaTest.java 2012-08-22 16:20:46 UTC (rev 457) @@ -0,0 +1,121 @@ +package fr.ulr.sammoa.persistence; +/* + * #%L + * SAMMOA :: Persistence + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2012 UMS 3462, Code Lutin + * %% + * 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/gpl-3.0.html>. + * #L% + */ + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.nuiton.topia.persistence.metadata.AssociationMeta; +import org.nuiton.topia.persistence.metadata.TableMeta; + +import java.util.Iterator; +import java.util.List; + +/** + * Tests the{@link SammoaDbMeta}. + * + * @author tchemit <chemit@codelutin.com> + * @since 0.6 + */ +public class SammoaDbMetaTest { + + protected SammoaDbMeta dbMetas; + + @Before + public void setUp() throws Exception { + dbMetas = SammoaDbMeta.newDbMeta(new SammoaPersistenceHelper()); + } + + @Test + public void getReferencialTables() throws Exception { + + List<TableMeta<SammoaEntityEnum>> entries = + dbMetas.getReferentialTables(); + + Assert.assertNotNull(entries); + Assert.assertEquals(7, entries.size()); + Iterator<TableMeta<SammoaEntityEnum>> itr = entries.iterator(); + assertTableMeta(itr.next(), SammoaEntityEnum.Region); + assertTableMeta(itr.next(), SammoaEntityEnum.Species); + assertTableMeta(itr.next(), SammoaEntityEnum.Campaign); + assertTableMeta(itr.next(), SammoaEntityEnum.Observer); + assertTableMeta(itr.next(), SammoaEntityEnum.Sector); + assertTableMeta(itr.next(), SammoaEntityEnum.Strate); + assertTableMeta(itr.next(), SammoaEntityEnum.Transect); + } + + @Test + public void getReferencialAssociations() throws Exception { + + List<AssociationMeta<SammoaEntityEnum>> entries = + dbMetas.getReferentialAssociations(); + + Assert.assertNotNull(entries); + Assert.assertTrue(entries.isEmpty()); + } + + @Test + public void getDataTables() throws Exception { + + List<TableMeta<SammoaEntityEnum>> entries = + dbMetas.getDataTables(); + Assert.assertNotNull(entries); + Assert.assertEquals(6, entries.size()); + Iterator<TableMeta<SammoaEntityEnum>> itr = entries.iterator(); + assertTableMeta(itr.next(), SammoaEntityEnum.Flight); + assertTableMeta(itr.next(), SammoaEntityEnum.GeoPoint); + assertTableMeta(itr.next(), SammoaEntityEnum.ObserverPosition); + assertTableMeta(itr.next(), SammoaEntityEnum.TransectFlight); + assertTableMeta(itr.next(), SammoaEntityEnum.Observation); + assertTableMeta(itr.next(), SammoaEntityEnum.Route); + } + + @Test + public void getDataAssociations() throws Exception { + + List<AssociationMeta<SammoaEntityEnum>> entries = + dbMetas.getDataAssociations(); + Assert.assertNotNull(entries); + Assert.assertEquals(4, entries.size()); + Iterator<AssociationMeta<SammoaEntityEnum>> itr = entries.iterator(); + assertAssociationMeta(itr.next(), SammoaEntityEnum.Flight, SammoaEntityEnum.Observer); + assertAssociationMeta(itr.next(), SammoaEntityEnum.Flight, SammoaEntityEnum.TransectFlight); + assertAssociationMeta(itr.next(), SammoaEntityEnum.TransectFlight, SammoaEntityEnum.ObserverPosition); + assertAssociationMeta(itr.next(), SammoaEntityEnum.Route, SammoaEntityEnum.ObserverPosition); + } + + protected void assertAssociationMeta(AssociationMeta<SammoaEntityEnum> meta, + SammoaEntityEnum source, + SammoaEntityEnum target) { + Assert.assertNotNull(meta); + Assert.assertEquals(source, meta.getSource()); + Assert.assertEquals(target, ((AssociationMeta) meta).getTarget()); + } + + protected void assertTableMeta(TableMeta<SammoaEntityEnum> meta, + SammoaEntityEnum source) { + Assert.assertNotNull(meta); + Assert.assertEquals(source, meta.getSource()); + } +} Property changes on: trunk/sammoa-persistence/src/test/java/fr/ulr/sammoa/persistence/SammoaDbMetaTest.java ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision HeadURL Added: svn:eol-style + native Deleted: trunk/sammoa-persistence/src/test/java/fr/ulr/sammoa/persistence/SammoaDbMetasTest.java =================================================================== --- trunk/sammoa-persistence/src/test/java/fr/ulr/sammoa/persistence/SammoaDbMetasTest.java 2012-08-22 09:08:00 UTC (rev 456) +++ trunk/sammoa-persistence/src/test/java/fr/ulr/sammoa/persistence/SammoaDbMetasTest.java 2012-08-22 16:20:46 UTC (rev 457) @@ -1,97 +0,0 @@ -package fr.ulr.sammoa.persistence; -/* - * #%L - * SAMMOA :: Persistence - * $Id$ - * $HeadURL$ - * %% - * Copyright (C) 2012 UMS 3462, Code Lutin - * %% - * 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/gpl-3.0.html>. - * #L% - */ - -import com.google.common.collect.Multimap; -import org.junit.Assert; -import org.junit.Before; -import org.junit.Test; -import org.nuiton.topia.persistence.metadata.DbMeta; -import org.nuiton.topia.persistence.metadata.MetaFilenameAware; - -/** - * Tests the{@link SammoaDbMetas}. - * - * @author tchemit <chemit@codelutin.com> - * @since 0.6 - */ -public class SammoaDbMetasTest { - - protected DbMeta<SammoaEntityEnum> dbMetas; - - - @Before - public void setUp() throws Exception { - dbMetas = SammoaDbMetas.newDbMetas(new SammoaPersistenceHelper()); - - } - - @Test - public void getAllEntries() throws Exception { - - MetaFilenameAware<SammoaEntityEnum>[] entries = - SammoaDbMetas.getAllEntries(dbMetas); - Assert.assertNotNull(entries); - Assert.assertEquals(SammoaDbMetas.getReferenceTypes().length + - SammoaDbMetas.getDataTypes().length + - 4 /* (data associations) */, - entries.length); - } - - @Test - public void getReferencialEntries() throws Exception { - - MetaFilenameAware<SammoaEntityEnum>[] entries = - SammoaDbMetas.getReferencialEntries(dbMetas); - - Assert.assertNotNull(entries); - Assert.assertEquals(SammoaDbMetas.getReferenceTypes().length, - entries.length); - } - - @Test - public void getDataEntries() throws Exception { - - MetaFilenameAware<SammoaEntityEnum>[] entries = - SammoaDbMetas.getDataEntries(dbMetas); - Assert.assertNotNull(entries); - Assert.assertEquals(SammoaDbMetas.getDataTypes().length, - entries.length); - } - - @Test - public void getDataAssociationsEntries() throws Exception { - - Multimap<SammoaEntityEnum, MetaFilenameAware<SammoaEntityEnum>> entries = - SammoaDbMetas.getDataAssociationsEntries(dbMetas); - Assert.assertNotNull(entries); - Assert.assertEquals(4, entries.size()); - Assert.assertTrue(entries.containsKey(SammoaEntityEnum.TransectFlight)); - Assert.assertEquals(1, entries.get(SammoaEntityEnum.TransectFlight).size()); - Assert.assertTrue(entries.containsKey(SammoaEntityEnum.Flight)); - Assert.assertEquals(2, entries.get(SammoaEntityEnum.Flight).size()); - Assert.assertTrue(entries.containsKey(SammoaEntityEnum.Route)); - Assert.assertEquals(1, entries.get(SammoaEntityEnum.Route).size()); - } -} Modified: trunk/sammoa-ui-swing/src/main/java/fr/ulr/sammoa/ui/swing/io/input/application/ImportApplicationUIHandler.java =================================================================== --- trunk/sammoa-ui-swing/src/main/java/fr/ulr/sammoa/ui/swing/io/input/application/ImportApplicationUIHandler.java 2012-08-22 09:08:00 UTC (rev 456) +++ trunk/sammoa-ui-swing/src/main/java/fr/ulr/sammoa/ui/swing/io/input/application/ImportApplicationUIHandler.java 2012-08-22 16:20:46 UTC (rev 457) @@ -194,12 +194,16 @@ ImportApplicationUIModel model = getModel(); List<FlightImportEntry> flightImportEntryList; + boolean existingCampaign; Campaign campaign; + + if (storage == null) { // willReset model flightImportEntryList = null; campaign = null; + existingCampaign = false; } else { @@ -211,7 +215,7 @@ campaign = referentialService.getCampaignByNaturalId(naturalId); - boolean existingCampaign = campaign != null; + existingCampaign = campaign != null; if (logger.isInfoEnabled()) { logger.info("Is campaign exist ? {}", existingCampaign); @@ -243,7 +247,17 @@ } } - model.setCampaignExist(campaign != null); + CampaignStorage oldStorage; + + if (existingCampaign) { + + oldStorage = referentialService.getCampaignStorage(campaign.getTopiaId()); + } else { + oldStorage = null; + } + + model.setOldStorage(oldStorage); + model.setCampaignExist(existingCampaign); model.setFlightEntries(flightImportEntryList); } Modified: trunk/sammoa-ui-swing/src/main/java/fr/ulr/sammoa/ui/swing/io/input/application/ImportApplicationUIModel.java =================================================================== --- trunk/sammoa-ui-swing/src/main/java/fr/ulr/sammoa/ui/swing/io/input/application/ImportApplicationUIModel.java 2012-08-22 09:08:00 UTC (rev 456) +++ trunk/sammoa-ui-swing/src/main/java/fr/ulr/sammoa/ui/swing/io/input/application/ImportApplicationUIModel.java 2012-08-22 16:20:46 UTC (rev 457) @@ -26,6 +26,7 @@ import com.google.common.collect.Lists; import fr.ulr.sammoa.application.io.CampaignStorage; import fr.ulr.sammoa.application.io.input.application.ImportApplicationModel; +import fr.ulr.sammoa.persistence.Flight; import org.jdesktop.beans.AbstractSerializableBean; import java.io.File; @@ -51,12 +52,17 @@ public static final String PROPERTY_STORAGE = "storage"; + public static final String PROPERTY_OLD_STORAGE = "oldStorage"; + /** File to import. */ protected File importFile; /** Loaded campaign storage. */ protected CampaignStorage storage; + /** Old existing campaign storage. */ + protected CampaignStorage oldStorage; + /** Is campaign exists ? */ protected boolean campaignExist; @@ -93,6 +99,14 @@ firePropertyChange(PROPERTY_IMPORT_FILE_LOADED, false, isImportFileLoaded()); } + public CampaignStorage getOldStorage() { + return oldStorage; + } + + public void setOldStorage(CampaignStorage oldStorage) { + this.oldStorage = oldStorage; + } + public boolean isCampaignExist() { return campaignExist; } @@ -115,18 +129,26 @@ public ImportApplicationModel toModel() { List<String> flightIds = Lists.newArrayList(); + List<String> flightToRemoveIds = Lists.newArrayList(); for (FlightImportEntry entry : getFlightEntries()) { if (!campaignExist || entry.isTreat()) { //flight to import flightIds.add(entry.getFlightStorage().getId()); + + Flight existingFlight = entry.getExistingFlight(); + if (existingFlight!=null) { + flightToRemoveIds.add(existingFlight.getTopiaId()); + } } } ImportApplicationModel result = ImportApplicationModel.newModel( getStorage(), - flightIds + getOldStorage(), + flightIds, + flightToRemoveIds ); return result; } Modified: trunk/src/site/rst/import-export.rst =================================================================== --- trunk/src/site/rst/import-export.rst 2012-08-22 09:08:00 UTC (rev 456) +++ trunk/src/site/rst/import-export.rst 2012-08-22 16:20:46 UTC (rev 457) @@ -724,7 +724,16 @@ - Sector : sectorNumber, campaign^ - Strate : strateType, sector^ - Transect : name, strate^ + - Flight : systemId, flightNumber, campaign^ +- GeoPoints +- ObserverPosition +- TransectFlight +- Observation +- Route + + + * Pas d'espèce commune entre deux régions ou sinon une copie sera effectuée ** Pas d'observateur commun entre deux campagnes ou sinon une copie sera effectuée \ No newline at end of file