/ - Diff - EDIT - EDIT Project Management

     /**
      * @author cmathew
      * @date 18 Jun 2015
+     *
      */
     public class CdmApplicationException extends Exception {
         private static final long serialVersionUID = -7968634498906096739L;
         public CdmApplicationException(Exception ex) {
             super(ex);
+        }

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/cdm/api/application/CdmApplicationRemoteConfiguration.java
437	437	return (IDescriptiveDataSetService) getService(IDescriptiveDataSetService.class, "/remoting/descriptivedataset.service", new AuthenticatingHttpInvokerRequestExecutor());
438	438	}
439	439
440		/**
441		* {@inheritDoc}
442		*/
443	440	@Override
444	441	public IRegistrationService getRegistrationService() {
445	442	return (IRegistrationService) getService(IRegistrationService.class, "/remoting/registration.service", new AuthenticatingHttpInvokerRequestExecutor());
446
447	443	}
448	444
449	445	@Override
...	...
456	452	return (IPreferenceService) getService(IPreferenceService.class, "/remoting/preference.service", new AuthenticatingHttpInvokerRequestExecutor());
457	453	}
458	454
459
460	455	@Override
461	456	public IEntityValidationService getEntityValidationService(){
462	457	return (IEntityValidationService) getService(IEntityValidationService.class, "/remoting/entityvalidation.service", new AuthenticatingHttpInvokerRequestExecutor());
463	458	}
464	459
465
466	460	@Override
467	461	public IEntityConstraintViolationService getEntityConstraintViolationService(){
468	462	return (IEntityConstraintViolationService) getService(IEntityConstraintViolationService.class, "/remoting/entityconstraintviolation.service", new AuthenticatingHttpInvokerRequestExecutor());
...	...
488	482	return cdmPermissionEvaluator;
489	483	}
490	484
491
492	485	@Override
493	486	public TransactionStatus startTransaction() throws UnsupportedOperationException {
494	487	throw new UnsupportedOperationException("startTransaction is not implemented for CdmApplicationRemoteConfiguration");
...	...
499	492	throw new UnsupportedOperationException("startTransaction is not implemented for CdmApplicationRemoteConfiguration");
500	493	}
501	494
502
503	495	@Override
504	496	public void commitTransaction(TransactionStatus txStatus) throws UnsupportedOperationException {
505	497	throw new UnsupportedOperationException("commitTransaction is not implemented for CdmApplicationRemoteConfiguration");
...	...
530	522	public ITestService getTestService() {
531	523	return (ITestService) getService(ITestService.class, "/remoting/test.service", new AuthenticatingHttpInvokerRequestExecutor());
532	524	}
533
534	525	}

         private static final Logger logger = Logger.getLogger(CdmApplicationRemoteController.class);
         public static final Resource DEFAULT_REMOTE_APPLICATION_CONTEXT_RESOURCE =
                 new ClassPathResource("/eu/etaxonomy/cdm/remotingApplicationContext.xml");
         private final Resource applicationContextResource;
         private final IProgressMonitor progressMonitor;
         private final ICdmRemoteSource remoteSource;
         /**
          * Creates new instance of CdmApplicationRemoteController
+         *
          * @param applicationContextResource
          * @param remoteSource
          * @param omitTermLoading
          * @param progressMonitor
          * @param listeners
          * @return
          */
     //    public static CdmApplicationRemoteController NewInstance(Resource applicationContextResource,
     //            ICdmRemoteSource remoteSource,
     //            IProgressMonitor progressMonitor,
