Project

General

Profile

Revision 940e93a1

ID940e93a138cb1003aa0366647204aee36758cba5
Parent 161620f9
Child 1a22bd3d

Added by Andreas Kohlbecker almost 3 years ago

fix #7354 DerivedUnitConverter handled typeDesignations correctly and abstains from persising anything

View differences:

cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/utility/DerivedUnitConverter.java
11 11
import java.lang.reflect.InvocationTargetException;
12 12
import java.lang.reflect.Method;
13 13

  
14
import eu.etaxonomy.cdm.api.service.IOccurrenceService;
14
import org.apache.log4j.Logger;
15

  
15 16
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
16 17
import eu.etaxonomy.cdm.model.media.Media;
18
import eu.etaxonomy.cdm.model.name.Registration;
17 19
import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignation;
20
import eu.etaxonomy.cdm.model.name.TaxonName;
18 21
import eu.etaxonomy.cdm.model.occurrence.DerivationEvent;
19 22
import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;
20 23
import eu.etaxonomy.cdm.model.occurrence.MediaSpecimen;
......
30 33

  
31 34
    private DerivedUnit source;
32 35

  
33
    IOccurrenceService service;
36
    private SpecimenTypeDesignation specimenTypeDesignation;
37

  
38
    private SpecimenTypeDesignation newSpecimenTypeDesignation;
39

  
40
    private static final Logger logger = Logger.getLogger(DerivedUnitConverter.class);
34 41

  
35 42
    /**
36 43
     * @param specimenTypeDesignation
37 44
     */
38
    protected DerivedUnitConverter(DerivedUnit derivedUnit, IOccurrenceService service) {
39
        if(derivedUnit == null){
45
    public DerivedUnitConverter(DerivedUnit source) throws Exception {
46
        if(source == null){
40 47
            throw new NullPointerException();
41 48
        }
42
        this.service = service;
43
        this.source = HibernateProxyHelper.deproxy(derivedUnit, DerivedUnit.class);
49
        this.source = HibernateProxyHelper.deproxy(source, DerivedUnit.class);
50
        if(source.getSpecimenTypeDesignations().size() == 1){
51
            specimenTypeDesignation = source.getSpecimenTypeDesignations().iterator().next();
52
        } else if (source.getSpecimenDescriptions().size() > 1){
53
            throw new Exception("can not convert derived unit with multipe type designations");
54
        }
55
    }
44 56

  
57
    /**
58
     * @param specimenTypeDesignation
59
     */
60
    public DerivedUnitConverter(SpecimenTypeDesignation specimenTypeDesignation) {
61
        if(specimenTypeDesignation == null){
62
            throw new NullPointerException();
63
        }
64
        this.specimenTypeDesignation = HibernateProxyHelper.deproxy(specimenTypeDesignation);
65
        this.source = HibernateProxyHelper.deproxy(specimenTypeDesignation.getTypeSpecimen(), DerivedUnit.class);
45 66
    }
46 67

  
47 68
    /**
48
     * converts the <code>source</code> <code>DerivedUnit</code> this converter has been created for into a <code>DerivedUnit</code> of the type <code>TARGET</code>.
49
     * If the <code>source</code> instance was persisted the target instance will also be written into data base and the source is deleted from there.
69
     * converts the <code>source</code> <code>DerivedUnit</code> this converter has been created
70
     * for into a <code>DerivedUnit</code> of the type <code>TARGET</code>.
71
     * If the <code>source</code> instance was persisted the target instance will also be written
72
     * into data base and the source is deleted from there.
50 73
     *
51 74
     * @param targetType
52 75
     * @param recordBasis
53 76
     * @throws DerivedUnitConversionException
54 77
     */
55 78
    @SuppressWarnings("unchecked")
56
    public TARGET convertTo(Class<TARGET> targetType, SpecimenOrObservationType recordBasis) throws DerivedUnitConversionException {
79
    public SpecimenTypeDesignation convertTo(Class<TARGET> targetType, SpecimenOrObservationType recordBasis) throws DerivedUnitConversionException {
57 80

  
58 81
        if(source.getClass().equals(targetType)){
59 82
            // nothing to do
60
            return (TARGET) source;
83
            return specimenTypeDesignation;
61 84
        }
62 85

  
63 86
        if(!isSuppoprtedType(targetType)){
......
87 110
            throw new DerivedUnitConversionException("Error during intantiation of " + targetType.getName(), e);
88 111
        }
89 112

  
90

  
91
        if(source.getId() > 0){
92
            service.merge(newInstance);
93
            service.delete(source);
94
        }
95

  
96
        return newInstance;
113
        logger.error("convertion of " + source.instanceToString() + "<--" + specimenTypeDesignation.instanceToString()
114
                + " to "
115
                + newSpecimenTypeDesignation.getTypeSpecimen().instanceToString() +  "<--" + newSpecimenTypeDesignation.instanceToString() );
116
        return newSpecimenTypeDesignation;
97 117

  
98 118
    }
99 119

  
......
139 159
        source.getMarkers().forEach(m -> n.addMarker(m));
140 160
        source.getRights().forEach(r -> n.addRights(r));
141 161
        n.addSources(source.getSources());
142
        for(SpecimenTypeDesignation std :  source.getSpecimenTypeDesignations()) {
143
            std.setTypeSpecimen(n);
144
            n.addSpecimenTypeDesignation(std);
145
         }
146
        source.getSpecimenTypeDesignations().clear();
162
        // need to clone the SpecimenTypeDesignation, since the SpecimenTypeDesignations are being deleted by the hibernate delete cascade
163
        newSpecimenTypeDesignation = (SpecimenTypeDesignation) specimenTypeDesignation.clone();
164
        for(Registration reg : specimenTypeDesignation.getRegistrations()){
165
            reg.removeTypeDesignation(specimenTypeDesignation);
166
            reg.addTypeDesignation(newSpecimenTypeDesignation);
167
        }
168
        for(TaxonName name : specimenTypeDesignation.getTypifiedNames()){
169
            name.addTypeDesignation(newSpecimenTypeDesignation, false);
170
            name.removeTypeDesignation(specimenTypeDesignation);
171
        }
172
        n.addSpecimenTypeDesignation(newSpecimenTypeDesignation);
147 173

  
148 174
    }
149 175

  
......
172 198
        return false;
173 199
    }
174 200

  
201
    /**
202
     * Returns the derived unit which was the source entity for the conversion.
203
     * You may want to delete this entity after the conversion if this makes sense
204
     * in the context of the actual use case. By this you can
205
     * avoid orphan derived units and type designations.
206
     */
207
    public DerivedUnit oldDerivedUnit(){
208
        return source;
209
    }
210

  
175 211
}
cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/utility/DerivedUnitConverterFactory.java
1
/**
2
* Copyright (C) 2017 EDIT
3
* European Distributed Institute of Taxonomy
4
* http://www.e-taxonomy.eu
5
*
6
* The contents of this file are subject to the Mozilla Public License Version 1.1
7
* See LICENSE.TXT at the top of this package for the full license terms.
8
*/
9
package eu.etaxonomy.cdm.api.utility;
10

  
11
import org.springframework.beans.factory.annotation.Autowired;
12

  
13
import eu.etaxonomy.cdm.api.service.IOccurrenceService;
14
import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;
15

  
16
/**
17
 * @author a.kohlbecker
18
 * @since Dec 14, 2017
19
 *
20
 */
