+observe.data.ps.observation.NonTargetCatchRelease.message.will.delete.sub.data

+observe.data.ps.observation.NonTargetCatchRelease.message.will.delete.sub.data.for.species

+import fr.ird.observe.client.datasource.editor.api.content.data.table.AskToDelete;

+import fr.ird.observe.dto.data.ps.observation.SetNonTargetCatchReleaseDto;

+import fr.ird.observe.dto.referential.common.SpeciesReference;

+import io.ultreia.java4all.i18n.I18n;

+import java.util.List;

+        referenceCache.addReferentialFilter(NonTargetCatchReleaseDto.PROPERTY_SPECIES, ReferencesFilterHelper.<SetNonTargetCatchReleaseDto, SpeciesReference>newSubList(SetNonTargetCatchReleaseDto::getAvailableSpeciesIds));

+    @Override

+    public boolean canSave(SetNonTargetCatchReleaseDto originalBean, SetNonTargetCatchReleaseDto bean, List<NonTargetCatchReleaseDto> data) {

+        AskToDelete<SetNonTargetCatchReleaseDto> ask = new AskToDelete<>(

+                SetNonTargetCatchReleaseDto::getRemovedUnsafeSpecies,

+                I18n.n("observe.data.ps.observation.NonTargetCatchRelease.message.will.delete.sub.data"));

+        return ask.needDelete(this.getClientUIContext().getDecoratorService(), originalBean, bean);

+    }

+import static io.ultreia.java4all.i18n.I18n.t;

+

+

+    @Override

+    protected String getDeleteExtraMessage(NonTargetCatchReleaseDto bean) {

+        if (bean.isHasSample()) {

+            int count = getBean().getUnsafeSpeciesUsageCount(bean.getSpecies());

+            if (count == 1) {

+                // while deleting this one, this species won't be available on sample

+                return t("observe.data.ps.observation.NonTargetCatchRelease.message.will.delete.sub.data.for.species", bean.getSpecies());

+            }

+        }

+        // No specific message

+        return null;

+    }

+observe.data.ps.observation.NonTargetCatchRelease.message.will.delete.sub.data=If you confirm save, some data could be deleted\!\n\nFollowing species won't be useable in samples \:\n%1$s\nAll samples of those species will be deleted.

+observe.data.ps.observation.NonTargetCatchRelease.message.will.delete.sub.data.for.species=\nIf you delete this non target catch release, the species (%s) will not be available for samples.\nSamples using this species (%s) will also be deleted.

+observe.data.ps.observation.NonTargetCatchRelease.message.will.delete.sub.data=If you confirm save, some data could be deleted\!\n\nFollowing species won't be useable in samples \:\n%1$s\nAll samples of those species will be deleted. \#TODO

+observe.data.ps.observation.NonTargetCatchRelease.message.will.delete.sub.data.for.species=\nIf you delete this non target catch release, the species (%s) will not be available for samples.\nSamples using this species (%s) will also be deleted. \#TODO

+observe.data.ps.observation.NonTargetCatch.message.will.delete.sub.data=En confirmant la sauvegarde des objets vont être supprimés\!\n\nLes espèces suivantes ne seront plus utilisables dans des échantillonnages ou les espèces libérées \:\n%1$s\nCela entrainera la suppression des données saisies liées à ces espèces

+observe.data.ps.observation.NonTargetCatch.message.will.delete.sub.data.for.species=\nLe fait de supprimer cette capture rend indisponible l'espèce (%s) sur les libérations ou les échantillons.\nLes libérations ou échantillons utilisant cette espèce seront alors supprimer.

+observe.data.ps.observation.NonTargetCatchRelease.message.will.delete.sub.data=En confirmant la sauvegarde des objets vont être supprimés\!\n\nLes espèces suivantes ne seront plus utilisables dans des échantillonages \:\n%1$s\nCela entrainera la suppression des données saisies liées à ces espèces

+observe.data.ps.observation.NonTargetCatchRelease.message.will.delete.sub.data.for.species=\nLe fait de supprimer cette libération rend indisponible l'espèce (%s) sur les échantillons.\nLes échantillons utilisant cette espèce seront alors supprimer.

+hasSample + {*:1} boolean

+package fr.ird.observe.dto.data.ps.observation;

+