-...
     //                listeners);
     //
     //    }
         /**
          * Creates new instance of CdmApplicationRemoteController
+         *
-...
                     validateXml,
                     progressMonitor,
                     listeners);
+        }
         /**
-...
+        }
         /**
          * Creates and starts a new spring application context
+         *
-...
             return ((CdmApplicationRemoteConfiguration)configuration).getIOService();
+        }
         public ITestService getTestService(){
             return ((CdmApplicationRemoteConfiguration)configuration).getTestService();
+        }

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/cdm/api/application/CdmApplicationState.java
42	42	/**
43	43	* @author cmathew
44	44	* @date 17 Jun 2015
45		*
46	45	*/
47	46	public class CdmApplicationState {
48	47
...	...
111	110	getInstance().setDataChangeService(dataChangeService);
112	111	}
113	112
114
115
116	113	/**
117	114	* @return the securityContext
118	115	*/
...	...
151	148	cdmlibLastModified = null;
152	149	}
153	150
154
155	151	/**
156	152	* Generic method that will scan the getters of {@link ICdmRepository} for the given service
157	153	* interface. If a matching getter is found the according service implementation is returned by
...	...
185	181	}
186	182	}
187	183	}
188
189	184	return service;
190	185	}
191	186
192
193	187	/**
194	188	* @see #getService(Class)
195	189	* As ICommonService is not extending IService we need a specific request here
...	...
198	192	ICdmRepository configuration = getCurrentAppConfig();
199	193
200	194	return configuration.getCommonService();
201
202	195	}
203	196
204	197	public static IIOService getIOService() {
205	198	ICdmRepository configuration = getCurrentAppConfig();
206	199
207	200	return ((CdmApplicationRemoteController)configuration).getIOService();
208
209	201	}
210	202
211	203	public static ILongRunningTasksService getLongRunningTasksService() {
212	204	ICdmRepository configuration = getCurrentAppConfig();
213	205
214	206	return ((CdmApplicationRemoteController)configuration).getLongRunningTasksService();
215
216	207	}
217	208
218	209
...	...
221	212	ICdmRepository configuration = getCurrentAppConfig();
222	213
223	214	return ((CdmApplicationRemoteController)configuration).getTestService();
224
225	215	}
226	216
227	217	public static ICachedCommonService getCachedCommonService() {
228	218	ICdmRepository configuration = getCurrentAppConfig();
229	219
230	220	return ((CdmApplicationRemoteController)configuration).getCachedCommonService();
231
232	221	}
233	222
234	223	public static CdmServiceCacher getCdmServiceCacher() {

     /**
      * @author cmathew
      * @date 7 Apr 2015
+     *
      */
     public class CdmChangeEvent {
-...
         private final Action action;
         private final Set<CdmBase> changedObjects;
         private final Class sourceType;
         private Class entityType;
         private final Class<?> sourceType;
         private Class<?> entityType;
         private Object source;
         public CdmChangeEvent(Action action, Set<CdmBase> changedObjects, Class sourceType) {
         public CdmChangeEvent(Action action, Set<CdmBase> changedObjects, Class<?> sourceType) {
             this.action = action;
             this.changedObjects = changedObjects;
             this.sourceType = sourceType;
+        }
         public CdmChangeEvent(Action action, CdmBase changedObject, Class sourceType) {
         public CdmChangeEvent(Action action, CdmBase changedObject, Class<?> sourceType) {
             this.action = action;
             changedObjects = new HashSet<CdmBase>();
             changedObjects.add(changedObject);
-...
             this.source = source;
+        }
         /**
          * @return the action
          */
         public Action getAction() {
             return action;
+        }
         /**
          * @return the changedObjects
          */
         public Set<? extends CdmBase> getChangedObjects() {
             return changedObjects;
+        }
         /**
          * @return the sourceType
          */
         public Class getSourceType() {
         public Class<?> getSourceType() {
             return sourceType;
+        }
         /**
          * @return the source
          */
         public Object getSource() {
             return source;
+        }
         public Class getEntityType() {
         public Class<?> getEntityType() {
             return entityType;
+        }
         public boolean hasChanges() {
             return changedObjects != null && !changedObjects.isEmpty();
+        }
+    }

     /**
      * @author cmathew
      * @date 18 Jun 2015
+     *
      */
     public class CdmDataChangeService implements ICdmDataChangeService {
-...
             currentEvents = new ArrayList<CdmChangeEvent>();
+        }
         /* (non-Javadoc)
          * @see eu.etaxonomy.taxeditor.store.ICdmDataChangeService#register(eu.etaxonomy.cdm.api.application.ICdmChangeListener)
          */
         @Override
         public void register(ICdmChangeListener listener) {
             listeners.add(listener);
+        }
         /* (non-Javadoc)
          * @see eu.etaxonomy.cdm.api.application.ICdmDataChangeService#unregister(eu.etaxonomy.cdm.api.application.ICdmChangeListener)
          */
         @Override
         public void unregister(ICdmChangeListener listener) {
             listeners.remove(listener);
+        }
         /* (non-Javadoc)
          * @see eu.etaxonomy.taxeditor.store.ICdmDataChangeService#addEvent(eu.etaxonomy.cdm.api.application.CdmChangeEvent)
          */
         @Override
         public void addEvent(CdmChangeEvent event) {
             currentEvents.add(event);
+        }
         /* (non-Javadoc)
          * @see eu.etaxonomy.taxeditor.store.ICdmDataChangeService#fireCurrentChangeEvents(boolean)
          */
         @Override
         public void fireCurrentChangeEvents(boolean async) {
             try {
-...
+            }
+        }
         /* (non-Javadoc)
          * @see eu.etaxonomy.taxeditor.store.ICdmDataChangeService#fireChangeEvent(eu.etaxonomy.cdm.api.application.CdmChangeEvent, boolean)
          */
         @Override
         public void fireChangeEvent(final CdmChangeEvent event, boolean async) {
-...
+            }
+        }
         /* (non-Javadoc)
          * @see eu.etaxonomy.taxeditor.store.ICdmDataChangeService#clear()
          */
         @Override
         public void clear() {
             listeners.clear();
             currentEvents.clear();
+        }
+    }

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/cdm/api/application/ICdmChangeListener.java
11	11	/**
12	12	* @author cmathew
13	13	* @date 7 Apr 2015
14		*
15	14	*/
16	15	public interface ICdmChangeListener {
17	16

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/cdm/api/application/ICdmDataChangeService.java
12	12	/**
13	13	* @author cmathew
14	14	* @date 18 Jun 2015
15		*
16	15	*/
17	16	public interface ICdmDataChangeService {
18	17

     @Component //FIXME This indicates that the CdmServiceCacher is initialized as Spring Component but it seems only to be instantiated directly
     public class CdmServiceCacher extends CdmCacher implements ICdmEntitySessionManagerObserver {
         private ICdmEntitySessionManager cdmEntitySessionManager;
         private CdmTransientEntityCacher cdmTransientEntityCacher;
-...
             cacheConfig.setDiskStoreConfiguration(diskStoreConfiguration);
             addCacheManager(cacheConfig.cacheManager());
+        }
         @Override
         protected CacheConfiguration getDefaultCacheConfiguration() {
             // For a better understanding on how to size caches, refer to
-...
             	.statistics(true)
             	.sizeOfPolicy(sizeOfConfig)
             	.overflowToOffHeap(false);
+        }
         @Override
-...
             return false;
+        }
         public void setCdmEntitySessionManager(ICdmEntitySessionManager cdmEntitySessionManager) {
             this.cdmEntitySessionManager = cdmEntitySessionManager;
             if(cdmEntitySessionManager != null) {
-...
+            }
+        }
         public CdmTransientEntityCacher getCurrentCacher() {
             ICdmEntitySession cdmEntitySession = cdmEntitySessionManager.getActiveSession();
             if(cdmEntitySession != null && cdmEntitySession instanceof CdmEntitySession) {
-...
             if(!isCachable(cdmBase) && cdmTransientEntityCacher != null) {
                 CdmEntityCacheKey<T> key = CdmTransientEntityCacher.generateKey(cdmBase);
                 cachedCdmEntity = cdmTransientEntityCacher.getFromCache(key);
+            }
             if(cachedCdmEntity == null) {
                 cachedCdmEntity = super.getFromCache(cdmBase);

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/cdm/api/lazyloading/CdmLazyLoader.java
35	35	@Configurable(autowire = Autowire.BY_TYPE)
36	36	public class CdmLazyLoader {
37	37
38
39		private final Set classes = new HashSet();
	38	private final Set classes = new HashSet<>();
40	39
41	40	public static boolean enableWeaving = true;
42		private static Set<String> classesToIgnore = new HashSet<String>();
	41	private static Set<String> classesToIgnore = new HashSet<>();
43	42
44	43
45	44	@Autowired
...	...
48	47	public CdmLazyLoader() {
49	48	//classesToIgnore.add("eu.etaxonomy.cdm.model.term.TermVocabulary");
50	49	//classesToIgnore.add("eu.etaxonomy.cdm.model.term.OrderedTermVocabulary");
51
52	50	}
53	51
54	52	/**
55	53	* Point cut for the 'initialize' method of the AbstractLazyInitializer.
56		*
57	54	*/
58	55	@Pointcut("execution(* org.hibernate.proxy.AbstractLazyInitializer.initialize())")
59	56	public void possibleEntityLazyInitializationException() {
60	57	}
61	58
62
63	59	/**
64	60	* 'Around' advice for the initialization of CDM Entity Objects
65	61	*
...	...
83	79
84	80	/**
85	81	* Point cut for the 'initialize' method of the AbstractPersistentCollection.
86		*
87	82	*/
88	83	@Pointcut("execution(protected final void org.hibernate.collection.internal.AbstractPersistentCollection.initialize(..))")
89	84	public void possibleCollectionLazyInitializationException() {
...	...
128	123	}
129	124	}
130	125	return pjp.proceed();
131
132	126	}
133	127
134	128	private CollectionField getCollectionField(PersistentCollection pc) {
...	...
183	177	return this.fieldName;
184	178	}
185	179	}
186
187	180	}

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/taxeditor/remoting/CdmEagerLoadingException.java
1	1	package eu.etaxonomy.taxeditor.remoting;
2	2
3	3	public class CdmEagerLoadingException extends RuntimeException {
4
5		public CdmEagerLoadingException(Throwable t) {
	4
	5	private static final long serialVersionUID = -3994961114337636890L;
	6
	7	public CdmEagerLoadingException(Throwable t) {
6	8	super(t);
7	9	}
8
	10
9	11	public CdmEagerLoadingException(String message) {
10	12	super(message);
11	13	}
12
13	14	}

     public class CdmRemotingException extends RuntimeException {
     	/**
+    	 *
     	 */
     	private static final long serialVersionUID = -560332689478356360L;
     	public CdmRemotingException(String message) {
-...
     	public CdmRemotingException(Exception exception) {
     	    super(exception);
+    	}
+    }

     /**
      * @author a.kohlbecker
      * @since Jan 17, 2020
+     *
      */
     public class RemoteExecutionTimestampsUtil {
-...
         static public void setLastServiceMethod(String lastMethod) {
             lastServiceMethod = lastMethod;
+        }
+    }

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/taxeditor/remoting/cache/ConversationalTransientEntityCacher.java
22	22	/**
23	23	* @author k.luther
24	24	* @date 15.03.2018
25		*
26	25	*/
27	26	public class ConversationalTransientEntityCacher extends CdmTransientEntityCacher {
28	27
29		/**
30		* @param sessionOwner
31		*/
32	28	public ConversationalTransientEntityCacher(Object sessionOwner) {
33	29	super(sessionOwner);
34
35	30	}
36	31	private CdmBase load(CdmEntityIdentifier cei, boolean update) {
37	32	return CdmApplicationState.getCommonService().findWithUpdate(cei.getCdmClass(), cei.getId());
38	33	}
39	34
40
41	35	public UpdateResult load(UpdateResult result, boolean update) {
42	36	// probably a good time to broadcast to other sessions
43	37
...	...
65	59	if(exists(new CdmEntityCacheKey<>(cei.getCdmClass(), cei.getId()))) {
66	60	reloadedObjects.add(load(cei, update));
67	61	}
68
69	62	}
70	63	updatedObjects.clear();
71	64	result.addUpdatedObjects(reloadedObjects);
72	65	return result;
73	66	}
74
75	67	}

     /**
      * @author cmathew
      * @date 23 Sep 2014
+     *
      */
     public class CDMServerException extends Exception {
         private static final long serialVersionUID = -7024801695206657419L;
         public CDMServerException(String message) {
             super(message);
+        }
-...
         public CDMServerException(String message,Exception e) {
             super(message,e);
+        }
+    }

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/taxeditor/remoting/server/CDMServerUtils.java
21	21	/**
22	22	* @author cmathew
23	23	* @date 11 Nov 2015
24		*
25	24	*/
26	25	public class CDMServerUtils {
27	26
28
29	27	public static String convertEditorToServerConfig() {
30	28	StringBuilder configStringBuilder = new StringBuilder();
31	29	configStringBuilder.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?> " + System.lineSeparator());
...	...
86	84	}
87	85	return managedConfigFile;
88	86	}
89
90	87	}

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/taxeditor/remoting/source/CdmPersistentRemoteSource.java
32	32
33	33	/**
34	34	* Class representing a CDM remote source which can be persisted to a source config file
35		*
36	35	*/
37	36	public class CdmPersistentRemoteSource extends CdmRemoteSourceBase implements ICdmPersistentSource{
38	37	@SuppressWarnings("unused")
...	...
60	59	} else {
61	60	throw new CdmRemoteSourceException("Remote source '" + remoteSource + "' does not exist in sources setting file");
62	61	}
63
64	62	}
65	63
66	64	/**S
...	...
151	149
152	150
153	151	Properties props = cdmSourceProperties;
154		Enumeration e = props.propertyNames();
	152	Enumeration<?> e = props.propertyNames();
155	153
156	154	while (e.hasMoreElements()) {
157	155	String key = (String) e.nextElement();
...	...
165	163	XmlHelp.prettyFormat );
166	164
167	165	return NewInstance(strRemoteSourceName) ;
168
169	166	}
170	167
171	168	/**
...	...
224	221	return super.toString();
225	222	}
226	223	}
227
228	224	}

     */
     package eu.etaxonomy.taxeditor.remoting.source;
     /**
      * Class representing a CDM remote source
+     *
      */
     public class CdmRemoteSource extends CdmRemoteSourceBase {
     	/**
     	 * Creates a new instance of CdmRemoteSource
+    	 *
     	 * @param name
     	 * @param server
     	 * @param port
     	 * @param contextPath
     	 * @param nomenclaturalCode
     	 * @return
     	 */
     	public static CdmRemoteSource NewInstance() {
     		return new CdmRemoteSource(DEFAULT_NAME, DEFAULT_SERVER, DEFAULT_PORT, DEFAULT_CONTEXT_PATH);
-...
     	 * @param server
     	 * @param port
     	 * @param contextPath
     	 * @param nomenclaturalCode
     	 * @return
     	 */
     	public static CdmRemoteSource NewInstance(String name, String server, int port, String contextPath) {
-...
     	 * @param server
     	 * @param port
     	 * @param contextPath
     	 * @param nomenclaturalCode
     	 */
     	private CdmRemoteSource(String name, String server, int port, String contextPath) {
     		super(name, server, port, contextPath);
+    	}
+    }

      * Base class representing a CDM remote source.
      * This class handles all the configuration relating to the remoting aspect of
      * a CDM source.
+     *
      */
     public class CdmRemoteSourceBase extends CdmSource implements ICdmRemoteSource {
-...
     	/**
     	 * Constructs a CdmRemoteSourceBase object with default values.
+    	 *
     	 */
     	protected CdmRemoteSourceBase() {
     		setName(DEFAULT_NAME);
-...
     	@Override
     	public String getDbSchemaVersion() throws CdmSourceException {
     		return metadataService.getDbSchemaVersion();
+    	}
     	@Override
     	public boolean isDbEmpty() throws CdmSourceException {
     		return metadataService.isDbEmpty();
+    	}
     	@Override
-...
     		return "Connecting to Remote CDM Instance " + getName() + ":" + getPort() + "/" + getContextPath();
+    	}
     	@Override
     	public Map<CdmMetaDataPropertyName, String> getMetaDataMap() throws CdmSourceException {
     		return metadataService.getCdmMetadataMap();

     /**
+     *
      */
     * Copyright (C) 2014 EDIT
     * European Distributed Institute of Taxonomy
     * http://www.e-taxonomy.eu
+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
     package eu.etaxonomy.taxeditor.remoting.source;
     /**
+     *
+     *
      */
     public class CdmRemoteSourceException extends Exception {
     	public CdmRemoteSourceException(String message) {
         private static final long serialVersionUID = -6381037924316526887L;
         public CdmRemoteSourceException(String message) {
     		super(message);
+    	}

     /**
      * @author cmathew
      * @date 20 Jan 2015
+     *
      */
     public class CdmServerInfo {
         public static final Logger logger = Logger.getLogger(CdmServerInfo.class);
         private final static String CDMSERVER_PREFIX = "cdmserver/";
-...
             instances = new ArrayList<>();
+        }
         public CdmInstanceInfo addInstance(String name, String basePath) {
             String _basePath = basePath;
             if(isLocalhostMgd()) {
-...
             CdmInstanceInfo cii = new CdmInstanceInfo(name, _basePath);
             instances.add(cii);
             return cii;
+        }
         public boolean isLocalhost() {
-...
+            }
+        }
         /**
          * @return
          */
         String guessProtocol() {
             return port == 443 ? "https" : "http";
+        }
-...
             return true;
+        }
         public boolean pingInstance(CdmInstanceInfo instance, int port) throws CDMServerException  {
             ICdmRemoteSource crs = getCdmRemoteSource(instance, port);
             try {
-...
+            }
+        }
         /**
          * @param serverVersion
          * @param editorVersion
          * @throws CdmSourceException
          */
         public static int compareCdmlibServicesVersion(String serverVersion, String serverCdmlibLastModified) throws CdmSourceException {
             String editorVersion = CdmApplicationState.getCdmlibVersion();
-...
             return serverInfoList;
+        }
         /**
          * @param file
          * @throws IOException
          * @throws FileNotFoundException
          * @throws JsonMappingException
          * @throws JsonParseException
          */
         private static List<CdmServerInfoConfig>  loadFromConfigFile(File file) {
             List<CdmServerInfoConfig> serverList = null;
-...
+        }
         /**
+         *
          */
         private static List<CdmServerInfoConfig> createDefaultServerConfigList() {
             List<CdmServerInfoConfig> serverInfoList = new ArrayList<CdmServerInfoConfig>();
             List<CdmServerInfoConfig> serverInfoList = new ArrayList<>();
             serverInfoList.add(new CdmServerInfoConfig(NAME_PRODUCTION, SERVER_PRODUCTION, 80, "", false));
             serverInfoList.add(new CdmServerInfoConfig(NAME_DEMO_1, SERVER_DEMO_1, 80, CDMSERVER_PREFIX, false));
             serverInfoList.add(new CdmServerInfoConfig(NAME_LOCALHOST, SERVER_LOCALHOST, 8080, CDMSERVER_PREFIX, true));
-...
             return server;
+        }
         public int getPort() {
             return port;
+        }
-...
              */
             private final String basePath;
             public CdmInstanceInfo(String name, String basePath) {
                 this.name = name;
                 this.basePath = basePath;
+            }
             public String getName() {
                 return name;
+            }

      * @date  Feb 10, 2016
      */
     public class CdmServerInfoConfig {
         /**
+         *
          */
         private String name;
         /**
+         *
          */
         private String server;
         /**
+         *
          */
         private int port;
         /**
+         *
          */
         private String prefix;
         /**
+         *
          */
         private boolean ignoreCdmLibVersion;
         /**
+         *
          */
         public CdmServerInfoConfig(String name, String server, int port, String prefix, boolean ignoreCdmLibVersion) {
             this.name = name;
             this.server = server;
-...
+        }
         /**
          * @return the name
          */
         public String getName() {
             return name;
+        }
         /**
          * @param name the name to set
          */
         public void setName(String name) {
             this.name = name;
+        }
         /**
          * @return the server
          */
         public String getServer() {
             return server;
+        }
         /**
          * @param server the server to set
          */
         public void setServer(String server) {
             this.server = server;
+        }
         /**
          * @return the port
          */
         public int getPort() {
             return port;
+        }
         /**
          * @param port the port to set
          */
         public void setPort(int port) {
             this.port = port;
+        }
         /**
          * @return the prefix
          */
         public String getPrefix() {
             return prefix;
+        }
         /**
          * @param prefix the prefix to set
          */
         public void setPrefix(String prefix) {
             this.prefix = prefix;
+        }
         /**
          * @return the ignoreCdmLibVersion
          */
         public boolean isIgnoreCdmLibVersion() {
             return ignoreCdmLibVersion;
+        }
         /**
          * @param ignoreCdmLibVersion the ignoreCdmLibVersion to set
          */
         public void setIgnoreCdmLibVersion(boolean ignoreCdmLibVersion) {
             this.ignoreCdmLibVersion = ignoreCdmLibVersion;
+        }

     /**
     * Copyright (C) 2014 EDIT
     * European Distributed Institute of Taxonomy
     * European Distributed Institute of Taxonomy
     * http://www.e-taxonomy.eu
+    *
+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
-...
     /**
      * Interface representing a CDM remote source
+     *
      */
     public interface ICdmRemoteSource extends ICdmSource {
     	/**
     	 * Gets the context path.
     	 * e.g. for 'http://127.0.0.1:8080/col/remoting/common.service', the
     	 * e.g. for 'http://127.0.0.1:8080/col/remoting/common.service', the
     	 * context path would be 'col'
     	 */
     	public String getContextPath();
     	/**
     	 * Gets the base url for the http-invoker services as listed in
     	 * Gets the base url for the http-invoker services as listed in
     	 * httpInvokerServicesClients.xml.
     	 * e.g. for 'http://127.0.0.1:8080/col/remoting/common.service', the
     	 * e.g. for 'http://127.0.0.1:8080/col/remoting/common.service', the
     	 * base url would be 'http://127.0.0.1:8080/col'
     	 */
     	public String getBaseUrl();
     	public String getBaseUrl();
+    }

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/taxeditor/service/AuthenticatingHttpInvokerRequestExecutor.java
20	20	/**
21	21	* @author cmathew
22	22	* @date 27 Jan 2015
23		*
24	23	*/
25	24	public class AuthenticatingHttpInvokerRequestExecutor extends TimestampingHttpInvokerRequestExecutor {
26	25
...	...
40	39	}
41	40	return postMethod;
42	41	}
43
44	42	}

     @Component
     public class CachedCommonServiceImpl implements ICachedCommonService {
         private static boolean cacheEnabled = true;
         public static boolean isCacheEnabled() {
-...
             return cdmEntity;
+        }
         private List<String> getPropertyPaths(Object obj) {
             List<String> propertyPaths = null;
             ICdmEntitySession cdmEntitySession =

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/taxeditor/service/CdmServiceInterceptorException.java
1	1	package eu.etaxonomy.taxeditor.service;
2	2
3	3	public class CdmServiceInterceptorException extends RuntimeException {
4
5		public CdmServiceInterceptorException(String message) {
	4
	5	private static final long serialVersionUID = 4413915923638221536L;
	6
	7	public CdmServiceInterceptorException(String message) {
6	8	super(message);
7	9	}
8
	10
9	11	public CdmServiceInterceptorException(Exception ex) {
10	12	super(ex);
11	13	}
12
13	14	}

     /**
      * @author cmathew
      * @date 14 Oct 2014
+     *
      */
     public interface ICachedCommonService {
         public CdmBase find(Class<? extends CdmBase> clazz, int id);
         /**
          * Initializes a collection or map.
+         *
-...
          * @return true if the value object exists in the collection, false o/w
          */
         public boolean containsValue(UUID ownerUuid, String fieldName, Object element);
+    }

     /**
      * @author a.kohlbecker
      * @since Feb 4, 2020
+     *
      */
     public interface IRemoteInvocationTermCacher {
         /**
          * @param ri
          * @param rir
          */
         void cacheTerms(RemoteInvocation ri, RemoteInvocationResult rir);
         public void cacheTerms(RemoteInvocation ri, RemoteInvocationResult rir);
         /**
          * @param ri
          * @return
          */
         RemoteInvocationResult termsFromCache(RemoteInvocation ri);
         public RemoteInvocationResult termsFromCache(RemoteInvocation ri);
+    }

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/taxeditor/service/RemoteInvocationTermCacher.java
16	16
17	17
18	18	public class RemoteInvocationTermCacher implements IRemoteInvocationTermCacher {
	19
19	20	private static final Logger logger = Logger.getLogger(RemoteInvocationTermCacher.class);
20	21
21	22	private static Map<TermType, RemoteInvocationResult> termTypeMap = new HashMap<>();
...	...
40	41	}
41	42	termTypeMap.put((TermType)ri.getArguments()[0], rir);
42	43	}
43
44	44	}
45	45	}
46	46	} else {
...	...
52	52	public RemoteInvocationResult termsFromCache(RemoteInvocation ri) {
53	53	return termTypeMap.get(ri.getArguments()[0]);
54	54	}
55
56	55	}

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/taxeditor/service/TimestampingHttpInvokerRequestExecutor.java
59	59	super(createDefaultHttpClient());
60	60	}
61	61
62
63	62	@Override
64	63	protected HttpResponse executeHttpPost(HttpInvokerClientConfiguration config, HttpClient httpClient,
65	64	HttpPost httpPost) throws IOException {
66	65
67
68	66	setExecutionRequestClientTimestamp(httpPost.getURI());
69	67
70	68	HttpResponse respone = super.executeHttpPost(config, httpClient, httpPost);
...	...
108	106	.setConnectionReuseStrategy(new NoConnectionReuseStrategy()) // see #8812
109	107	.build();
110	108	}
111
112	109	}

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/taxeditor/session/CdmClientSessionException.java
2	2
3	3	public class CdmClientSessionException extends RuntimeException {
4	4
5		public CdmClientSessionException(String message) {
	5	private static final long serialVersionUID = -6738096254429238266L;
	6
	7	public CdmClientSessionException(String message) {
6	8	super(message);
7	9	}
8	10	}

     import eu.etaxonomy.taxeditor.remoting.cache.ConversationalTransientEntityCacher;
     import net.sf.ehcache.statistics.LiveCacheStatistics;
     /**
      * NOTE : It would be nice to have this class performing merge / delete operations
      * using services, but this is only possible if we can 'intelligently'
      * get from a model class to the corresponding service class
+     *
+     *
      * @author cmathew
      * @date 20 Oct 2014
      */
-...
         private List<ICdmEntitySessionEnabled> changeObservers;
         public CdmEntitySession(ICdmEntitySessionEnabled sessionOwner, CdmEntitySessionManager cdmEntitySessionManager) {
             this.sessionOwner = sessionOwner;
             this.cdmEntitySessionManager = cdmEntitySessionManager;
-...
             cdmEntitySessionManager.addToOwnerSessionMap(sessionOwner, this);
+        }
         @Override
         public  <O extends Object> O load(O obj, boolean update) {
             return cdmTransientEntityCacher.load(obj, update);
+        }
         @Override
         public  <T extends CdmBase> T load(T cdmBase, boolean update) {
             return cdmTransientEntityCacher.load(cdmBase, update);
-...
             //		}
+        }
         @Override
         public void bind() {
             logger.info("Binding session with owner " + sessionOwner.toString());
-...
                 init(sessionOwner, cdmEntitySessionManager);
+            }
             cdmEntitySessionManager.bind(sessionOwner);
+        }
         @Override
-...
             cdmTransientEntityCacher.dispose();
             changeObservers.clear();
             cdmEntitySessionManager.remove(sessionOwner);
+        }
     //    @Override
-...
             return load(cdmBase, false);
+        }
         /**
          * Returns the cdm entity specified by the <code>uuid</code>,
          * recursively initializes all bean properties given in the
-...
         public void addNewCdmEntity(CdmBase newEntity) {
             cdmTransientEntityCacher.addNewEntity(newEntity);
+        }
+    }

     /**
      * @author cmathew
      * @date 16 Oct 2014
+     *
      */
     @Component
     public class CdmEntitySessionManager implements ICdmEntitySessionManager {
         private static final Logger logger = Logger.getLogger(CdmEntitySessionManager.class);
         private final Map<ICdmEntitySessionEnabled, ICdmEntitySession> ownerSessionMap =
                 new HashMap<ICdmEntitySessionEnabled, ICdmEntitySession>();
         private final Map<ICdmEntitySessionEnabled, ICdmEntitySession> ownerSessionMap = new HashMap<>();
         private final List<ICdmEntitySessionManagerObserver> sessionObservers = new ArrayList<ICdmEntitySessionManagerObserver>();
         private final List<ICdmEntitySessionManagerObserver> sessionObservers = new ArrayList<>();
         //private ICdmEntitySession activeSession;
         private final InheritableThreadLocal<ICdmEntitySession> tlActiveSession = new InheritableThreadLocal<ICdmEntitySession>();
         private final InheritableThreadLocal<ICdmEntitySession> tlActiveSession = new InheritableThreadLocal<>();
         private  NullSession nullSession;
-...
             return tlActiveSession.get();
+        }
         private void setActiveSession(ICdmEntitySession activeSession) {
            this. tlActiveSession.set(activeSession);
             notifyObservers();
-...
+            }
             setActiveSession(session);
+        }
         @Override