21
public class DerivedUnitConverterFactory {
22

  
23
    private static IOccurrenceService service;
24

  
25
    @Autowired
26
    public void setIOccurrenceService(IOccurrenceService service){
27
        DerivedUnitConverterFactory.service = service;
28
    }
29

  
30
    public static <TARGET extends DerivedUnit> DerivedUnitConverter<TARGET> createDerivedUnitConverter(DerivedUnit derivedUnit, Class<TARGET> targetType){
31
        DerivedUnitConverter<TARGET> converter = new DerivedUnitConverter<TARGET>(derivedUnit, service);
32
        return converter;
33
    }
34

  
35

  
36
}
cdmlib-services/src/main/resources/eu/etaxonomy/cdm/services_base.xml
27 27
    <!-- equips a new and empty database with the initial set of meta data and admin user   -->
28 28
    <bean id="firstDataInserter" class="eu.etaxonomy.cdm.api.application.FirstDataInserter" />
29 29
    
30
    <!--  only needed as long as DerivedUnit and MediaSpecimen, ... are different classes -->
31
    <bean id="derivedUnitConverterFactory" class="eu.etaxonomy.cdm.api.utility.DerivedUnitConverterFactory" />
32 30
</beans>
cdmlib-services/src/main/resources/eu/etaxonomy/cdm/services_security_base.xml
70 70
    <bean id="firstDataInserter" class="eu.etaxonomy.cdm.api.application.FirstDataInserter">
71 71
        <property name="runAsAuthenticationProvider" ref="runAsAuthenticationProvider"/>
72 72
    </bean>
73
    
74
    <!--  only needed as long as DerivedUnit and MediaSpecimen, ... are different classes -->
75
    <bean id="derivedUnitConverterFactory" class="eu.etaxonomy.cdm.api.utility.DerivedUnitConverterFactory" />
76 73

  
77 74
</beans>
cdmlib-services/src/test/java/eu/etaxonomy/cdm/api/utility/DerivedUnitConverterIntegrationTest.java
20 20
import org.unitils.spring.annotation.SpringBeanByType;
21 21

  
22 22
import eu.etaxonomy.cdm.api.service.IOccurrenceService;
23
import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignation;
23 24
import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;
24 25
import eu.etaxonomy.cdm.model.occurrence.FieldUnit;
25 26
import eu.etaxonomy.cdm.model.occurrence.MediaSpecimen;
......
54 55

  
55 56
        DerivedUnit du = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
56 57
        du.setTitleCache("test derived unit", true);
58
        SpecimenTypeDesignation std = SpecimenTypeDesignation.NewInstance();
59
        std.setTypeSpecimen(du);
57 60
        du = (DerivedUnit) service.save(du); // intermediate save is essential for this test
58
        DerivedUnitConverter<MediaSpecimen> duc = DerivedUnitConverterFactory.createDerivedUnitConverter(du, MediaSpecimen.class);
59
        duc.convertTo(MediaSpecimen.class, SpecimenOrObservationType.StillImage);
60

  
61
        DerivedUnitConverter<MediaSpecimen> converter = new DerivedUnitConverter<MediaSpecimen>(std);
62
        SpecimenTypeDesignation newDu = converter.convertTo(MediaSpecimen.class, SpecimenOrObservationType.StillImage);
63
        assertEquals(du, converter.oldDerivedUnit());
64
        printDataSet(System.err, new String[]{"SpecimenOrObservationBase", "TypeDesignationBase"});
65
        service.saveOrUpdate(newDu.getTypeSpecimen());
66
        service.delete(du);
67
        printDataSet(System.err, new String[]{"SpecimenOrObservationBase", "TypeDesignationBase"});
61 68
        assertEquals(1, service.list(null, null, null, null, null).size());
62 69
        assertEquals(1, service.list(MediaSpecimen.class, null, null, null, null).size());
63 70
    }
......
75 82

  
76 83
        MediaSpecimen du = MediaSpecimen.NewInstance(SpecimenOrObservationType.StillImage);
77 84
        du.setTitleCache("test media specimen", true);
78
        DerivedUnitConverter<DerivedUnit> duc = DerivedUnitConverterFactory.createDerivedUnitConverter(du, DerivedUnit.class);
85
        SpecimenTypeDesignation std = SpecimenTypeDesignation.NewInstance();
86
        std.setTypeSpecimen(du);
87
        DerivedUnitConverter<DerivedUnit> duc = new DerivedUnitConverter<DerivedUnit>(std);
79 88
        du = (MediaSpecimen) service.save(du); // intermediate save is essential for this test
80 89
        duc.convertTo(DerivedUnit.class, SpecimenOrObservationType.PreservedSpecimen);
81 90

  
......
104 113
                "derivedFrom.originals.*",
105 114
                "derivedFrom.originals.derivationEvents",
106 115
                "specimenTypeDesignations.typifiedNames.typeDesignations",
116
                "specimenTypeDesignations.annotations",
117
                "specimenTypeDesignations.markers",
118
                "specimenTypeDesignations.registrations",
107 119
                //
108 120
                "derivedFrom.originals.gatheringEvent.$",
109 121
                "derivedFrom.originals.gatheringEvent.country",
110 122
                "derivedFrom.originals.gatheringEvent.collectingAreas",
111 123
                "derivedFrom.originals.gatheringEvent.actor.teamMembers",
112 124
                "derivedFrom.originals.derivationEvents.derivatives" }));
113
        DerivedUnitConverter<DerivedUnit> duc = DerivedUnitConverterFactory.createDerivedUnitConverter(du, DerivedUnit.class);