+/*-

+ * #%L

+ * ObServe Models :: Dto

+ * %%

+ * Copyright (C) 2008 - 2021 IRD, Code Lutin, Ultreia.io

+ * %%

+ * 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.ird.observe.dto.referential.common.SpeciesReference;

+import io.ultreia.java4all.bean.spi.GenerateJavaBeanDefinition;

+

+import java.util.Objects;

+import java.util.Set;

+import java.util.stream.Collectors;

+

+@GenerateJavaBeanDefinition

+public class SetNonTargetCatchReleaseDto extends GeneratedSetNonTargetCatchReleaseDto {

+

+    private static final long serialVersionUID = 1L;

+

+    /**

+     * Get the set of unsafe species no more used in the {@code incoming} dto.

+     *

+     * @param incoming the dto to compare this

+     * @return the set of unsafe species no more used in incoming dto

+     */

+    public Set<SpeciesReference> getRemovedUnsafeSpecies(SetNonTargetCatchReleaseDto incoming) {

+        // Get all unsafe species

+        Set<SpeciesReference> allUnsafeSpecies = getUnsafeSpecies();

+        // Get incoming used unsafe species

+        Set<SpeciesReference> incomingUsedUnsafeSpecies = incoming.getUnsafeSpecies();

+        // Remove for all the used

+        allUnsafeSpecies.removeAll(incomingUsedUnsafeSpecies);

+        // This will return the set of no more used unsafe species

+        return allUnsafeSpecies;

+    }

+

+    /**

+     * @return set of unsafe species used in catches

+     */

+    public Set<SpeciesReference> getUnsafeSpecies() {

+        return getNonTargetCatchRelease().stream().filter(NonTargetCatchReleaseDto::isHasSample).map(NonTargetCatchReleaseDto::getSpecies).collect(Collectors.toSet());

+    }

+

+    /**

+     * @param species species to test

+     * @return count of usage of this species in catches

+     */

+    public int getUnsafeSpeciesUsageCount(SpeciesReference species) {

+        return (int) getNonTargetCatchRelease().stream().filter(d -> Objects.equals(species, d.getSpecies())).count();

+    }

+}

+import fr.ird.observe.dto.data.ps.observation.NonTargetCatchReleaseDto;

+        return isNonTargetCatchNotEmpty() && getNonTargetCatch().stream().anyMatch(t -> isSpeciesGroupRelease(t.getSpecies()));

+        if (dto instanceof SetNonTargetCatchReleaseDto) {

+            toSetNonTargetCatchReleaseDto(referentialLocale, (SetNonTargetCatchReleaseDto) dto);

+            return;

+        }

+        if (dto instanceof SetNonTargetCatchReleaseDto) {

+            fromSetNonTargetCatchReleaseDto(referentialLocale, (SetNonTargetCatchReleaseDto) dto);

+            return;

+        }

+                catchDto.setHasSample(hasSample);

+                catchDto.setHasSample(hasSample);

+    private void toSetNonTargetCatchReleaseDto(ReferentialLocale referentialLocale, SetNonTargetCatchReleaseDto dto) {

+        // do normal copy

+        super.toDto(referentialLocale, dto);

+        // is there some sample?

+        if (isNonTargetSampleNotEmpty()) {

+            NonTargetSample targetSample = getNonTargetSample().iterator().next();

+            // get usable species ids

+            java.util.Set<String> speciesId = DtoReferenceAware.ids(targetSample.getNonTargetLength().stream().map(NonTargetLength::getSpecies));

+            // mark catch if there is associated samples to it

+            dto.getNonTargetCatchRelease().forEach(childDto -> {

+                boolean hasSample = speciesId.contains(childDto.getSpecies().getId());

+                childDto.setHasSample(hasSample);

+            });

+        }

+        dto.setAvailableSpeciesIds(getNonTargetCatch().stream().map(NonTargetCatch::getSpecies).filter(this::isSpeciesGroupRelease).map(Species::getTopiaId).distinct().collect(ImmutableSet.toImmutableSet()));

+    }

+

+    private void fromSetNonTargetCatchReleaseDto(ReferentialLocale referentialLocale, SetNonTargetCatchReleaseDto dto) {

+        // do normal copy

+        super.fromDto(referentialLocale, dto);

+        // delete any discarded sample which not using the given species ids

+        //FIXME should we also check in non target catches ???

+//        TargetSample targetSample = getTargetSample(true);

+//        if (targetSample != null) {

+//            List<NonTargetCatchReleaseDto> targetCatch = dto.getNonTargetCatchRelease();

+//            Set<String> speciesIds = DtoReferenceAware.ids(targetCatch.stream().map(NonTargetCatchReleaseDto::getSpecies));

+//            // remove sample from species ids

+//            targetSample.getTargetLength().removeIf(targetLength -> !speciesIds.contains(targetLength.getSpecies().getTopiaId()));

+//        }

+    }

+