-...
             return tlActiveSession.get().load(cdmBaseList, update);
+        }
         /* (non-Javadoc)
          * @see eu.etaxonomy.taxeditor.session.ICdmEntitySessionManager#dispose(eu.etaxonomy.taxeditor.session.ISessionEventListener)
          */
         void remove(ICdmEntitySessionEnabled owner) {
             ICdmEntitySession session = ownerSessionMap.get(owner);
             if(session == null) {
-...
             if(nullSession != null && nullSession.getOwner() == owner) {
                 nullSession = null;
+            }
+        }
         @Override
         public void disposeAll() {
             Set<ICdmEntitySessionEnabled> owners =
-...
                     session.dispose();
+                }
+            }
+        }
         void addToOwnerSessionMap(ICdmEntitySessionEnabled owner, ICdmEntitySession session) {

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/taxeditor/session/DefaultNewEntityListener.java
18	18	/**
19	19	* @author cmathew
20	20	* @date 30 Sep 2015
21		*
22	21	*/
23	22	public class DefaultNewEntityListener implements NewEntityListener {
24	23
...	...
34	33	}
35	34	}
36	35	}
37
38	36	}

     //     */
     //    public <T extends ICdmBase> void update(T cdmBase, CdmBase affectedObject);
         /**
+         *
          */
         public <T extends CdmBase> void update();
         /**
          * @param obj
          * @return
          */
         public List<String> getPropertyPaths(Object obj);
         public void addNewCdmEntity(CdmBase newEntity);

eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/preference/CdmStorePropertyTester.java
57	57
58	58	private boolean isRemoting() {
59	59	return CdmStore.getCurrentSessionManager().isRemoting();
60
61	60	}
62
63
64	61	}

eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/ui/element/BigDecimalWithLabelElement.java
25	25	public BigDecimalWithLabelElement(CdmFormFactory toolkit, ICdmFormElement parentElement, String labelString,
26	26	Number initialNumber, int style) {
27	27	super(toolkit, parentElement, labelString, initialNumber, style);
28
29	28	}
30	29
31	30	private BigDecimal start;
...	...
82	81	return null;
83	82	}
84	83	}
85
86	84	}

eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/ui/element/FloatWithLabelElement.java
71	71	this.end = end;
72	72	}
73	73
74
75	74	public void setLimits(int numberOfDigits, Integer start, Integer end){
76	75	setLimits(numberOfDigits, start.floatValue(), end.floatValue());
77	76	}

Project

General

Profile

EDIT

Revision 2661173a

Added by Andreas Müller almost 4 years ago