114
        DerivedUnit target = duc.convertTo(DerivedUnit.class, SpecimenOrObservationType.HumanObservation);
125
        SpecimenTypeDesignation specimenTypeDesignation = du.getSpecimenTypeDesignations().iterator().next();
126
        DerivedUnitConverter<DerivedUnit> duc = new DerivedUnitConverter<DerivedUnit>(specimenTypeDesignation);
127
        SpecimenTypeDesignation newSpecimenTypeDesignation = duc.convertTo(DerivedUnit.class, SpecimenOrObservationType.HumanObservation);
128
        DerivedUnit target = newSpecimenTypeDesignation.getTypeSpecimen();
115 129

  
116 130
        //service.save(target); // save is performed in convertTo()
117 131

  
cdmlib-services/src/test/java/eu/etaxonomy/cdm/api/utility/DerivedUnitConverterTest.java
8 8
*/
9 9
package eu.etaxonomy.cdm.api.utility;
10 10

  
11
import java.io.IOException;
12
import java.util.Collection;
13
import java.util.List;
14
import java.util.Map;
15
import java.util.Set;
16
import java.util.UUID;
17

  
18
import org.hibernate.LockOptions;
19
import org.hibernate.Session;
20
import org.hibernate.criterion.Criterion;
21
import org.hibernate.envers.query.criteria.AuditCriterion;
22
import org.hibernate.search.spatial.impl.Rectangle;
23 11
import org.junit.Assert;
24 12
import org.junit.Test;
25 13

  
26
import eu.etaxonomy.cdm.api.facade.DerivedUnitFacade;
27
import eu.etaxonomy.cdm.api.facade.DerivedUnitFacadeNotSupportedException;
28
import eu.etaxonomy.cdm.api.service.DeleteResult;
29
import eu.etaxonomy.cdm.api.service.IOccurrenceService;
30
import eu.etaxonomy.cdm.api.service.UpdateResult;
31
import eu.etaxonomy.cdm.api.service.config.DeleteConfiguratorBase;
32
import eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator;
33
import eu.etaxonomy.cdm.api.service.config.SpecimenDeleteConfigurator;
34
import eu.etaxonomy.cdm.api.service.dto.FieldUnitDTO;
35
import eu.etaxonomy.cdm.api.service.dto.IdentifiedEntityDTO;
36
import eu.etaxonomy.cdm.api.service.dto.MarkedEntityDTO;
37
import eu.etaxonomy.cdm.api.service.dto.PreservedSpecimenDTO;
38
import eu.etaxonomy.cdm.api.service.pager.Pager;
39
import eu.etaxonomy.cdm.api.service.search.LuceneParseException;
40
import eu.etaxonomy.cdm.api.service.search.SearchResult;
41
import eu.etaxonomy.cdm.api.service.util.TaxonRelationshipEdge;
42
import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;
43
import eu.etaxonomy.cdm.model.common.Annotation;
44
import eu.etaxonomy.cdm.model.common.DefinedTerm;
45
import eu.etaxonomy.cdm.model.common.ISourceable;
46
import eu.etaxonomy.cdm.model.common.IdentifiableSource;
47
import eu.etaxonomy.cdm.model.common.LSID;
48
import eu.etaxonomy.cdm.model.common.Language;
49
import eu.etaxonomy.cdm.model.common.Marker;
50
import eu.etaxonomy.cdm.model.common.MarkerType;
51
import eu.etaxonomy.cdm.model.description.DescriptionBase;
52
import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
53
import eu.etaxonomy.cdm.model.description.IndividualsAssociation;
54
import eu.etaxonomy.cdm.model.location.Country;
55
import eu.etaxonomy.cdm.model.media.Media;
56
import eu.etaxonomy.cdm.model.media.Rights;
57
import eu.etaxonomy.cdm.model.molecular.DnaSample;
58
import eu.etaxonomy.cdm.model.molecular.Sequence;
59 14
import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignation;
60
import eu.etaxonomy.cdm.model.name.TaxonName;
61
import eu.etaxonomy.cdm.model.occurrence.DerivationEvent;
62 15
import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;
63
import eu.etaxonomy.cdm.model.occurrence.DeterminationEvent;
64
import eu.etaxonomy.cdm.model.occurrence.FieldUnit;
65 16
import eu.etaxonomy.cdm.model.occurrence.MediaSpecimen;
66
import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
67 17
import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationType;
68
import eu.etaxonomy.cdm.model.taxon.Taxon;
69
import eu.etaxonomy.cdm.model.taxon.TaxonBase;
70
import eu.etaxonomy.cdm.model.view.AuditEvent;
71
import eu.etaxonomy.cdm.model.view.AuditEventRecord;
72
import eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort;
73
import eu.etaxonomy.cdm.persistence.dto.MergeResult;
74
import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
75
import eu.etaxonomy.cdm.persistence.query.Grouping;
76
import eu.etaxonomy.cdm.persistence.query.MatchMode;
77
import eu.etaxonomy.cdm.persistence.query.OrderHint;
78
import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy;
79
import eu.etaxonomy.cdm.strategy.match.IMatchStrategy;
80
import eu.etaxonomy.cdm.strategy.merge.IMergeStrategy;
81 18

  
82 19
/**
83 20
 *
......
92 29
    public void toMediaSpecimen() throws DerivedUnitConversionException {
93 30
        DerivedUnit du = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
94 31
        du.setTitleCache("test derived unit", true);
95
        DerivedUnitConverter<MediaSpecimen> duc = new DerivedUnitConverter<MediaSpecimen>(du, new OccurrenceServiceMock());
96
        MediaSpecimen target = duc.convertTo(MediaSpecimen.class, SpecimenOrObservationType.StillImage);
32
        SpecimenTypeDesignation std = SpecimenTypeDesignation.NewInstance();
33
        std.setTypeSpecimen(du);
34
        DerivedUnitConverter<MediaSpecimen> duc = new DerivedUnitConverter<MediaSpecimen>(std);
35
        SpecimenTypeDesignation newStd = duc.convertTo(MediaSpecimen.class, SpecimenOrObservationType.StillImage);
36
        assertNotEquals(std.getUuid(), newStd.getUuid());
37
        MediaSpecimen target = (MediaSpecimen) newStd.getTypeSpecimen();
97 38
        assertNotNull(target);
98 39
        assertEquals(SpecimenOrObservationType.StillImage, target.getRecordBasis());
99 40
        assertEquals("test derived unit", target.getTitleCache());
......
104 45

  
105 46
        MediaSpecimen du = MediaSpecimen.NewInstance(SpecimenOrObservationType.StillImage);
106 47
        du.setTitleCache("test media specimen", true);
107
        DerivedUnitConverter<DerivedUnit> duc = new DerivedUnitConverter<DerivedUnit>(du, new OccurrenceServiceMock());
108
        DerivedUnit target = duc.convertTo(DerivedUnit.class, SpecimenOrObservationType.PreservedSpecimen);
48
        SpecimenTypeDesignation std = SpecimenTypeDesignation.NewInstance();
49
        std.setTypeSpecimen(du);
50
        DerivedUnitConverter<DerivedUnit> duc = new DerivedUnitConverter<DerivedUnit>(std);
51
        SpecimenTypeDesignation newStd = duc.convertTo(DerivedUnit.class, SpecimenOrObservationType.PreservedSpecimen);
52
        assertNotEquals(std.getUuid(), newStd.getUuid());
53
        DerivedUnit target = newStd.getTypeSpecimen();
109 54
        assertNotNull(target);
110 55
        assertEquals(SpecimenOrObservationType.PreservedSpecimen, target.getRecordBasis());
111 56
        assertEquals("test media specimen", target.getTitleCache());
112 57
    }
113 58

  
114
    class OccurrenceServiceMock implements IOccurrenceService {
115

  
116
        /**
117
         * {@inheritDoc}
118
         */
