Tony CHEMIT pushed to branch develop at ultreiaio / ird-observe

Commits:

9 changed files:

Changes:

  • client-datasource-actions/src/main/java/fr/ird/observe/client/datasource/actions/AdminUIHandler.java
    ... ... @@ -272,9 +272,7 @@ public class AdminUIHandler implements UIHandler<AdminUI>, WithClientUIContext {
    272 272
    273 273 
                 if (ui.getModel().getStepState(AdminStep.SAVE_LOCAL) == WizardState.PENDING) {
    274 274 
                     SaveLocalUI tabUI = (SaveLocalUI) ui.getStepUI(AdminStep.SAVE_LOCAL);
    275 
    -                if (tabUI.getStepModel().isLocalSourceNeedSave()) {
    276 
    -                    SwingUtilities.invokeLater(tabUI.getStart()::doClick);
    277 
    -                } else {
    275 
    +                if (!tabUI.getStepModel().isLocalSourceNeedSave()) {
    278 276 
                         SwingUtilities.invokeLater(tabUI.getContinueAction()::doClick);
    279 277 
                     }
    280 278 
                 }

  • services-local/src/main/java/fr/ird/observe/services/local/service/actions/synchro/referential/legacy/UnidirectionalReferentialSynchronizeLocalServiceLocal.java
    ... ... @@ -41,10 +41,12 @@ import fr.ird.observe.services.local.service.actions.synchro.referential.sql.Upd
    41 41 
     import fr.ird.observe.services.service.LastUpdateDateService;
    42 42 
     import fr.ird.observe.services.service.actions.synchro.referential.legacy.UnidirectionalReferentialSynchronizeLocalService;
    43 43 
     import fr.ird.observe.services.service.actions.synchro.referential.legacy.UnidirectionalReferentialSynchronizeRequest;
    44 
    +import fr.ird.observe.services.service.usage.DtoUsageCountRequest;
    45 
    +import fr.ird.observe.services.service.usage.DtoUsageCountResult;
    46 
    +import fr.ird.observe.services.service.usage.UsageService;
    44 47 
     import fr.ird.observe.spi.DbModelHelper;
    45 48 
     import fr.ird.observe.spi.context.ReferentialDtoEntityContext;
    46 49 
     import org.nuiton.topia.persistence.TopiaDao;
    47 
    -import org.nuiton.topia.persistence.TopiaEntity;
    48 50 
     import org.nuiton.topia.persistence.metadata.TopiaMetadataEntity;
    49 51 
     import org.nuiton.topia.persistence.metadata.TopiaMetadataModel;
    50 52 
     import org.nuiton.topia.persistence.support.TopiaSqlWork;
    ... ... @@ -63,19 +65,20 @@ import java.util.Set;
    63 65 
     public class UnidirectionalReferentialSynchronizeLocalServiceLocal extends ObserveServiceLocal implements UnidirectionalReferentialSynchronizeLocalService {
    64 66
    65 67 
         private LastUpdateDateService lastUpdateDateService;
    68 
    +    private UsageService usageService;
    66 69
    67 70 
         @Override
    68 71 
         public void setServiceContext(ObserveServiceContextLocal serviceContext) {
    69 72 
             super.setServiceContext(serviceContext);
    70 73 
             lastUpdateDateService = serviceContext.newService(LastUpdateDateService.class);
    74 
    +        usageService = serviceContext.newService(UsageService.class);
    71 75 
         }
    72 76
    73 77 
         @Override
    74 78 
         public <D extends ReferentialDto> ImmutableSet<String> filterIdsUsedInLocalSource(Class<D> dtoType, ImmutableSet<String> ids) {
    75 
    -        Class<? extends ReferentialEntity<D, ?>> entityType = DbModelHelper.fromReferentialDtoWeak(dtoType).toEntityType();
    76 79 
             Set<String> result = new LinkedHashSet<>();
    77 80 
             for (String id : ids) {
    78 
    -            int count = countUsage0(entityType, id);
    81 
    +            long count = countUsage0(dtoType, id);
    79 82 
                 if (count > 0) {
    80 83 
                     result.add(id);
    81 84 
                 }
    ... ... @@ -101,7 +104,7 @@ public class UnidirectionalReferentialSynchronizeLocalServiceLocal extends Obser
    101 104 
             TopiaMetadataModel metadataModel = serviceContext.getTopiaApplicationContext().getMetadataModel();
    102 105 
             TopiaMetadataEntity metadataEntity = metadataModel.getEntity(referentielName);
    103 106 
             if (request.withReferentialToAdd()) {
    104 
    -            InsertSqlStatementGenerator<D> sqlStatementGenerator = new InsertSqlStatementGenerator<>(metadataModel, metadataEntity, dtoType);
    107 
    +            InsertSqlStatementGenerator sqlStatementGenerator = new InsertSqlStatementGenerator(metadataModel, metadataEntity);
    105 108 
                 ImmutableSet<D> referentialToAdd = request.getReferentialToAdd();
    106 109 
                 if (ObjectMaterialDto.class.equals(dtoType)) {
    107 110 
                     // must reorder to be sure to insert parent before sons
    ... ... @@ -149,15 +152,10 @@ public class UnidirectionalReferentialSynchronizeLocalServiceLocal extends Obser
    149 152 
             lastUpdateDateService.updateReferentialLastUpdateDates();
    150 153 
         }
    151 154
    152 
    -    private <E extends ReferentialEntity<?, ?>> int countUsage0(Class<E> entityType, String id) {
    153 
    -        TopiaDao<E> dao = getTopiaPersistenceContext().getDao(entityType);
    154 
    -        E e = dao.forTopiaIdEquals(id).findUnique();
    155 
    -        Map<Class<? extends TopiaEntity>, List<? extends TopiaEntity>> allUsages = dao.findAllUsages(e);
    156 
    -        int count = 0;
    157 
    -        for (List<? extends TopiaEntity> entities : allUsages.values()) {
    158 
    -            count += entities.size();
    159 
    -        }
    160 
    -        return count;
    155 
    +    private <D extends ReferentialDto> long countUsage0(Class<D> dtoType, String id) {
    156 
    +        DtoUsageCountRequest<D> request = new DtoUsageCountRequest<>(dtoType, id);
    157 
    +        DtoUsageCountResult<?> usageCount = usageService.count(request);
    158 
    +        return usageCount.getCount().values().stream().reduce(Long::sum).orElse(0L);
    161 159 
         }
    162 160
    163 161 
         private <E extends ReferentialEntity<D, R>, D extends ReferentialDto, R extends ReferentialDtoReference<D, R>> ReferentialDtoReferenceSet<R> getLocalSourceReferentialToDelete0(Class<E> entityType, Class<R> referenceType, ImmutableSet<String> ids) {

  • services-local/src/main/java/fr/ird/observe/services/local/service/actions/synchro/referential/ng/ReferentialSynchronizeSqlListRequestBuilder.java
    ... ... @@ -140,20 +140,13 @@ public class ReferentialSynchronizeSqlListRequestBuilder {
    140 140 
         private <D extends ReferentialDto, R extends ReferentialDtoReference<D, R>, E extends ReferentialEntity<D, R>> void onAdd(TopiaMetadataEntity metadata, Class<D> dtoType, Class<E> entityType, Set<ReferentialSynchronizeTask> tasks, Multimap<Class<? extends ReferentialDto>, String> newIds) {
    141 141
    142 142 
             List<E> insertEntities = loadEntities(entityType, tasks);
    143 
    -        InsertSqlGenerator<D> insertGenerator;
    143 
    +        InsertSqlGenerator insertGenerator;
    144 144 
             if (metadata.withEntities()) {
    145 145 
                 Multimap<Class<? extends ReferentialDto>, String> allIds = ArrayListMultimap.create(request.getIdsOnlyExistingOnThisSide());
    146 146 
                 allIds.putAll(newIds);
    147 
    -            insertGenerator = new InsertSqlWithCascadeStatementGenerator<D>(metadataModel, metadata, dtoType, allIds) {
    148 
    -
    149 
    -                @Override
    150 
    -                protected <DD extends ReferentialDto> ImmutableList<String> insertMissingReferential(Class<DD> referentialType, String id) {
    151 
    -                    ReferentialDtoEntityContext<DD, ?, ?, ?> modelContext = DbModelHelper.fromReferentialDto(referentialType);
    152 
    -                    return addExtraInsertStatement(modelContext, id);
    153 
    -                }
    154 
    -            };
    147 
    +            insertGenerator = new InsertSqlWithCascadeStatementGenerator(service, metadataModel, metadata, dtoType, allIds);
    155 148 
             } else {
    156 
    -            insertGenerator = new InsertSqlStatementGenerator<>(metadataModel, metadata, dtoType);
    149 
    +            insertGenerator = new InsertSqlStatementGenerator(metadataModel, metadata);
    157 150 
             }
    158 151
    159 152 
             for (E entity : insertEntities) {
    ... ... @@ -173,15 +166,7 @@ public class ReferentialSynchronizeSqlListRequestBuilder {
    173 166 
             if (metadata.withEntities()) {
    174 167 
                 Multimap<Class<? extends ReferentialDto>, String> allIds = ArrayListMultimap.create(request.getIdsOnlyExistingOnThisSide());
    175 168 
                 allIds.putAll(newIds);
    176 
    -            updateGenerator = new UpdateSqlWithCascadeStatementGenerator<D>(metadataModel, metadata, request.getIdsOnlyExistingOnThisSide()) {
    177 
    -
    178 
    -                @Override
    179 
    -                protected <DD extends ReferentialDto> ImmutableList<String> insertMissingReferential(Class<DD> referentialType, String id) {
    180 
    -                    ReferentialDtoEntityContext<DD, ?, ?, ?> modelContext = DbModelHelper.fromReferentialDto(referentialType);
    181 
    -                    return addExtraInsertStatement(modelContext, id);
    182 
    -                }
    183 
    -            };
    184 
    -
    169 
    +            updateGenerator = new UpdateSqlWithCascadeStatementGenerator(service, metadataModel, metadata, request.getIdsOnlyExistingOnThisSide());
    185 170 
             } else {
    186 171 
                 updateGenerator = new UpdateSqlStatementGenerator(metadataModel, metadata);
    187 172 
             }
    ... ... @@ -256,7 +241,6 @@ public class ReferentialSynchronizeSqlListRequestBuilder {
    256 241 
             }
    257 242 
         }
    258 243
    259 
    -
    260 244 
         private <D extends ReferentialDto> void onDeactivateWithReplacement(TopiaMetadataEntity metadata, Class<D> dtoType, Set<ReferentialSynchronizeTask> tasks) {
    261 245
    262 246 
             ReplaceSqlStatementGenerator replaceGenerator = new ReplaceSqlStatementGenerator(metadataModel, metadata);
    ... ... @@ -277,18 +261,6 @@ public class ReferentialSynchronizeSqlListRequestBuilder {
    277 261 
             }
    278 262 
         }
    279 263
    280 
    -    private <D extends ReferentialDto, E extends ReferentialEntity<D, ?>> ImmutableList<String> addExtraInsertStatement(ReferentialDtoEntityContext<D, ?, E, ?> binder, String id) {
    281 
    -
    282 
    -        Class<E> entityType = binder.toEntityType();
    283 
    -        Class<D> dtoType = binder.toDtoType();
    284 
    -        String referentialName = ObserveEntityEnum.valueOf(entityType).name();
    285 
    -        TopiaMetadataEntity metadata = metadataModel.getEntity(referentialName);
    286 
    -
    287 
    -        InsertSqlStatementGenerator<D> insertGenerator = new InsertSqlStatementGenerator<>(metadataModel, metadata, dtoType);
    288 
    -        D referential = service.loadEntityToReferentialDto(binder, id);
    289 
    -        return insertGenerator.generateSql(referential);
    290 
    -    }
    291 
    -
    292 264 
         private <E extends ReferentialEntity> List<E> loadEntities(Class<E> entityType, Set<ReferentialSynchronizeTask> tasks) {
    293 265 
             Set<String> ids = tasks.stream().map(ReferentialSynchronizeTask::getReferentialId).collect(Collectors.toSet());
    294 266 
             return service.getTopiaPersistenceContext().loadEntities(entityType, ids);

  • services-local/src/main/java/fr/ird/observe/services/local/service/actions/synchro/referential/sql/InsertSqlGenerator.java
    ... ... @@ -29,7 +29,7 @@ import fr.ird.observe.dto.referential.ReferentialDto;
    29 29 
      * @author Tony Chemit - dev@tchemit.fr
    30 30 
      * @since ?
    31 31 
      */
    32 
    -public interface InsertSqlGenerator<D extends ReferentialDto> {
    32 
    +public interface InsertSqlGenerator {
    33 33
    34 
    -    ImmutableList<String> generateSql(D referentialDto);
    34 
    +    ImmutableList<String> generateSql(ReferentialDto referentialDto);
    35 35 
     }

  • services-local/src/main/java/fr/ird/observe/services/local/service/actions/synchro/referential/sql/InsertSqlStatementGenerator.java
    ... ... @@ -48,7 +48,7 @@ import java.util.Set;
    48 48 
      *
    49 49 
      * @author Tony Chemit - dev@tchemit.fr
    50 50 
      */
    51 
    -public class InsertSqlStatementGenerator<D extends ReferentialDto> implements InsertSqlGenerator<D> {
    51 
    +public class InsertSqlStatementGenerator implements InsertSqlGenerator {
    52 52
    53 53 
         private final TopiaMetadataEntity metadataEntity;
    54 54 
         private final Set<TopiaMetadataComposition> compositions;
    ... ... @@ -61,7 +61,7 @@ public class InsertSqlStatementGenerator<D extends ReferentialDto> implements In
    61 61 
         private final Set<String> primitiveLongPropertyNames;
    62 62 
         private final Set<String> primitiveFloatPropertyNames;
    63 63
    64 
    -    public InsertSqlStatementGenerator(TopiaMetadataModel topiaMetadataModel, TopiaMetadataEntity metadataEntity, Class<D> dtoType) {
    64 
    +    public InsertSqlStatementGenerator(TopiaMetadataModel topiaMetadataModel, TopiaMetadataEntity metadataEntity) {
    65 65 
             this.metadataEntity = Objects.requireNonNull(metadataEntity);
    66 66 
             this.compositions = topiaMetadataModel.getCompositions(this.metadataEntity);
    67 67 
             this.associations = topiaMetadataModel.getAssociations(this.metadataEntity);
    ... ... @@ -79,7 +79,7 @@ public class InsertSqlStatementGenerator<D extends ReferentialDto> implements In
    79 79
    80 80 
         @SuppressWarnings("unchecked")
    81 81 
         @Override
    82 
    -    public ImmutableList<String> generateSql(D referentialDto) {
    82 
    +    public ImmutableList<String> generateSql(ReferentialDto referentialDto) {
    83 83
    84 84 
             ImmutableList.Builder<String> result = ImmutableList.builder();
    85 85
    ... ... @@ -152,22 +152,27 @@ public class InsertSqlStatementGenerator<D extends ReferentialDto> implements In
    152 152 
             for (TopiaMetadataAssociation association : associations) {
    153 153
    154 154 
                 Collection<ReferentialDtoReference<?, ?>> associationValues = referentialDto.get(association.getTargetPropertyName());
    155 
    -            for (ReferentialDtoReference<?, ?> associationValue : associationValues) {
    156 
    -                String insertAssocationSql = TopiaSqlStatements.generateAssociationInsertStatement(association, id, associationValue.getId());
    157 
    -                result.add(TopiaSqlStatements.boxAssociationStatement(insertAssocationSql));
    155 
    +            for (@SuppressWarnings("rawtypes") ReferentialDtoReference associationValue : associationValues) {
    156 
    +                addAssociation(association, id, associationValue, result);
    158 157 
                 }
    159 158 
             }
    160 159 
             return result.build();
    160 
    +    }
    161 161
    162 
    +    protected <DD extends ReferentialDto, RR extends ReferentialDtoReference<DD, RR>> void addAssociation(TopiaMetadataAssociation association,
    163 
    +                                                                                                          String sourceId,
    164 
    +                                                                                                          RR associationValue,
    165 
    +                                                                                                          ImmutableList.Builder<String> builder) {
    166 
    +        String insertSql = TopiaSqlStatements.generateAssociationInsertStatement(association, sourceId, associationValue.getId());
    167 
    +        builder.add(TopiaSqlStatements.boxAssociationStatement(insertSql));
    162 168 
         }
    163 169
    170 
    +    protected <DD extends ReferentialDto, RR extends ReferentialDtoReference<DD, RR>> void addReferentialReferenceParameter(RR parameter, List<String> parameters, ImmutableList.Builder<String> result) {
    171 
    +        addStringParameter(parameter.getId(), parameters);
    172 
    +    }
    164 173
    165 
    -    <DD extends ReferentialDto, RR extends ReferentialDtoReference<DD, RR>> void addAssociation(TopiaMetadataAssociation association,
    166 
    -                                                                                                String sourceId,
    167 
    -                                                                                                RR associationValue,
    168 
    -                                                                                                ImmutableList.Builder<String> builder) {
    169 
    -        String insertAssocationSql = TopiaSqlStatements.generateAssociationInsertStatement(association, sourceId, associationValue.getId());
    170 
    -        builder.add(TopiaSqlStatements.boxAssociationStatement(insertAssocationSql));
    174 
    +    protected <DD extends ReferentialDto> void addReferentialDtoParameter(DD parameter, List<String> parameters, ImmutableList.Builder<String> result) {
    175 
    +        addStringParameter(parameter.getId(), parameters);
    171 176 
         }
    172 177
    173 178 
         private Set<String> computeColumnNames(TopiaMetadataEntity metadataEntity,
    ... ... @@ -227,12 +232,4 @@ public class InsertSqlStatementGenerator<D extends ReferentialDto> implements In
    227 232 
             parameters.add("" + parameter);
    228 233 
         }
    229 234
    230 
    -    protected <DD extends ReferentialDto, RR extends ReferentialDtoReference<DD, RR>> void addReferentialReferenceParameter(RR parameter, List<String> parameters, ImmutableList.Builder<String> result) {
    231 
    -        addStringParameter(parameter.getId(), parameters);
    232 
    -    }
    233 
    -
    234 
    -    protected <DD extends ReferentialDto> void addReferentialDtoParameter(DD parameter, List<String> parameters, ImmutableList.Builder<String> result) {
    235 
    -        addStringParameter(parameter.getId(), parameters);
    236 
    -    }
    237 
    -
    238 235 
     }

  • services-local/src/main/java/fr/ird/observe/services/local/service/actions/synchro/referential/sql/InsertSqlWithCascadeStatementGenerator.java
    ... ... @@ -26,6 +26,7 @@ import com.google.common.collect.ImmutableList;
    26 26 
     import com.google.common.collect.Multimap;
    27 27 
     import fr.ird.observe.dto.reference.ReferentialDtoReference;
    28 28 
     import fr.ird.observe.dto.referential.ReferentialDto;
    29 
    +import fr.ird.observe.services.local.service.actions.synchro.referential.ng.ReferentialSynchronizeServiceLocal;
    29 30 
     import org.nuiton.topia.persistence.metadata.TopiaMetadataAssociation;
    30 31 
     import org.nuiton.topia.persistence.metadata.TopiaMetadataEntity;
    31 32 
     import org.nuiton.topia.persistence.metadata.TopiaMetadataModel;
    ... ... @@ -40,62 +41,43 @@ import java.util.List;
    40 41 
      * @author Tony Chemit - dev@tchemit.fr
    41 42 
      * @since 5.0
    42 43 
      */
    43 
    -public abstract class InsertSqlWithCascadeStatementGenerator<D extends ReferentialDto> implements InsertSqlGenerator<D>{
    44 
    +public class InsertSqlWithCascadeStatementGenerator extends WithCascadeStatementGenerator implements InsertSqlGenerator {
    44 45
    45 
    -    private final InsertSqlStatementGenerator<D> delegateGenerator;
    46 
    -    private final Multimap<Class<? extends ReferentialDto>, String> idsOnlyExistingOnThisSide;
    46 
    +    private final InsertSqlStatementGenerator delegateGenerator;
    47 47
    48 
    -    protected InsertSqlWithCascadeStatementGenerator(TopiaMetadataModel topiaMetadataModel, TopiaMetadataEntity metadataEntity,
    49 
    -                                                     Class<D> dtoType,
    48 
    +    public InsertSqlWithCascadeStatementGenerator(ReferentialSynchronizeServiceLocal service,
    49 
    +                                                     TopiaMetadataModel topiaMetadataModel,
    50 
    +                                                     TopiaMetadataEntity metadataEntity,
    51 
    +                                                     Class<? extends ReferentialDto> dtoType,
    50 52 
                                                          Multimap<Class<? extends ReferentialDto>, String> idsOnlyExistingOnThisSide) {
    51 
    -        this.idsOnlyExistingOnThisSide = idsOnlyExistingOnThisSide;
    52 
    -        this.delegateGenerator = new InsertSqlStatementGenerator<D>(topiaMetadataModel, metadataEntity, dtoType) {
    53 
    -
    53 
    +        super(service, topiaMetadataModel);
    54 
    +        this.delegateGenerator = new InsertSqlStatementGenerator(topiaMetadataModel, metadataEntity) {
    54 55 
                 @Override
    55 
    -            <DD extends ReferentialDto, RR extends ReferentialDtoReference<DD, RR>> void addAssociation(TopiaMetadataAssociation association,
    56 
    -                                                                                                        String sourceId,
    57 
    -                                                                                                        RR associationValue,
    58 
    -                                                                                                        ImmutableList.Builder<String> builder) {
    56 
    +            protected <DD extends ReferentialDto, RR extends ReferentialDtoReference<DD, RR>> void addAssociation(TopiaMetadataAssociation association,
    57 
    +                                                                                                                  String sourceId,
    58 
    +                                                                                                                  RR associationValue,
    59 
    +                                                                                                                  ImmutableList.Builder<String> builder) {
    59 60 
                     super.addAssociation(association, sourceId, associationValue, builder);
    60 
    -                addMissingReferentialIfNecessary(associationValue.getDtoType(), associationValue.getId(), builder);
    61 
    +                addMissingReferentialIfNecessary(idsOnlyExistingOnThisSide, associationValue.getDtoType(), associationValue.getId(), builder);
    61 62 
                 }
    62 63
    63 64 
                 @Override
    64 
    -            protected <DD extends ReferentialDto, RR extends ReferentialDtoReference<DD, RR>> void addReferentialReferenceParameter(RR parameter, List<String> parameters, ImmutableList.Builder<String> result) {
    65 
    -                super.addReferentialReferenceParameter(parameter, parameters, result);
    66 
    -                addMissingReferentialIfNecessary(parameter.getDtoType(), parameter.getId(), result);
    65 
    +            protected <DD extends ReferentialDto, RR extends ReferentialDtoReference<DD, RR>> void addReferentialReferenceParameter(RR parameter, List<String> parameters, ImmutableList.Builder<String> builder) {
    66 
    +                super.addReferentialReferenceParameter(parameter, parameters, builder);
    67 
    +                addMissingReferentialIfNecessary(idsOnlyExistingOnThisSide, parameter.getDtoType(), parameter.getId(), builder);
    67 68 
                 }
    68 69
    69 70 
                 @Override
    70 
    -            protected <DD extends ReferentialDto> void addReferentialDtoParameter(DD parameter, List<String> parameters, ImmutableList.Builder<String> result) {
    71 
    -                super.addReferentialDtoParameter(parameter, parameters, result);
    72 
    -                addMissingReferentialIfNecessary(dtoType, parameter.getId(), result);
    71 
    +            protected <DD extends ReferentialDto> void addReferentialDtoParameter(DD parameter, List<String> parameters, ImmutableList.Builder<String> builder) {
    72 
    +                super.addReferentialDtoParameter(parameter, parameters, builder);
    73 
    +                addMissingReferentialIfNecessary(idsOnlyExistingOnThisSide, dtoType, parameter.getId(), builder);
    73 74 
                 }
    74 75 
             };
    75 76 
         }
    76 77
    77 
    -    protected abstract <DD extends ReferentialDto> ImmutableList<String> insertMissingReferential(Class<DD> referentialType, String id);
    78 
    -
    79 78 
         @Override
    80 
    -    public ImmutableList<String> generateSql(D referentialDto) {
    81 
    -
    79 
    +    public ImmutableList<String> generateSql(ReferentialDto referentialDto) {
    82 80 
             return delegateGenerator.generateSql(referentialDto);
    83 
    -
    84 
    -    }
    85 
    -
    86 
    -    private <DD extends ReferentialDto> void addMissingReferentialIfNecessary(Class<DD> associationType, String associationId, ImmutableList.Builder<String> builder) {
    87 
    -
    88 
    -        if (idsOnlyExistingOnThisSide.containsEntry(associationType, associationId)) {
    89 
    -
    90 
    -            // il faut insérer aussi ce référentiel
    91 
    -            ImmutableList<String> sql = insertMissingReferential(associationType, associationId);
    92 
    -
    93 
    -            builder.addAll(sql);
    94 
    -
    95 
    -            // ce référentiel est désormais présent dans les deux sources
    96 
    -            idsOnlyExistingOnThisSide.remove(associationType, associationId);
    97 
    -
    98 
    -        }
    99 81 
         }
    100 82
    101 83 
     }

  • services-local/src/main/java/fr/ird/observe/services/local/service/actions/synchro/referential/sql/UpdateSqlStatementGenerator.java
    ... ... @@ -208,14 +208,22 @@ public class UpdateSqlStatementGenerator implements UpdateSqlGenerator {
    208 208 
             return result.build();
    209 209 
         }
    210 210
    211 
    -    <DD extends ReferentialDto, RR extends ReferentialDtoReference<DD, RR>> void addAssociation(TopiaMetadataAssociation association,
    212 
    -                                                                                                String sourceId,
    213 
    -                                                                                                RR associationValue,
    214 
    -                                                                                                ImmutableList.Builder<String> builder) {
    211 
    +    protected <DD extends ReferentialDto, RR extends ReferentialDtoReference<DD, RR>> void addAssociation(TopiaMetadataAssociation association,
    212 
    +                                                                                                          String sourceId,
    213 
    +                                                                                                          RR associationValue,
    214 
    +                                                                                                          ImmutableList.Builder<String> builder) {
    215 215 
             String insertSql = TopiaSqlStatements.generateAssociationInsertStatement(association, sourceId, associationValue.getId());
    216 216 
             builder.add(TopiaSqlStatements.boxAssociationStatement(insertSql));
    217 217 
         }
    218 218
    219 
    +    protected <DD extends ReferentialDto, RR extends ReferentialDtoReference<DD, RR>> void addReferentialReferenceParameter(String columnName, RR parameter, StringBuilder parameters, ImmutableList.Builder<String> result) {
    220 
    +        addStringParameter(columnName, parameter.getId(), parameters);
    221 
    +    }
    222 
    +
    223 
    +    protected <DD extends ReferentialDto> void addReferentialDtoParameter(String columnName, DD parameter, StringBuilder parameters, ImmutableList.Builder<String> result) {
    224 
    +        addStringParameter(columnName, parameter.getId(), parameters);
    225 
    +    }
    226 
    +
    219 227 
         private Map<String, String> computeColumnNames(TopiaMetadataEntity metadataEntity, String[] simplePropertyNames, String[] compositionPropertyNames) {
    220 228 
             Map<String, String> columnNames = new TreeMap<>();
    221 229
    ... ... @@ -252,14 +260,6 @@ public class UpdateSqlStatementGenerator implements UpdateSqlGenerator {
    252 260 
             addParameter0(columnName, "" + parameter, parameters);
    253 261 
         }
    254 262
    255 
    -    protected <DD extends ReferentialDto, RR extends ReferentialDtoReference<DD, RR>> void addReferentialReferenceParameter(String columnName, RR parameter, StringBuilder parameters, ImmutableList.Builder<String> result) {
    256 
    -        addStringParameter(columnName, parameter.getId(), parameters);
    257 
    -    }
    258 
    -
    259 
    -    protected <DD extends ReferentialDto> void addReferentialDtoParameter(String columnName, DD parameter, StringBuilder parameters, ImmutableList.Builder<String> result) {
    260 
    -        addStringParameter(columnName, parameter.getId(), parameters);
    261 
    -    }
    262 
    -
    263 263 
         private void addParameter0(String columnName, String value, StringBuilder parameters) {
    264 264 
             parameters.append(", ").append(columnName).append(" = ").append(value);
    265 265 
         }

  • services-local/src/main/java/fr/ird/observe/services/local/service/actions/synchro/referential/sql/UpdateSqlWithCascadeStatementGenerator.java
    ... ... @@ -27,6 +27,7 @@ import com.google.common.collect.ImmutableSet;
    27 27 
     import com.google.common.collect.Multimap;
    28 28 
     import fr.ird.observe.dto.reference.ReferentialDtoReference;
    29 29 
     import fr.ird.observe.dto.referential.ReferentialDto;
    30 
    +import fr.ird.observe.services.local.service.actions.synchro.referential.ng.ReferentialSynchronizeServiceLocal;
    30 31 
     import org.nuiton.topia.persistence.metadata.TopiaMetadataAssociation;
    31 32 
     import org.nuiton.topia.persistence.metadata.TopiaMetadataEntity;
    32 33 
     import org.nuiton.topia.persistence.metadata.TopiaMetadataModel;
    ... ... @@ -41,58 +42,41 @@ import java.util.Date;
    41 42 
      * @author Tony Chemit - dev@tchemit.fr
    42 43 
      * @since 5.0
    43 44 
      */
    44 
    -public abstract class UpdateSqlWithCascadeStatementGenerator<D extends ReferentialDto> implements UpdateSqlGenerator {
    45 
    +public class UpdateSqlWithCascadeStatementGenerator extends WithCascadeStatementGenerator implements UpdateSqlGenerator {
    45 46
    46 47 
         private final UpdateSqlStatementGenerator delegateGenerator;
    47 
    -    private final Multimap<Class<? extends ReferentialDto>, String> idsOnlyExistingOnThisSide;
    48 48
    49 
    -    protected UpdateSqlWithCascadeStatementGenerator(TopiaMetadataModel topiaMetadataModel,
    50 
    -                                                     TopiaMetadataEntity metadataEntity,
    51 
    -                                                     Multimap<Class<? extends ReferentialDto>, String> idsOnlyExistingOnThisSide) {
    52 
    -        this.idsOnlyExistingOnThisSide = idsOnlyExistingOnThisSide;
    49 
    +    public UpdateSqlWithCascadeStatementGenerator(ReferentialSynchronizeServiceLocal service,
    50 
    +                                                  TopiaMetadataModel topiaMetadataModel,
    51 
    +                                                  TopiaMetadataEntity metadataEntity,
    52 
    +                                                  Multimap<Class<? extends ReferentialDto>, String> idsOnlyExistingOnThisSide) {
    53 
    +        super(service, topiaMetadataModel);
    53 54 
             this.delegateGenerator = new UpdateSqlStatementGenerator(topiaMetadataModel, metadataEntity) {
    54 
    -
    55 
    -
    56 
    -            <DD extends ReferentialDto, RR extends ReferentialDtoReference<DD, RR>> void addAssociation(TopiaMetadataAssociation association,
    57 
    -                                                                                                        String sourceId,
    58 
    -                                                                                                        RR associationValue,
    59 
    -                                                                                                        ImmutableList.Builder<String> builder) {
    55 
    +            @Override
    56 
    +            protected <DD extends ReferentialDto, RR extends ReferentialDtoReference<DD, RR>> void addAssociation(TopiaMetadataAssociation association,
    57 
    +                                                                                                                  String sourceId,
    58 
    +                                                                                                                  RR associationValue,
    59 
    +                                                                                                                  ImmutableList.Builder<String> builder) {
    60 60 
                     super.addAssociation(association, sourceId, associationValue, builder);
    61 
    -                addMissingReferentialIfNecessary(associationValue.getDtoType(), associationValue.getId(), builder);
    61 
    +                addMissingReferentialIfNecessary(idsOnlyExistingOnThisSide, associationValue.getDtoType(), associationValue.getId(), builder);
    62 62 
                 }
    63 63
    64 64 
                 @Override
    65 
    -            protected <DD extends ReferentialDto, RR extends ReferentialDtoReference<DD, RR>> void addReferentialReferenceParameter(String columnName, RR parameter, StringBuilder parameters, ImmutableList.Builder<String> result) {
    66 
    -                super.addReferentialReferenceParameter(columnName, parameter, parameters, result);
    67 
    -                addMissingReferentialIfNecessary(parameter.getDtoType(), parameter.getId(), result);
    65 
    +            protected <DD extends ReferentialDto, RR extends ReferentialDtoReference<DD, RR>> void addReferentialReferenceParameter(String columnName, RR parameter, StringBuilder parameters, ImmutableList.Builder<String> builder) {
    66 
    +                super.addReferentialReferenceParameter(columnName, parameter, parameters, builder);
    67 
    +                addMissingReferentialIfNecessary(idsOnlyExistingOnThisSide, parameter.getDtoType(), parameter.getId(), builder);
    68 68 
                 }
    69 69
    70 70 
                 @Override
    71 
    -            protected <DD extends ReferentialDto> void addReferentialDtoParameter(String columnName, DD parameter, StringBuilder parameters, ImmutableList.Builder<String> result) {
    72 
    -                super.addReferentialDtoParameter(columnName, parameter, parameters, result);
    73 
    -                addMissingReferentialIfNecessary(parameter.getClass(), parameter.getId(), result);
    71 
    +            protected <DD extends ReferentialDto> void addReferentialDtoParameter(String columnName, DD parameter, StringBuilder parameters, ImmutableList.Builder<String> builder) {
    72 
    +                super.addReferentialDtoParameter(columnName, parameter, parameters, builder);
    73 
    +                addMissingReferentialIfNecessary(idsOnlyExistingOnThisSide, parameter.getClass(), parameter.getId(), builder);
    74 74 
                 }
    75 75 
             };
    76 76 
         }
    77 77
    78 
    -    protected abstract <DD extends ReferentialDto> ImmutableList<String> insertMissingReferential(Class<DD> referentialType, String id);
    79 
    -
    80 78 
         @Override
    81 79 
         public ImmutableList<String> generateSql(ReferentialDto referentialDto, ImmutableSet<String> properties, Date lastUpdateDate) {
    82 80 
             return delegateGenerator.generateSql(referentialDto, properties, lastUpdateDate);
    83 81 
         }
    84 
    -
    85 
    -    private <DD extends ReferentialDto> void addMissingReferentialIfNecessary(Class<DD> associationType, String associationId, ImmutableList.Builder<String> result) {
    86 
    -
    87 
    -        if (idsOnlyExistingOnThisSide.containsEntry(associationType, associationId)) {
    88 
    -
    89 
    -            // il faut insérer aussi ce référentiel
    90 
    -            ImmutableList<String> sqlList = insertMissingReferential(associationType, associationId);
    91 
    -            result.addAll(sqlList);
    92 
    -            // ce référentiel est désormais présent dans les deux sources
    93 
    -            idsOnlyExistingOnThisSide.remove(associationType, associationId);
    94 
    -
    95 
    -        }
    96 
    -    }
    97 
    -
    98 82 
     }

  • services-local/src/main/java/fr/ird/observe/services/local/service/actions/synchro/referential/sql/WithCascadeStatementGenerator.java
    1 
    +package fr.ird.observe.services.local.service.actions.synchro.referential.sql;
    2 
    +
    3 
    +/*-
    4 
    + * #%L
    5 
    + * ObServe :: Services local
    6 
    + * %%
    7 
    + * Copyright (C) 2008 - 2020 IRD, Code Lutin, Ultreia.io
    8 
    + * %%
    9 
    + * This program is free software: you can redistribute it and/or modify
    10 
    + * it under the terms of the GNU General Public License as
    11 
    + * published by the Free Software Foundation, either version 3 of the
    12 
    + * License, or (at your option) any later version.
    13 
    + *
    14 
    + * This program is distributed in the hope that it will be useful,
    15 
    + * but WITHOUT ANY WARRANTY; without even the implied warranty of
    16 
    + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    17 
    + * GNU General Public License for more details.
    18 
    + *
    19 
    + * You should have received a copy of the GNU General Public
    20 
    + * License along with this program.  If not, see
    21 
    + * <http://www.gnu.org/licenses/gpl-3.0.html>.
    22 
    + * #L%
    23 
    + */
    24 
    +
    25 
    +import com.google.common.collect.ImmutableList;
    26 
    +import com.google.common.collect.Multimap;
    27 
    +import fr.ird.observe.dto.reference.ReferentialDtoReference;
    28 
    +import fr.ird.observe.dto.referential.ReferentialDto;
    29 
    +import fr.ird.observe.entities.ObserveEntityEnum;
    30 
    +import fr.ird.observe.entities.referential.ReferentialEntity;
    31 
    +import fr.ird.observe.services.local.service.actions.synchro.referential.ng.ReferentialSynchronizeServiceLocal;
    32 
    +import fr.ird.observe.spi.DbModelHelper;
    33 
    +import fr.ird.observe.spi.context.ReferentialDtoEntityContext;
    34 
    +import org.nuiton.topia.persistence.metadata.TopiaMetadataEntity;
    35 
    +import org.nuiton.topia.persistence.metadata.TopiaMetadataModel;
    36 
    +
    37 
    +/**
    38 
    + * Support statement generator when a cascade can be done on adding new referential.
    39 
    + *
    40 
    + * @author Tony Chemit - dev@tchemit.fr
    41 
    + * @since 8.0
    42 
    + */
    43 
    +public abstract class WithCascadeStatementGenerator {
    44 
    +
    45 
    +    private final ReferentialSynchronizeServiceLocal service;
    46 
    +    private final TopiaMetadataModel metadataModel;
    47 
    +
    48 
    +    protected WithCascadeStatementGenerator(ReferentialSynchronizeServiceLocal service, TopiaMetadataModel metadataModel) {
    49 
    +        this.service = service;
    50 
    +        this.metadataModel = metadataModel;
    51 
    +    }
    52 
    +
    53 
    +    public <D extends ReferentialDto> void addMissingReferentialIfNecessary(Multimap<Class<? extends ReferentialDto>, String> idsOnlyExistingOnThisSide, Class<D> associationType, String associationId, ImmutableList.Builder<String> builder) {
    54 
    +
    55 
    +        if (idsOnlyExistingOnThisSide.containsEntry(associationType, associationId)) {
    56 
    +            // need to add this referential on this other side
    57 
    +            ImmutableList<String> sqlList = insertMissingReferential(associationType, associationId);
    58 
    +            builder.addAll(sqlList);
    59 
    +            // now this referential is on both side
    60 
    +            idsOnlyExistingOnThisSide.remove(associationType, associationId);
    61 
    +        }
    62 
    +    }
    63 
    +
    64 
    +    protected <D extends ReferentialDto, R extends ReferentialDtoReference<D, R>, E extends ReferentialEntity<D, R>> ImmutableList<String> insertMissingReferential(Class<D> referentialType, String id) {
    65 
    +        ReferentialDtoEntityContext<D, R, E, ?> modelContext = DbModelHelper.fromReferentialDto(referentialType);
    66 
    +
    67 
    +        Class<E> entityType = modelContext.toEntityType();
    68 
    +        String referentialName = ObserveEntityEnum.valueOf(entityType).name();
    69 
    +        TopiaMetadataEntity metadata = metadataModel.getEntity(referentialName);
    70 
    +
    71 
    +        InsertSqlStatementGenerator insertGenerator = new InsertSqlStatementGenerator(metadataModel, metadata);
    72 
    +        D referential = service.loadEntityToReferentialDto(modelContext, id);
    73 
    +        return insertGenerator.generateSql(referential);
    74 
    +    }
    75 
    +
    76 
    +
    77 
    +}

    • —
    View it on GitLab.
    You're receiving this email because of your account on gitlab.com. If you'd like to receive fewer emails, you can adjust your notification settings.