119
        @Override
120
        public void updateTitleCache() {
121

  
122

  
123
        }
124

  
125
        /**
126
         * {@inheritDoc}
127
         */
128
        @Override
129
        public void updateTitleCache(Class<? extends SpecimenOrObservationBase> clazz, Integer stepSize,
130
                IIdentifiableEntityCacheStrategy<SpecimenOrObservationBase> cacheStrategy, IProgressMonitor monitor) {
131

  
132

  
133
        }
134

  
135
        /**
136
         * {@inheritDoc}
137
         */
138
        @Override
139
        public SpecimenOrObservationBase find(LSID lsid) {
140

  
141
            return null;
142
        }
143

  
144
        /**
145
         * {@inheritDoc}
146
         */
147
        @Override
148
        public SpecimenOrObservationBase replace(SpecimenOrObservationBase x, SpecimenOrObservationBase y) {
149

  
150
            return null;
151
        }
152

  
153
        /**
154
         * {@inheritDoc}
155
         */
156
        @Override
157
        public Pager<IdentifiableSource> getSources(SpecimenOrObservationBase t, Integer pageSize, Integer pageNumber,
158
                List<String> propertyPaths) {
159

  
160
            return null;
161
        }
162

  
163
        /**
164
         * {@inheritDoc}
165
         */
166
        @Override
167
        public Pager<Rights> getRights(SpecimenOrObservationBase t, Integer pageSize, Integer pageNumber,
168
                List<String> propertyPaths) {
169

  
170
            return null;
171
        }
172

  
173
        /**
174
         * {@inheritDoc}
175
         */
176
        @Override
177
        public String getTitleCache(UUID uuid, boolean refresh) {
178

  
179
            return null;
180
        }
181

  
182
        /**
183
         * {@inheritDoc}
184
         */
185
        @Override
186
        public Pager<SpecimenOrObservationBase> findByTitle(Class<? extends SpecimenOrObservationBase> clazz,
187
                String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber,
188
                List<OrderHint> orderHints, List<String> propertyPaths) {
189

  
190
            return null;
191
        }
192

  
193
        /**
194
         * {@inheritDoc}
195
         */
196
        @Override
197
        public Pager<SpecimenOrObservationBase> findByTitle(
198
                IIdentifiableEntityServiceConfigurator<SpecimenOrObservationBase> configurator) {
199

  
200
            return null;
201
        }
202

  
203
        /**
204
         * {@inheritDoc}
205
         */
206
        @Override
207
        public Integer countByTitle(Class<? extends SpecimenOrObservationBase> clazz, String queryString,
208
                MatchMode matchmode, List<Criterion> criteria) {
209

  
210
            return null;
211
        }
212

  
213
        /**
214
         * {@inheritDoc}
215
         */
216
        @Override
217
        public Integer countByTitle(IIdentifiableEntityServiceConfigurator<SpecimenOrObservationBase> configurator) {
218

  
219
            return null;
220
        }
221

  
222
        /**
223
         * {@inheritDoc}
224
         */
225
        @Override
226
        public List<SpecimenOrObservationBase> listByTitle(Class<? extends SpecimenOrObservationBase> clazz,
227
                String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber,
228
                List<OrderHint> orderHints, List<String> propertyPaths) {
229

  
230
            return null;
231
        }
232

  
233
        /**
234
         * {@inheritDoc}
235
         */
236
        @Override
237
        public List<SpecimenOrObservationBase> listByReferenceTitle(Class<? extends SpecimenOrObservationBase> clazz,
238
                String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber,
239
                List<OrderHint> orderHints, List<String> propertyPaths) {
240

  
241
            return null;
242
        }
243

  
244
        /**
245
         * {@inheritDoc}
246
         */
247
        @Override
248
        public int deduplicate(Class<? extends SpecimenOrObservationBase> clazz, IMatchStrategy matchStrategy,
249
                IMergeStrategy mergeStrategy) {
250

  
251
            return 0;
252
        }
253

  
254
        /**
255
         * {@inheritDoc}
256
         */
257
        @Override
258
        public Pager<SpecimenOrObservationBase> findTitleCache(Class<? extends SpecimenOrObservationBase> clazz,
259
                String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints,
260
                MatchMode matchMode) {
261

  
262
            return null;
263
        }
264

  
265
        /**
266
         * {@inheritDoc}
267
         */
268
        @Override
269
        public ISourceable getSourcedObjectByIdInSource(Class clazz, String idInSource, String idNamespace) {
270

  
271
            return null;
272
        }
273

  
274
        /**
275
         * {@inheritDoc}
276
         */
277
        @Override
278
        public <S extends SpecimenOrObservationBase> Pager<IdentifiedEntityDTO<S>> findByIdentifier(Class<S> clazz,
279
                String identifier, DefinedTerm identifierType, MatchMode matchmode, boolean includeCdmEntity,
280
                Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
281

  
282
            return null;
283
        }
284

  
285
        /**
286
         * {@inheritDoc}
287
         */
288
        @Override
289
        public <S extends SpecimenOrObservationBase> Pager<MarkedEntityDTO<S>> findByMarker(Class<S> clazz,
290
                MarkerType markerType, Boolean markerValue, boolean includeEntity, Integer pageSize, Integer pageNumber,
291
                List<String> propertyPaths) {
292

  
293
            return null;
294
        }
295

  
296
        /**
297
         * {@inheritDoc}
298
         */
299
        @Override
300
        public Pager<Annotation> getAnnotations(SpecimenOrObservationBase annotatedObj, MarkerType status,
301
                Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
302

  
303
            return null;
304
        }
305

  
306
        /**
307
         * {@inheritDoc}
308
         */
309
        @Override
310
        public Pager<Marker> getMarkers(SpecimenOrObservationBase annotatableEntity, Boolean technical,
311
                Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
312

  
313
            return null;
314
        }
315

  
316
        /**
317
         * {@inheritDoc}
318
         */
319
        @Override
320
        public List<Object[]> groupMarkers(Class<? extends SpecimenOrObservationBase> clazz, Boolean technical,
321
                Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
322

  
323
            return null;
324
        }
325

  
326
        /**
327
         * {@inheritDoc}
328
         */
329
        @Override
330
        public int countMarkers(Class<? extends SpecimenOrObservationBase> clazz, Boolean technical) {
331

  
332
            return 0;
333
        }
334

  
335
        /**
336
         * {@inheritDoc}
337
         */
338
        @Override
339
        public <S extends SpecimenOrObservationBase> List<UuidAndTitleCache<S>> getUuidAndTitleCache(Class<S> clazz,
340
                Integer limit, String pattern) {
341

  
342
            return null;
343
        }
344

  
345
        /**
346
         * {@inheritDoc}
347
         */
348
        @Override
349
        public List<UuidAndTitleCache<SpecimenOrObservationBase>> getUuidAndTitleCache(Integer limit, String pattern) {
350

  
351
            return null;
352
        }
353

  
354
        /**
355
         * {@inheritDoc}
356
         */
357
        @Override
358
        public Pager<AuditEventRecord<SpecimenOrObservationBase>> pageAuditEvents(SpecimenOrObservationBase t,
359
                Integer pageSize, Integer pageNumber, AuditEventSort sort, List<String> propertyPaths) {
360

  
361
            return null;
362
        }
363

  
364
        /**
365
         * {@inheritDoc}
366
         */
367
        @Override
368
        public AuditEventRecord<SpecimenOrObservationBase> getNextAuditEvent(SpecimenOrObservationBase t) {
369

  
370
            return null;
371
        }
372

  
373
        /**
374
         * {@inheritDoc}
375
         */
376
        @Override
377
        public AuditEventRecord<SpecimenOrObservationBase> getPreviousAuditEvent(SpecimenOrObservationBase t) {
378

  
379
            return null;
380
        }
381

  
382
        /**
383
         * {@inheritDoc}
384
         */
385
        @Override
386
        public Pager<AuditEventRecord<SpecimenOrObservationBase>> pageAuditEvents(
387
                Class<? extends SpecimenOrObservationBase> clazz, AuditEvent from, AuditEvent to,
388
                List<AuditCriterion> criteria, Integer pageSize, Integer pageValue, AuditEventSort sort,
389
                List<String> propertyPaths) {
390

  
391
            return null;
392
        }
393

  
394
        /**
395
         * {@inheritDoc}
396
         */
397
        @Override
398
        public DeleteResult isDeletable(UUID object, DeleteConfiguratorBase config) {
399

  
400
            return null;
401
        }
402

  
403
        /**
404
         * {@inheritDoc}
405
         */
406
        @Override
407
        public void clear() {
408

  
409

  
410
        }
411

  
412
        /**
413
         * {@inheritDoc}
414
         */
415
        @Override
416
        public void lock(SpecimenOrObservationBase t, LockOptions lockOptions) {
417

  
418

  
419
        }
420

  
421
        /**
422
         * {@inheritDoc}
423
         */
424
        @Override
425
        public void refresh(SpecimenOrObservationBase t, LockOptions lockOptions, List<String> propertyPaths) {
426

  
427

  
428
        }
429

  
430
        /**
431
         * {@inheritDoc}
432
         */
433
        @Override
434
        public int count(Class<? extends SpecimenOrObservationBase> clazz) {
435

  
436
            return 0;
437
        }
438

  
439
        /**
440
         * {@inheritDoc}
441
         */
442
        @Override
443
        public DeleteResult delete(UUID persistentObjectUUID) {
444

  
445
            return null;
446
        }
447

  
448
        /**
449
         * {@inheritDoc}
450
         */
451
        @Override
452
        public boolean exists(UUID uuid) {
453

  
454
            return false;
455
        }
456

  
457
        /**
458
         * {@inheritDoc}
459
         */
460
        @Override
461
        public List<SpecimenOrObservationBase> find(Set<UUID> uuidSet) {
462

  
463
            return null;
464
        }
465

  
466
        /**
467
         * {@inheritDoc}
468
         */
469
        @Override
470
        public SpecimenOrObservationBase find(UUID uuid) {
471

  
472
            return null;
473
        }
474

  
475
        /**
476
         * {@inheritDoc}
477
         */
478
        @Override
479
        public SpecimenOrObservationBase findWithoutFlush(UUID uuid) {
480

  
481
            return null;
482
        }
483

  
484
        /**
485
         * {@inheritDoc}
486
         */
487
        @Override
488
        public SpecimenOrObservationBase find(int id) {
489

  
490
            return null;
491
        }
492

  
493
        /**
494
         * {@inheritDoc}
495
         */
496
        @Override
497
        public List<SpecimenOrObservationBase> findById(Set<Integer> idSet) {
498

  
499
            return null;
500
        }
501

  
502
        /**
503
         * {@inheritDoc}
504
         */
505
        @Override
506
        public Session getSession() {
507

  
508
            return null;
509
        }
510

  
511
        /**
512
         * {@inheritDoc}
513
         */
514
        @Override
515
        public List<Object[]> group(Class<? extends SpecimenOrObservationBase> clazz, Integer limit, Integer start,
516
                List<Grouping> groups, List<String> propertyPaths) {
517

  
518
            return null;
519
        }
520

  
521
        /**
522
         * {@inheritDoc}
523
         */
524
        @Override
525
        public <S extends SpecimenOrObservationBase> List<S> list(Class<S> type, Integer limit, Integer start,
526
                List<OrderHint> orderHints, List<String> propertyPaths) {
527

  
528
            return null;
529
        }
530

  
531
        /**
532
         * {@inheritDoc}
533
         */
534
        @Override
535
        public SpecimenOrObservationBase load(UUID uuid) {
536

  
537
            return null;
538
        }
539

  
540
        /**
541
         * {@inheritDoc}
542
         */
543
        @Override
544
        public SpecimenOrObservationBase load(int id, List<String> propertyPaths) {
545

  
546
            return null;
547
        }
548

  
549
        /**
550
         * {@inheritDoc}
551
         */
552
        @Override
553
        public SpecimenOrObservationBase load(UUID uuid, List<String> propertyPaths) {
554

  
555
            return null;
556
        }
557

  
558
        /**
559
         * {@inheritDoc}
560
         */
561
        @Override
562
        public List<SpecimenOrObservationBase> load(List<UUID> uuids, List<String> propertyPaths) {
563

  
564
            return null;
565
        }
566

  
567
        /**
568
         * {@inheritDoc}
569
         */
570
        @Override
571
        public SpecimenOrObservationBase merge(SpecimenOrObservationBase transientObject) {
572

  
573
            return null;
574
        }
575

  
576
        /**
577
         * {@inheritDoc}
578
         */
579
        @Override
580
        public <S extends SpecimenOrObservationBase> Pager<S> page(Class<S> type, Integer pageSize, Integer pageNumber,
581
                List<OrderHint> orderHints, List<String> propertyPaths) {
582

  
583
            return null;
584
        }
585

  
586
        /**
587
         * {@inheritDoc}
588
         */
589
        @Override
590
        public UUID refresh(SpecimenOrObservationBase persistentObject) {
591

  
592
            return null;
593
        }
594

  
595
        /**
596
         * {@inheritDoc}
597
         */
598
        @Override
599
        public List<SpecimenOrObservationBase> rows(String tableName, int limit, int start) {
600

  
601
            return null;
602
        }
603

  
604
        /**
605
         * {@inheritDoc}
606
         */
607
        @Override
608
        public Map<UUID, SpecimenOrObservationBase> save(Collection<SpecimenOrObservationBase> newInstances) {
609

  
610
            return null;
611
        }
612

  
613
        /**
614
         * {@inheritDoc}
615
         */
616
        @Override
617
        public SpecimenOrObservationBase save(SpecimenOrObservationBase newInstance) {
618

  
619
            return null;
620
        }
621

  
622
        /**
623
         * {@inheritDoc}
624
         */
625
        @Override
626
        public UUID saveOrUpdate(SpecimenOrObservationBase transientObject) {
627

  
628
            return null;
629
        }
630

  
631
        /**
632
         * {@inheritDoc}
633
         */
634
        @Override
635
        public Map<UUID, SpecimenOrObservationBase> saveOrUpdate(
636
                Collection<SpecimenOrObservationBase> transientObjects) {
637

  
638
            return null;
639
        }
640

  
641
        /**
642
         * {@inheritDoc}
643
         */
644
        @Override
645
        public UUID update(SpecimenOrObservationBase transientObject) {
646

  
647
            return null;
648
        }
649

  
650
        /**
651
         * {@inheritDoc}
652
         */
653
        @Override
654
        public SpecimenOrObservationBase loadWithUpdate(UUID uuid) {
655

  
656
            return null;
657
        }
658

  
659
        /**
660
         * {@inheritDoc}
661
         */
662
        @Override
663
        public List<SpecimenOrObservationBase> list(SpecimenOrObservationBase example, Set<String> includeProperties,
664
                Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
665

  
666
            return null;
667
        }
668

  
669
        /**
670
         * {@inheritDoc}
671
         */
672
        @Override
673
        public DeleteResult delete(SpecimenOrObservationBase persistentObject) {
674

  
675
            return null;
676
        }
677

  
678
        /**
679
         * {@inheritDoc}
680
         */
681
        @Override
682
        public DeleteResult delete(Collection<UUID> persistentObjectUUIDs) {
683

  
684
            return null;
685
        }
686

  
687
        /**
688
         * {@inheritDoc}
689
         */
690
        @Override
691
        public List<SpecimenOrObservationBase> merge(List<SpecimenOrObservationBase> detachedObjects) {
692

  
693
            return null;
694
        }
695

  
696
        /**
697
         * {@inheritDoc}
698
         */
699
        @Override
700
        public List<SpecimenOrObservationBase> loadByIds(List<Integer> idSet, List<String> propertyPaths) {
701

  
702
            return null;
703
        }
704

  
705
        /**
706
         * {@inheritDoc}
707
         */
708
        @Override
709
        public List<MergeResult<SpecimenOrObservationBase>> merge(List<SpecimenOrObservationBase> detachedObjects,
710
                boolean returnTransientEntity) {
711

  
712
            return null;
713
        }
714

  
715
        /**
716
         * {@inheritDoc}
717
         */
718
        @Override
719
        public MergeResult<SpecimenOrObservationBase> merge(SpecimenOrObservationBase newInstance,
720
                boolean returnTransientEntity) {
721

  
722
            return null;
723
        }
724

  
725
        /**
726
         * {@inheritDoc}
727
         */
728
        @Override
729
        public Country getCountryByIso(String iso639) {
730

  
731
            return null;
732
        }
733

  
734
        /**
735
         * {@inheritDoc}
736
         */
737
        @Override
738
        public List<Country> getCountryByName(String name) {
739

  
740
            return null;
741
        }
742

  
743
        /**
744
         * {@inheritDoc}
745
         */
746
        @Override
747
        public Pager<SpecimenOrObservationBase> list(Class<? extends SpecimenOrObservationBase> type,
748
                TaxonBase determinedAs, Integer limit, Integer start, List<OrderHint> orderHints,
749
                List<String> propertyPaths) {
750

  
751
            return null;
752
        }
753

  
754
        /**
755
         * {@inheritDoc}
756
         */
757
        @Override
758
        public Pager<SpecimenOrObservationBase> list(Class<? extends SpecimenOrObservationBase> type,
759
                TaxonName determinedAs, Integer limit, Integer start, List<OrderHint> orderHints,
760
                List<String> propertyPaths) {
761

  
762
            return null;
763
        }
764

  
765
        /**
766
         * {@inheritDoc}
767
         */
768
        @Override
769
        public Pager<Media> getMedia(SpecimenOrObservationBase occurence, Integer pageSize, Integer pageNumber,
770
                List<String> propertyPaths) {
771

  
772
            return null;
773
        }
774

  
775
        /**
776
         * {@inheritDoc}
777
         */
778
        @Override
779
        public Pager<Media> getMediainHierarchy(SpecimenOrObservationBase rootOccurence, Integer pageSize,
780
                Integer pageNumber, List<String> propertyPaths) {
781

  
782
            return null;
783
        }
784

  
785
        /**
786
         * {@inheritDoc}
787
         */
788
        @Override
789
        public int countDeterminations(SpecimenOrObservationBase occurence, TaxonBase taxonbase) {
790

  
791
            return 0;
792
        }
793

  
794
        /**
795
         * {@inheritDoc}
796
         */
797
        @Override
798
        public Pager<DeterminationEvent> getDeterminations(SpecimenOrObservationBase occurence, TaxonBase taxonBase,
799
                Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
800

  
801
            return null;
802
        }
803

  
804
        /**
805
         * {@inheritDoc}
806
         */
807
        @Override
808
        public Pager<DerivationEvent> getDerivationEvents(SpecimenOrObservationBase occurence, Integer pageSize,
809
                Integer pageNumber, List<String> propertyPaths) {
810

  
811
            return null;
812
        }
813

  
814
        /**
815
         * {@inheritDoc}
816
         */
817
        @Override
818
        public Pager<SpecimenOrObservationBase> search(Class<? extends SpecimenOrObservationBase> clazz, String query,
819
                Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
820

  
821
            return null;
822
        }
823

  
824
        /**
825
         * {@inheritDoc}
826
         */
827
        @Override
828
        public List<UuidAndTitleCache<FieldUnit>> getFieldUnitUuidAndTitleCache() {
829

  
830
            return null;
831
        }
832

  
833
        /**
834
         * {@inheritDoc}
835
         */
836
        @Override
837
        public List<UuidAndTitleCache<DerivedUnit>> getDerivedUnitUuidAndTitleCache(Integer limit, String pattern) {
838

  
839
            return null;
840
        }
841

  
842
        /**
843
         * {@inheritDoc}
844
         */
845
        @Override
846
        public DerivedUnitFacade getDerivedUnitFacade(DerivedUnit derivedUnit, List<String> propertyPaths)
847
                throws DerivedUnitFacadeNotSupportedException {
848

  
849
            return null;
850
        }
851

  
852
        /**
853
         * {@inheritDoc}
854
         */
855
        @Override
856
        public List<DerivedUnitFacade> listDerivedUnitFacades(DescriptionBase description, List<String> propertyPaths) {
857

  
858
            return null;
859
        }
860

  
861
        /**
862
         * {@inheritDoc}
863
         */
864
        @Override
865
        public <T extends SpecimenOrObservationBase> List<T> listByAssociatedTaxon(Class<T> type,
866
                Set<TaxonRelationshipEdge> includeRelationships, Taxon associatedTaxon, Integer maxDepth,
867
                Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
868

  
869
            return null;
870
        }
871

  
872
        /**
873
         * {@inheritDoc}
874
         */
875
        @Override
876
        public Collection<SpecimenOrObservationBase> listFieldUnitsByAssociatedTaxon(Taxon associatedTaxon,
877
                List<OrderHint> orderHints, List<String> propertyPaths) {
878

  
879
            return null;
880
        }
881

  
882
        /**
883
         * {@inheritDoc}
884
         */
885
        @Override
886
        public Pager<SpecimenOrObservationBase> pageFieldUnitsByAssociatedTaxon(
887
                Set<TaxonRelationshipEdge> includeRelationships, Taxon associatedTaxon, Integer maxDepth,
888
                Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
889

  
890
            return null;
891
        }
892

  
893
        /**
894
         * {@inheritDoc}
895
         */
896
        @Override
897
        public <T extends SpecimenOrObservationBase> Pager<T> pageByAssociatedTaxon(Class<T> type,
898
                Set<TaxonRelationshipEdge> includeRelationships, Taxon associatedTaxon, Integer maxDepth,
899
                Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
900

  
901
            return null;
902
        }
903

  
904
        /**
905
         * {@inheritDoc}
906
         */
907
        @Override
908
        public Collection<FieldUnit> getFieldUnits(UUID specimenUuid, List<String> propertyPaths) {
909

  
910
            return null;
911
        }
912

  
913
        /**
914
         * {@inheritDoc}
915
         */
916
        @Override
917
        public Pager<SearchResult<SpecimenOrObservationBase>> findByFullText(
918
                Class<? extends SpecimenOrObservationBase> clazz, String queryString, Rectangle boundingBox,
919
                List<Language> languages, boolean highlightFragments, Integer pageSize, Integer pageNumber,
920
                List<OrderHint> orderHints, List<String> propertyPaths) throws IOException, LuceneParseException {
921

  
922
            return null;
923
        }
924

  
925
        /**
926
         * {@inheritDoc}
927
         */
928
        @Override
929
        public <T extends SpecimenOrObservationBase> Pager<T> pageByAssociatedTaxon(Class<T> type,
930
                Set<TaxonRelationshipEdge> includeRelationships, String taxonUUID, Integer maxDepth, Integer pageSize,
931
                Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
932

  
933
            return null;
934
        }
935

  
936
        /**
937
         * {@inheritDoc}
938
         */
939
        @Override
940
        public UpdateResult moveSequence(DnaSample from, DnaSample to, Sequence sequence) {
941

  
942
            return null;
943
        }
944

  
945
        /**
946
         * {@inheritDoc}
947
         */
948
        @Override
949
        public UpdateResult moveSequence(UUID fromUuid, UUID toUuid, UUID sequenceUuid) {
950

  
951
            return null;
952
        }
953

  
954
        /**
955
         * {@inheritDoc}
956
         */
957
        @Override
958
        public UpdateResult moveDerivate(UUID specimenFromUuid, UUID specimenToUuid, UUID derivateUuid) {
959

  
960
            return null;
961
        }
962

  
963
        /**
964
         * {@inheritDoc}
965
         */
966
        @Override
967
        public boolean moveDerivate(SpecimenOrObservationBase<?> from, SpecimenOrObservationBase<?> to,
968
                DerivedUnit derivate) {
969

  
970
            return false;
971
        }
972

  
973
        /**
974
         * {@inheritDoc}
975
         */
976
        @Override
977
        public FieldUnitDTO assembleFieldUnitDTO(FieldUnit fieldUnit, UUID associatedTaxonUuid) {
978

  
979
            return null;
980
        }
981

  
982
        /**
983
         * {@inheritDoc}
984
         */
985
        @Override
986
        public PreservedSpecimenDTO assemblePreservedSpecimenDTO(DerivedUnit derivedUnit) {
987

  
988
            return null;
989
        }
990

  
991
        /**
992
         * {@inheritDoc}
993
         */
994
        @Override
995
        public DeleteResult delete(SpecimenOrObservationBase<?> specimen, SpecimenDeleteConfigurator config) {
996

  
997
            return null;
998
        }
999

  
1000
        /**
1001
         * {@inheritDoc}
1002
         */
1003
        @Override
1004
        public DeleteResult delete(UUID specimenUuid, SpecimenDeleteConfigurator config) {
1005

  
1006
            return null;
1007
        }
1008

  
1009
        /**
1010
         * {@inheritDoc}
1011
         */
1012
        @Override
1013
        public Collection<IndividualsAssociation> listIndividualsAssociations(SpecimenOrObservationBase<?> specimen,
1014
                Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
1015

  
1016
            return null;
1017
        }
1018

  
1019
        /**
1020
         * {@inheritDoc}
1021
         */
1022
        @Override
1023
        public Collection<TaxonBase<?>> listIndividualsAssociationTaxa(SpecimenOrObservationBase<?> specimen,
1024
                Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
1025

  
1026
            return null;
1027
        }
1028

  
1029
        /**
1030
         * {@inheritDoc}
1031
         */
1032
        @Override
1033
        public Collection<TaxonBase<?>> listAssociatedTaxa(SpecimenOrObservationBase<?> specimen, Integer limit,
1034
                Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
1035
            return null;
1036
        }
1037

  
1038
        /**
1039
         * {@inheritDoc}
1040
         */
1041
        @Override
1042
        public Collection<TaxonBase<?>> listDeterminedTaxa(SpecimenOrObservationBase<?> specimen, Integer limit,
1043
                Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
1044

  
1045
            return null;
1046
        }
1047

  
1048
        /**
1049
         * {@inheritDoc}
1050
         */
1051
        @Override
1052
        public Collection<DeterminationEvent> listDeterminationEvents(SpecimenOrObservationBase<?> specimen,
1053
                Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
1054
            return null;
1055
        }
1056

  
1057
        /**
1058
         * {@inheritDoc}
1059
         */
1060
        @Override
1061
        public Collection<TaxonBase<?>> listTypeDesignationTaxa(DerivedUnit specimen, Integer limit, Integer start,
1062
                List<OrderHint> orderHints, List<String> propertyPaths) {
1063

  
1064
            return null;
1065
        }
1066

  
1067
        /**
1068
         * {@inheritDoc}
1069
         */
1070
        @Override
1071
        public Map<DerivedUnit, Collection<SpecimenTypeDesignation>> listTypeDesignations(
1072
                Collection<DerivedUnit> specimens, Integer limit, Integer start, List<OrderHint> orderHints,
1073
                List<String> propertyPaths) {
1074
            return null;
1075
        }
1076

  
1077
        /**
1078
         * {@inheritDoc}
1079
         */
1080
        @Override
1081
        public Collection<SpecimenTypeDesignation> listTypeDesignations(DerivedUnit specimen, Integer limit,
1082
                Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
1083
            return null;
1084
        }
1085

  
1086
        /**
1087
         * {@inheritDoc}
1088
         */
1089
        @Override
1090
        public Collection<DescriptionBase<?>> listDescriptionsWithDescriptionSpecimen(
1091
                SpecimenOrObservationBase<?> specimen, Integer limit, Integer start, List<OrderHint> orderHints,
1092
                List<String> propertyPaths) {
1093

  
1094
            return null;
1095
        }
1096

  
1097
        /**
1098
         * {@inheritDoc}
1099
         */
1100
        @Override
1101
        public Collection<DescriptionElementBase> getCharacterDataForSpecimen(SpecimenOrObservationBase<?> specimen) {
1102

  
1103
            return null;
1104
        }
1105

  
1106
        /**
1107
         * {@inheritDoc}
1108
         */
1109
        @Override
1110
        public Collection<DescriptionElementBase> getCharacterDataForSpecimen(UUID specimenUuid) {
1111
            return null;
1112
        }
1113

  
1114
        /**
1115
         * {@inheritDoc}
1116
         */
1117
        @Override
1118
        public String getMostSignificantIdentifier(DerivedUnit derivedUnit) {
1119
            return null;
1120
        }
1121

  
1122
        /**
1123
         * {@inheritDoc}
1124
         */
1125
        @Override
1126
        public int countOccurrences(IIdentifiableEntityServiceConfigurator<SpecimenOrObservationBase> config) {
1127
            return 0;
1128
        }
1129

  
1130
        /**
1131
         * {@inheritDoc}
1132
         */
1133
        @Override
1134
        public List<SpecimenOrObservationBase<?>> getAllHierarchyDerivatives(SpecimenOrObservationBase<?> specimen) {
1135
            return null;
1136
        }
1137

  
1138
        /**
1139
         * {@inheritDoc}
1140
         */
1141
        @Override
1142
        public List<DerivedUnit> getAllChildDerivatives(SpecimenOrObservationBase<?> specimen) {
1143
            return null;
1144
        }
1145

  
1146
        /**
1147
         * {@inheritDoc}
1148
         */
1149
        @Override
1150
        public List<DerivedUnit> getAllChildDerivatives(UUID specimenUuid) {
1151
            return null;
1152
        }
1153

  
1154
        /**
1155
         * {@inheritDoc}
1156
         */
1157
        @Override
1158
        public <S extends SpecimenOrObservationBase> List<IdentifiedEntityDTO<S>> listByIdentifier(Class<S> clazz,
1159
                String identifier, DefinedTerm identifierType, MatchMode matchmode, boolean includeEntity,
1160
                List<String> propertyPaths, Integer limit) {
1161
            // TODO Auto-generated method stub
1162
            return null;
1163
        }
1164

  
1165
        /**
1166
         * {@inheritDoc}
1167
         */
1168
        @Override
1169
        public List<FieldUnit> getFieldUnitsForGatheringEvent(UUID gatheringEventUuid) {
1170
            return null;
1171
        }
1172

  
1173
    }
1174

  
1175

  
1176 59
}
cdmlib-test/src/main/resources/eu/etaxonomy/cdm/services_base_test.xml
53 53
        </property>
54 54
    </bean>
55 55
    
56
    <!--  only needed as long as DerivedUnit and MediaSpecimen, ... are different classes -->
57
    <bean id="derivedUnitConverterFactory" class="eu.etaxonomy.cdm.api.utility.DerivedUnitConverterFactory" />
58 56
</beans>

Also available in: Unified diff

Add picture from clipboard (Maximum size: 40 MB)