src/site/resources/css/site.css -text
src/site/resources/images/taxeditor_transformed.png -text
src/site/site.xml -text
+
+# The following files will be ignored when merging another
+# branch into this branch in case of merge conflict and
+# if the 'ours' merge driver is configured.
+# WARNING : This merge driver should NOT be set in development
+# environments. It is supposed to be used only in CI
+# environments.
+# The driver can be configured by executing,
+# git config --local merge.ours.driver true
+**/pom.xml merge=ours
+**/MANIFEST.MF merge=ours
+**/feature.xml merge=ours
+eu.etaxonomy.taxeditor.cdmlib/.classpath merge=ours
+eu.etaxonomy.taxeditor.cdmlib/build.properties merge=ours
+eu.etaxonomy.taxeditor/eu.etaxonomy.taxeditor.product merge=ours
+eu.etaxonomy.taxeditor/eu.etaxonomy.taxeditor.product.with.jre merge=ours
\ No newline at end of file
if (object instanceof Person){\r
Person person = HibernateProxyHelper.deproxy(object, Person.class);\r
try {\r
- team = CdmStore.getService(IAgentService.class).convertPerson2Team(person);\r
+ team = CdmStore.getService(IAgentService.class).convertPerson2Team(person.getUuid());\r
} catch (IllegalArgumentException e) {\r
MessagingUtils.errorDialog("Can not convert Person into a Team", null, e.getLocalizedMessage(), TaxeditorBulkeditorPlugin.PLUGIN_ID,e, true);\r
} catch (MergeException e) {\r
import org.eclipse.ui.handlers.HandlerUtil;\r
import org.eclipse.ui.texteditor.IDocumentProvider;\r
\r
-import eu.etaxonomy.cdm.api.service.AgentServiceImpl;\r
import eu.etaxonomy.cdm.api.service.IAgentService;\r
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;\r
-import eu.etaxonomy.cdm.model.agent.AgentBase;\r
import eu.etaxonomy.cdm.model.agent.Person;\r
import eu.etaxonomy.cdm.model.agent.Team;\r
import eu.etaxonomy.cdm.strategy.merge.MergeException;\r
@Override\r
public Person execute(ExecutionEvent event) throws ExecutionException {\r
ISelection selection = HandlerUtil.getCurrentSelection(event);\r
- \r
+\r
IEditorPart editor = HandlerUtil.getActiveEditor(event);\r
- \r
+\r
IEditorInput input = editor.getEditorInput();\r
if (editor.isDirty()){\r
boolean proceed = MessageDialog.openQuestion(null,\r
}\r
}\r
if((input instanceof IEntityPersistenceService) && (selection instanceof IStructuredSelection)){\r
- \r
- \r
+\r
+\r
IDocumentProvider provider = ((BulkEditor) editor).getDocumentProvider();\r
- LineAnnotationModel model = \r
+ LineAnnotationModel model =\r
(LineAnnotationModel) provider.getAnnotationModel(input);\r
- \r
- \r
+\r
+\r
IStructuredSelection structuredSelection = (IStructuredSelection) selection;\r
- \r
+\r
IEntityPersistenceService persistenceService = (IEntityPersistenceService) input;\r
- \r
+\r
Person person ;\r
for(Object object : structuredSelection.toList()){\r
LineAnnotation annotation = (LineAnnotation) model.getAnnotation(object);\r
if (object instanceof Team){\r
Team team = HibernateProxyHelper.deproxy(object, Team.class);\r
try {\r
- person = CdmStore.getService(IAgentService.class).convertTeam2Person(team);\r
+ person = CdmStore.getService(IAgentService.class).convertTeam2Person(team.getUuid());\r
} catch (IllegalArgumentException e) {\r
MessagingUtils.informationDialog("Can not convert Team to Person", e.getMessage());\r
} catch (MergeException e) {\r
}else{\r
MessagingUtils.informationDialog("Can not convert Team to Person", "convertTeam2Person can only be called on a team.");\r
}\r
- \r
+\r
if (person != null){\r
((BulkEditor) editor).removeAnnotatedLine(annotation);\r
((BulkEditor) editor).createAnnotatedLine(person);\r
@Override
public TeamOrPersonBase save(TeamOrPersonBase entity) {
if(CdmStore.getCurrentSessionManager().isRemoting()) {
- return (TeamOrPersonBase) CdmStore.getService(IAgentService.class).merge(entity, true);
+ return (TeamOrPersonBase) CdmStore.getService(IAgentService.class).merge(entity, true).getMergedEntity();
} else {
CdmStore.getService(IAgentService.class).saveOrUpdate(entity) ;
return entity;
@Override
public Group save(Group entity) {
if(CdmStore.getCurrentSessionManager().isRemoting()) {
- return CdmStore.getService(IGroupService.class).merge(entity, true) ;
+ return CdmStore.getService(IGroupService.class).merge(entity, true).getMergedEntity();
} else {
CdmStore.getService(IGroupService.class).saveOrUpdate(entity);
return entity;
@Override
public TaxonNameBase save(TaxonNameBase entity) {
if(CdmStore.getCurrentSessionManager().isRemoting()) {
- return CdmStore.getService(INameService.class).merge(entity, true) ;
+ return CdmStore.getService(INameService.class).merge(entity, true).getMergedEntity();
} else {
CdmStore.getService(INameService.class).saveOrUpdate(entity);
return entity;
@Override
public SpecimenOrObservationBase<IIdentifiableEntityCacheStrategy> save(SpecimenOrObservationBase entity) {
if(CdmStore.getCurrentSessionManager().isRemoting()) {
- return CdmStore.getService(IOccurrenceService.class).merge(entity, true) ;
+ return CdmStore.getService(IOccurrenceService.class).merge(entity, true).getMergedEntity();
} else {
CdmStore.getService(IOccurrenceService.class).save(entity);
return entity;
@Override
public Reference save(Reference entity) {
if(CdmStore.getCurrentSessionManager().isRemoting()) {
- return CdmStore.getService(IReferenceService.class).merge(entity, true);
+ return CdmStore.getService(IReferenceService.class).merge(entity, true).getMergedEntity();
} else {
CdmStore.getService(IReferenceService.class).saveOrUpdate(entity);
return entity;
@Override\r
public TaxonBase save(TaxonBase entity) {\r
if(CdmStore.getCurrentSessionManager().isRemoting()) {\r
- return CdmStore.getService(ITaxonService.class).merge(entity, true);\r
+ return CdmStore.getService(ITaxonService.class).merge(entity, true).getMergedEntity();\r
} else {\r
CdmStore.getService(ITaxonService.class).saveOrUpdate(entity);\r
return entity;\r
@Override
public User save(User entity) {
if(CdmStore.getCurrentSessionManager().isRemoting()) {
- return CdmStore.getService(IUserService.class).merge(entity, true);
+ return CdmStore.getService(IUserService.class).merge(entity, true).getMergedEntity();
} else {
CdmStore.getService(IUserService.class).saveOrUpdate(entity);
return entity;
try{
User user = User.NewInstance(text, text);
if(CdmStore.getCurrentSessionManager().isRemoting()) {
- user = CdmStore.getService(IUserService.class).merge(user);
+ CdmStore.getService(IUserService.class).createUser(user);
+ user = CdmStore.getService(IUserService.class).loadWithUpdate(user.getUuid());
} else {
CdmStore.getService(IUserService.class).createUser(user);
}
*/
package eu.etaxonomy.cdm.api.application;
+import java.io.File;
+import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
-
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.util.Dictionary;
+import java.util.jar.Attributes;
+import java.util.jar.JarFile;
+import java.util.jar.Manifest;
+
+import org.eclipse.core.runtime.FileLocator;
+import org.eclipse.core.runtime.Platform;
+import org.eclipse.osgi.util.ManifestElement;
+import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleException;
+import org.osgi.framework.Constants;
import org.springframework.security.core.context.SecurityContext;
import eu.etaxonomy.cdm.api.cache.CdmServiceCacher;
private static CdmServiceCacher cdmServiceCacher;
+ private static String cdmlibVersion = null;
+ private static String cdmlibLastModified = null;
public static CdmApplicationState getInstance() {
if(cdmApplicationState == null) {
getInstance().setSecurityContext(null);
cdmApplicationState = null;
cdmServiceCacher = null;
+ cdmlibVersion = null;
+ cdmlibLastModified = null;
}
cdmServiceCacher = cacher;
}
+ public static void updateCdmlibManifestInfo() {
+ cdmlibVersion = null;
+ cdmlibLastModified = null;
+ String cdmlibPathPrefix = "lib/cdmlib-services-";
+ String jarSuffix = ".jar";
+ Bundle bundle = Platform.getBundle("eu.etaxonomy.taxeditor.cdmlib");
+ Dictionary<String, String> headers = bundle.getHeaders();
+ String bundleClasspath = headers.get(Constants.BUNDLE_CLASSPATH);
+ try {
+ ManifestElement[] elements = ManifestElement.parseHeader(Constants.BUNDLE_CLASSPATH, bundleClasspath);
+ for (ManifestElement manifestElement : elements) {
+ String jar = manifestElement.getValue();
+ if(jar.startsWith(cdmlibPathPrefix) && jar.endsWith(jarSuffix)) {
+ URL fileURL = bundle.getEntry(jar);
+ File file = null;
+ try {
+ String urlString = FileLocator.resolve(fileURL).toExternalForm().replace(" ", "%20");;
+ file = new File(new URI(urlString));
+ JarFile jarFile = new JarFile(file);
+ Manifest manifest = jarFile.getManifest();
+ Attributes attributes = manifest.getMainAttributes();
+ // from the OSGI spec the LastModified value is " the number of milliseconds
+ // since midnight Jan. 1, 1970 UTC with the condition that a change must
+ // always result in a higher value than the previous last modified time
+ // of any bundle"
+ cdmlibVersion = attributes.getValue("Bundle-Version");
+ cdmlibLastModified = attributes.getValue("Bnd-LastModified");
+
+ jarFile.close();
+ if(cdmlibVersion == null || cdmlibLastModified == null) {
+ throw new IllegalStateException("Invalid cdmlib manifest info");
+ }
+ } catch (URISyntaxException urise) {
+ throw new IllegalStateException(urise);
+ } catch (IOException ioe) {
+ throw new IllegalStateException(ioe);
+ }
+ }
+ }
+ } catch (BundleException e) {
+ throw new IllegalStateException(e);
+ }
+ }
+
+ public static String getCdmlibVersion() {
+ if(cdmlibVersion == null) {
+ updateCdmlibManifestInfo();
+ }
+ return cdmlibVersion;
+ }
+ public static String getCdmlibLastModified() {
+ if(cdmlibLastModified == null) {
+ updateCdmlibManifestInfo();
+ }
+ return cdmlibLastModified;
+ }
}
import eu.etaxonomy.cdm.api.service.pager.Pager;
import eu.etaxonomy.cdm.model.ICdmCacher;
import eu.etaxonomy.cdm.model.common.CdmBase;
+import eu.etaxonomy.cdm.persistence.dto.MergeResult;
/**
* @author cmathew
} else if(obj instanceof Pager) {
load(((Pager)obj).getRecords(), recursive, update);
return obj;
+ } else if(obj instanceof MergeResult) {
+ return (T) load((MergeResult<CdmBase>)obj, recursive, update);
}
return obj;
}
+ public MergeResult<CdmBase> load(MergeResult<CdmBase> mergeResult, boolean recursive, boolean update) {
+ CdmBase cdmBase = load(mergeResult.getMergedEntity(), recursive, update);
+ load(mergeResult.getNewEntities(), recursive, update);
+ return new MergeResult(cdmBase, mergeResult.getNewEntities());
+ }
+
+
/**
* Puts the (Key,Value) pair of ({@link java.util.UUID}, {@link eu.etaxonomy.cdm.model.common.CdmBase}),
* in the cache corresponding to the given cache id
import eu.etaxonomy.cdm.api.service.dto.CdmEntityIdentifier;
import eu.etaxonomy.cdm.model.ICdmCacher;
import eu.etaxonomy.cdm.model.common.CdmBase;
+import eu.etaxonomy.cdm.persistence.dto.MergeResult;
import eu.etaxonomy.taxeditor.session.ICdmEntitySessionManager;
/**
return result;
}
+ public MergeResult<CdmBase> load(MergeResult<CdmBase> mergeResult, boolean update) {
+ return cacheLoader.load(mergeResult, true, update);
+ }
+
public CdmModelFieldPropertyFromClass getFromCdmlibModelCache(String className) {
return cacheLoader.getFromCdmlibModelCache(className);
}
import java.util.Comparator;
import java.util.List;
+import org.apache.commons.lang.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.ResponseHandler;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
+import org.apache.http.params.HttpConnectionParams;
+import org.apache.http.params.HttpParams;
import org.apache.http.util.EntityUtils;
import org.apache.log4j.Logger;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
+import eu.etaxonomy.cdm.api.application.CdmApplicationState;
import eu.etaxonomy.cdm.config.CdmSourceException;
import eu.etaxonomy.cdm.database.CdmPersistentDataSource;
import eu.etaxonomy.cdm.database.ICdmDataSource;
+import eu.etaxonomy.cdm.model.metadata.CdmMetaData;
import eu.etaxonomy.taxeditor.remoting.server.CDMServerException;
/**
private static List<CdmServerInfo> cdmServerInfoList;
+ private String cdmlibServicesVersion = "";
+ private String cdmlibServicesLastModified = "";
+
+
public CdmServerInfo(String name, String server, int port) {
this.name = name;
this.server = server;
this.port = port;
instances = new ArrayList<CdmInstanceInfo>();
+
}
return NAME_LOCALHOST_MGD.equals(name);
}
+ public String getCdmlibServicesVersion() {
+ return cdmlibServicesVersion;
+ }
+
+ public String getCdmlibLastModified() {
+ return cdmlibServicesLastModified;
+ }
+
public void refreshInstances() throws CDMServerException {
instances.clear();
if(isLocalhostMgd()) {
});
}
+ public void updateInfo() throws CDMServerException {
+ String url = "http://" + server + ":" + String.valueOf(port) + "/" + CDMSERVER_PREFIX + "/info.jsp";
+ String responseBody = getResponse(url);
+ if(responseBody != null) {
+ try {
+ JSONObject info = new JSONObject(responseBody);
+ cdmlibServicesVersion = info.getString("cdmlibServicesVersion");
+ cdmlibServicesLastModified = info.getString("cdmlibServicesLastModified");
+ } catch (JSONException e) {
+ throw new CDMServerException(e);
+ }
+ }
+ }
+
public void addInstancesViaHttp() throws CDMServerException {
+ updateInfo();
String url = "http://" + server + ":" + String.valueOf(port) + "/" + CDMSERVER_PREFIX + "/instances.jsp";
+ String responseBody = getResponse(url);
+ if(responseBody != null) {
+ try {
+ JSONArray array = new JSONArray(responseBody);
+ for(int i=0;i<array.length();i++) {
+ JSONObject instance = (JSONObject)array.get(i);
+ if(instance != null) {
+ JSONObject conf = (JSONObject)instance.get("configuration");
+ if(conf != null) {
+ String instanceName = conf.getString("instanceName");
+ // we need to remove the first (char) forward slash from
+ // the base path
+ String basePath = conf.getString("basePath").substring(1);
+ addInstance(instanceName, basePath);
+ logger.info("Added instance with name : " + instanceName + ", basePath : " + basePath);
+ }
+ }
+ }
+ } catch (JSONException e) {
+ throw new CDMServerException(e);
+ }
+ }
+ }
+ private String getResponse(String url) throws CDMServerException {
HttpClient client = new DefaultHttpClient();
+ HttpParams params = client.getParams();
+
+ HttpConnectionParams.setConnectionTimeout(params, 5000);
+ HttpConnectionParams.setSoTimeout(params, 5000);
+
HttpGet httpGet = new HttpGet(url);
logger.info("Executing request " + httpGet.getRequestLine());
} catch (IOException e) {
throw new CDMServerException(e);
}
-
-
- if(responseBody != null) {
- try {
- JSONArray array = new JSONArray(responseBody);
- for(int i=0;i<array.length();i++) {
- JSONObject instance = (JSONObject)array.get(i);
- if(instance != null) {
- JSONObject conf = (JSONObject)instance.get("configuration");
- if(conf != null) {
- String instanceName = conf.getString("instanceName");
- // we need to remove the first (char) forward slash from
- // the base path
- String basePath = conf.getString("basePath").substring(1);
- addInstance(instanceName, basePath);
- logger.info("Added instance with name : " + instanceName + ", basePath : " + basePath);
- }
- }
- }
- } catch (JSONException e) {
- throw new CDMServerException(e);
- }
- }
+ return responseBody;
}
public void addInstancesFromDataSourcesConfig() {
return null;
}
- public boolean pingServer(){
+ public boolean pingServer() {
try {
Socket s = new Socket(server, port);
logger.info("[CDM-Server] Available @ " + server + ":" + port );
+ updateInfo();
return true;
} catch (IOException ioe) {
+ } catch (CDMServerException e) {
+
}
return false;
}
return false;
}
+ public int compareDbSchemaVersion(CdmInstanceInfo instance, int port) throws CDMServerException {
+
+ ICdmRemoteSource crs = getCdmRemoteSource(instance, port);
+ String dbSchemaVersion;
+ try {
+ dbSchemaVersion = crs.getDbSchemaVersion();
+ } catch (CdmSourceException e) {
+ throw new CDMServerException(e);
+ }
+
+
+ if(dbSchemaVersion != null) {
+ return CdmMetaData.compareVersion(dbSchemaVersion, CdmMetaData.getDbSchemaVersion(), 3, null);
+ } else {
+ throw new CDMServerException("Cannot determine editor db. schema version");
+ }
+ }
+
+ public int compareCdmlibServicesVersion() throws CdmSourceException {
+
+ String serverVersion = cdmlibServicesVersion;
+ String serverCdmlibLastModified = cdmlibServicesLastModified;
+
+ return compareCdmlibServicesVersion(serverVersion, serverCdmlibLastModified);
+ }
+
+
+ /**
+ * @param serverVersion
+ * @param editorVersion
+ * @throws CdmSourceException
+ */
+ public static int compareCdmlibServicesVersion(String serverVersion, String serverCdmlibLastModified) throws CdmSourceException {
+
+ String editorVersion = CdmApplicationState.getCdmlibVersion();
+ String editorCdmlibLastModified = CdmApplicationState.getCdmlibLastModified();
+
+ int result = 0;
+ if(StringUtils.isBlank(serverVersion) || StringUtils.isBlank(editorVersion)) {
+ throw new CdmSourceException("cdmlib-services server or editor version is empty");
+ }
+
+ String[] serverVersionSplit = serverVersion.split("\\.");
+ String[] editorVersionSplit = editorVersion.split("\\.");
+
+ if(serverVersionSplit.length < 3 || editorVersionSplit.length < 3 || serverVersionSplit.length > 4 || editorVersionSplit.length > 4) {
+ throw new CdmSourceException("cdmlib-services server or editor version is invalid");
+ }
+
+ Integer serverVersionPart;
+ Integer editorVersionPart;
+
+ for(int i=0 ; i<3 ; i++) {
+ serverVersionPart = Integer.valueOf(serverVersionSplit[i]);
+ editorVersionPart = Integer.valueOf(editorVersionSplit[i]);
+
+ int partCompare = serverVersionPart.compareTo(editorVersionPart);
+ if (partCompare != 0){
+ return partCompare;
+ }
+ }
+ // at this point major, minor and patch versions are matching
+
+ if(StringUtils.isBlank(serverCdmlibLastModified) || StringUtils.isBlank(editorCdmlibLastModified)) {
+ throw new CdmSourceException("cdmlib-services server or editor version is empty");
+ }
+
+ String cdmServerIgnoreVersion = System.getProperty("cdm.server.version.lm.ignore");
+ if(StringUtils.isBlank(cdmServerIgnoreVersion) || !cdmServerIgnoreVersion.equals("true")) {
+ Long serverLastModified = Long.valueOf(serverCdmlibLastModified);
+ Long editorLastModified = Long.valueOf(editorCdmlibLastModified);
+ return serverLastModified.compareTo(editorLastModified);
+ }
+
+ return 0;
+ }
+
+
+
public static List<CdmServerInfo> getCdmServers() {
if(cdmServerInfoList == null) {
cdmServerInfoList = new ArrayList<CdmServerInfo>();
import java.io.IOException;
import java.io.OutputStream;
+import java.util.HashSet;
+import java.util.Set;
import org.apache.log4j.Logger;
import org.springframework.remoting.httpinvoker.HttpInvokerClientConfiguration;
private RemoteInvocation currentRemoteInvocation;
+ protected final static Set<String> cachableMethods = new HashSet<String>();
+
+ public CdmServiceRequestExecutor() {
+ cachableMethods.add("merge");
+ cachableMethods.add("save");
+ cachableMethods.add("findWithUpdate");
+ cachableMethods.add("loadWithUpdate");
+ }
+
@Override
protected void writeRemoteInvocation(RemoteInvocation invocation, OutputStream os) throws IOException {
if(cdmEntitySessionManager == null) {
java.lang.ClassNotFoundException {
RemoteInvocationResult rir = fromCache(currentRemoteInvocation);
- // if rir is not null at this point we assume that the
- // the object has already been loaded in the cache and
- // does not need to be reloaded
-
if(rir == null) {
logger.info("Remote invoking : " + currentRemoteInvocation.getMethodName() + "@" + config.getServiceUrl());
rir = super.doExecuteRequest(config, baos);
if(rir.getValue() != null && !rir.hasException()) {
- if("merge".equals(currentRemoteInvocation.getMethodName()) ||
- "save".equals(currentRemoteInvocation.getMethodName()) ||
- "findWithUpdate".equals(currentRemoteInvocation.getMethodName())) {
+ if(cachableMethods.contains(currentRemoteInvocation.getMethodName())) {
rir = new RemoteInvocationResult(cdmEntitySessionManager.load(rir.getValue(), true));
} else if(rir.getValue() instanceof UpdateResult){
UpdateResult result = (UpdateResult)rir.getValue();
import eu.etaxonomy.cdm.api.service.IService;
import eu.etaxonomy.cdm.api.service.UpdateResult;
import eu.etaxonomy.cdm.model.common.CdmBase;
+import eu.etaxonomy.cdm.persistence.dto.MergeResult;
import eu.etaxonomy.taxeditor.remoting.cache.CdmTransientEntityCacher;
import eu.etaxonomy.taxeditor.remoting.cache.EntityCacherDebugResult;
return cdmTransientEntityCacher.load(updateResult, update);
}
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.taxeditor.session.ICdmEntitySession#load(eu.etaxonomy.cdm.persistence.dto.MergeResult, boolean)
+ */
+ @Override
+ public <T extends CdmBase> MergeResult<T> load(MergeResult<T> mergeResult, boolean update) {
+ return cdmTransientEntityCacher.load(mergeResult, update);
+ }
+
@Override
public <T extends CdmBase> void update() {
Collection<T> rootEntities = getRootEntities();
*/
@Override
public <T extends CdmBase> T remoteUpdate(IService<T> service, T cdmBase) {
- T mergedCdmBase = service.merge(cdmBase, true);
+ T mergedCdmBase = service.merge(cdmBase, true).getMergedEntity();
return mergedCdmBase;
}
import eu.etaxonomy.cdm.api.service.UpdateResult;
import eu.etaxonomy.cdm.model.common.CdmBase;
+import eu.etaxonomy.cdm.persistence.dto.MergeResult;
/**
* @author cmathew
}
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.taxeditor.session.ICdmEntitySessionManager#load(eu.etaxonomy.cdm.persistence.dto.MergeResult, boolean)
+ */
+ @Override
+ public MergeResult load(MergeResult mergeResult, boolean update) {
+ if(activeSession == null) {
+ return mergeResult;
+ }
+ return activeSession.load(mergeResult, update);
+ }
+
+
/* (non-Javadoc)
* @see eu.etaxonomy.taxeditor.session.ICdmEntitySessionManager#load(java.util.Collection)
*/
return true;
}
-
-
}
*/
@Override
public void onCreate(CdmBase cdmBase) {
- logger.warn("New Entity created : " + cdmBase);
+ logger.info("New Entity created : " + cdmBase);
if(CdmApplicationState.getCurrentAppConfig() instanceof CdmApplicationRemoteController){
((CdmApplicationRemoteController)CdmApplicationState.getCurrentAppConfig()).getCdmEntitySessionManager().getActiveSession().addNewCdmEntity(cdmBase);
}
import eu.etaxonomy.cdm.api.service.IService;
import eu.etaxonomy.cdm.api.service.UpdateResult;
import eu.etaxonomy.cdm.model.common.CdmBase;
+import eu.etaxonomy.cdm.persistence.dto.MergeResult;
import eu.etaxonomy.taxeditor.remoting.cache.EntityCacherDebugResult;
public interface ICdmEntitySession {
public UpdateResult load(UpdateResult updateResult, boolean update);
+ public <T extends CdmBase> MergeResult<T> load(MergeResult<T> mergeResult, boolean update);
+
public <T extends CdmBase> EntityCacherDebugResult debug(T cdmBase);
public <T extends CdmBase> EntityCacherDebugResult debug(Collection<T> cdmBase);
import eu.etaxonomy.cdm.api.service.UpdateResult;
import eu.etaxonomy.cdm.model.common.CdmBase;
+import eu.etaxonomy.cdm.persistence.dto.MergeResult;
public interface ICdmEntitySessionManager {
public abstract UpdateResult load(UpdateResult updateResult, boolean update);
+ public abstract MergeResult load(MergeResult mergeResult, boolean update);
+
public abstract <T extends CdmBase> Collection<T> load(Collection<T> cdmBaseList, boolean update);
import eu.etaxonomy.cdm.api.service.IService;
import eu.etaxonomy.cdm.api.service.UpdateResult;
import eu.etaxonomy.cdm.model.common.CdmBase;
+import eu.etaxonomy.cdm.persistence.dto.MergeResult;
import eu.etaxonomy.taxeditor.remoting.cache.EntityCacherDebugResult;
/**
*/
@Override
public <T extends CdmBase> T remoteUpdate(IService<T> service, T cdmBase) {
- T mergedCdmBase = service.merge(cdmBase, true);
+ T mergedCdmBase = service.merge(cdmBase, true).getMergedEntity();
return mergedCdmBase;
}
}
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.taxeditor.session.ICdmEntitySession#load(eu.etaxonomy.cdm.persistence.dto.MergeResult, boolean)
+ */
+ @Override
+ public <T extends CdmBase> MergeResult<T> load(MergeResult<T> mergeResult, boolean update) {
+ return mergeResult;
+ }
+
}
import eu.etaxonomy.cdm.api.service.IService;
import eu.etaxonomy.cdm.api.service.UpdateResult;
import eu.etaxonomy.cdm.model.common.CdmBase;
+import eu.etaxonomy.cdm.persistence.dto.MergeResult;
import eu.etaxonomy.taxeditor.remoting.cache.EntityCacherDebugResult;
import eu.etaxonomy.taxeditor.session.ICdmEntitySession;
import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;
}
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.taxeditor.session.ICdmEntitySession#load(eu.etaxonomy.cdm.persistence.dto.MergeResult, boolean)
+ */
+ @Override
+ public <T extends CdmBase> MergeResult<T> load(MergeResult<T> mergeResult, boolean update) {
+ return mergeResult;
+ }
+
}
import eu.etaxonomy.cdm.api.service.UpdateResult;
import eu.etaxonomy.cdm.model.common.CdmBase;
+import eu.etaxonomy.cdm.persistence.dto.MergeResult;
import eu.etaxonomy.taxeditor.session.ICdmEntitySession;
import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;
import eu.etaxonomy.taxeditor.session.ICdmEntitySessionManager;
return new MockCdmEntitySession();
}
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.taxeditor.session.ICdmEntitySessionManager#load(eu.etaxonomy.cdm.persistence.dto.MergeResult, boolean)
+ */
+ @Override
+ public MergeResult load(MergeResult mergeResult, boolean update) {
+ return mergeResult;
+ }
+
}
@Override
public void merge() {
if(CdmStore.getCurrentSessionManager().isRemoting()) {
- group = CdmStore.getService(IGroupService.class).merge(group, true);
+ group = CdmStore.getService(IGroupService.class).merge(group, true).getMergedEntity();
}
}
}
@Override
public void merge() {
if(CdmStore.getCurrentSessionManager().isRemoting()) {
- key = CdmStore.getService(IPolytomousKeyService.class).merge(key,true);
+ key = CdmStore.getService(IPolytomousKeyService.class).merge(key,true).getMergedEntity();
}
}
ContainerFactory.createOrUpdateHeterotypicSynonymyGroups(this);
ContainerFactory.createOrUpdateMisapplicationsGroup(this);
+
// Redraw composite
managedForm.reflow(true);
}
element.removeSynonym(synonym);
} else {
-
+//TODO: this should be moved to the handler, the operations should not contain ui code
DeleteResult result = service.deleteSynonym(synonym.getUuid(), element.getUuid(), null);
if (result.isError()){
DeleteResultMessagingUtils.messageDialogWithDetails(result, "Delete failed", TaxeditorEditorPlugin.PLUGIN_ID);
import eu.etaxonomy.cdm.model.view.AuditEvent;
import eu.etaxonomy.cdm.model.view.AuditEventRecord;
import eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort;
+import eu.etaxonomy.cdm.persistence.dto.MergeResult;
import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
import eu.etaxonomy.cdm.persistence.query.Grouping;
import eu.etaxonomy.cdm.persistence.query.MatchMode;
}
/* (non-Javadoc)
- * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase, boolean)
+ * @see eu.etaxonomy.cdm.api.service.IService#merge(java.util.List, boolean)
*/
@Override
- public AgentBase merge(AgentBase arg0, boolean arg1) {
+ public List<MergeResult<AgentBase>> merge(List<AgentBase> arg0, boolean arg1) {
return defaultService.merge(arg0, arg1);
}
/* (non-Javadoc)
- * @see eu.etaxonomy.cdm.api.service.IService#merge(java.util.List, boolean)
+ * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase, boolean)
*/
@Override
- public List<AgentBase> merge(List<AgentBase> arg0, boolean arg1) {
- return defaultService.merge(arg0, arg1);
+ public MergeResult<AgentBase> merge(AgentBase arg0, boolean arg1) {
+ return defaultService.merge(arg0, arg1);
+ }
+
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.api.service.IService#loadWithUpdate(java.util.UUID)
+ */
+ @Override
+ public AgentBase loadWithUpdate(UUID arg0) {
+ return defaultService.loadWithUpdate(arg0);
}
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.api.service.IAgentService#convertPerson2Team(java.util.UUID)
+ */
+ @Override
+ public Team convertPerson2Team(UUID arg0) throws MergeException, IllegalArgumentException {
+ return defaultService.convertPerson2Team(arg0);
+ }
+
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.api.service.IAgentService#convertTeam2Person(java.util.UUID)
+ */
+ @Override
+ public Person convertTeam2Person(UUID arg0) throws MergeException {
+ return defaultService.convertTeam2Person(arg0);
+ }
}
import eu.etaxonomy.cdm.model.view.AuditEvent;
import eu.etaxonomy.cdm.model.view.AuditEventRecord;
import eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort;
+import eu.etaxonomy.cdm.persistence.dto.MergeResult;
import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
import eu.etaxonomy.cdm.persistence.query.Grouping;
import eu.etaxonomy.cdm.persistence.query.MatchMode;
* @see eu.etaxonomy.cdm.api.service.IClassificationService#getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(eu.etaxonomy.cdm.model.taxon.Classification)
*/
@Override
- public List<UuidAndTitleCache<TaxonNode>> getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(Classification classification) {
- return defaultService.getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(classification);
+ public List<UuidAndTitleCache<TaxonNode>> getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(Classification classification, List<UUID> excludeTaxa) {
+ return defaultService.getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(classification, excludeTaxa);
}
/**
}
/* (non-Javadoc)
- * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase, boolean)
+ * @see eu.etaxonomy.cdm.api.service.IService#merge(java.util.List, boolean)
*/
@Override
- public Classification merge(Classification arg0, boolean arg1) {
+ public List<MergeResult<Classification>> merge(List<Classification> arg0, boolean arg1) {
return defaultService.merge(arg0, arg1);
}
/* (non-Javadoc)
- * @see eu.etaxonomy.cdm.api.service.IService#merge(java.util.List, boolean)
+ * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase, boolean)
*/
@Override
- public List<Classification> merge(List<Classification> arg0, boolean arg1) {
+ public MergeResult<Classification> merge(Classification arg0, boolean arg1) {
return defaultService.merge(arg0, arg1);
}
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.api.service.IService#loadWithUpdate(java.util.UUID)
+ */
+ @Override
+ public Classification loadWithUpdate(UUID arg0) {
+ return defaultService.loadWithUpdate(arg0);
+ }
}
import eu.etaxonomy.cdm.model.view.AuditEvent;
import eu.etaxonomy.cdm.model.view.AuditEventRecord;
import eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort;
+import eu.etaxonomy.cdm.persistence.dto.MergeResult;
import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
import eu.etaxonomy.cdm.persistence.query.Grouping;
import eu.etaxonomy.cdm.persistence.query.MatchMode;
}
/* (non-Javadoc)
- * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase, boolean)
+ * @see eu.etaxonomy.cdm.api.service.IService#merge(java.util.List, boolean)
*/
@Override
- public Collection merge(Collection arg0, boolean arg1) {
+ public List<MergeResult<Collection>> merge(List<Collection> arg0, boolean arg1) {
return defaultService.merge(arg0, arg1);
}
/* (non-Javadoc)
- * @see eu.etaxonomy.cdm.api.service.IService#merge(java.util.List, boolean)
+ * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase, boolean)
*/
@Override
- public List<Collection> merge(List<Collection> arg0, boolean arg1) {
+ public MergeResult<Collection> merge(Collection arg0, boolean arg1) {
return defaultService.merge(arg0, arg1);
}
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.api.service.IService#loadWithUpdate(java.util.UUID)
+ */
+ @Override
+ public Collection loadWithUpdate(UUID arg0) {
+ return defaultService.loadWithUpdate(arg0);
+ }
+
+
}
import eu.etaxonomy.cdm.model.view.AuditEvent;
import eu.etaxonomy.cdm.model.view.AuditEventRecord;
import eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort;
+import eu.etaxonomy.cdm.persistence.dto.MergeResult;
import eu.etaxonomy.cdm.persistence.dto.TermDto;
import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
import eu.etaxonomy.cdm.persistence.query.Grouping;
}
/* (non-Javadoc)
- * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase, boolean)
+ * @see eu.etaxonomy.cdm.api.service.IService#merge(java.util.List, boolean)
*/
@Override
- public DescriptionBase merge(DescriptionBase arg0, boolean arg1) {
+ public List<MergeResult<DescriptionBase>> merge(List<DescriptionBase> arg0, boolean arg1) {
return defaultService.merge(arg0, arg1);
}
/* (non-Javadoc)
- * @see eu.etaxonomy.cdm.api.service.IService#merge(java.util.List, boolean)
+ * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase, boolean)
*/
@Override
- public List<DescriptionBase> merge(List<DescriptionBase> arg0, boolean arg1) {
-
+ public MergeResult<DescriptionBase> merge(DescriptionBase arg0, boolean arg1) {
return defaultService.merge(arg0, arg1);
}
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.api.service.IService#loadWithUpdate(java.util.UUID)
+ */
+ @Override
+ public DescriptionBase loadWithUpdate(UUID arg0) {
+ return defaultService.loadWithUpdate(arg0);
+ }
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.api.service.IDescriptionService#moveTaxonDescription(java.util.UUID, java.util.UUID)
+ */
+ @Override
+ public UpdateResult moveTaxonDescription(UUID arg0, UUID arg1) {
+ return defaultService.moveTaxonDescriptions(arg0, arg1);
+ }
}
import eu.etaxonomy.cdm.model.view.AuditEvent;
import eu.etaxonomy.cdm.model.view.AuditEventRecord;
import eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort;
+import eu.etaxonomy.cdm.persistence.dto.MergeResult;
import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
import eu.etaxonomy.cdm.persistence.query.Grouping;
import eu.etaxonomy.cdm.persistence.query.MatchMode;
}
/* (non-Javadoc)
- * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase, boolean)
+ * @see eu.etaxonomy.cdm.api.service.IService#merge(java.util.List, boolean)
*/
@Override
- public TaxonNameBase merge(TaxonNameBase arg0, boolean arg1) {
+ public List<MergeResult<TaxonNameBase>> merge(List<TaxonNameBase> arg0, boolean arg1) {
return defaultService.merge(arg0, arg1);
}
/* (non-Javadoc)
- * @see eu.etaxonomy.cdm.api.service.IService#merge(java.util.List, boolean)
+ * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase, boolean)
*/
@Override
- public List<TaxonNameBase> merge(List<TaxonNameBase> arg0, boolean arg1) {
+ public MergeResult<TaxonNameBase> merge(TaxonNameBase arg0, boolean arg1) {
return defaultService.merge(arg0, arg1);
}
+
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.api.service.IService#loadWithUpdate(java.util.UUID)
+ */
+ @Override
+ public TaxonNameBase loadWithUpdate(UUID arg0) {
+ return defaultService.loadWithUpdate(arg0);
+ }
+
}
import eu.etaxonomy.cdm.model.view.AuditEvent;
import eu.etaxonomy.cdm.model.view.AuditEventRecord;
import eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort;
+import eu.etaxonomy.cdm.persistence.dto.MergeResult;
import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
import eu.etaxonomy.cdm.persistence.query.Grouping;
import eu.etaxonomy.cdm.persistence.query.MatchMode;
return defaultService.moveSequence(arg0, arg1, arg2);
}
- /* (non-Javadoc)
- * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase, boolean)
- */
@Override
- public SpecimenOrObservationBase merge(SpecimenOrObservationBase arg0, boolean arg1) {
- return defaultService.merge(arg0, arg1);
+ public Pager<Media> getMediainHierarchy(SpecimenOrObservationBase arg0, Integer arg1, Integer arg2,
+ List<String> arg3) {
+ return defaultService.getMediainHierarchy(arg0, arg1, arg2, arg3);
}
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.api.service.IService#merge(java.util.List, boolean)
*/
@Override
- public List<SpecimenOrObservationBase> merge(List<SpecimenOrObservationBase> arg0, boolean arg1) {
+ public List<MergeResult<SpecimenOrObservationBase>> merge(List<SpecimenOrObservationBase> arg0, boolean arg1) {
return defaultService.merge(arg0, arg1);
}
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase, boolean)
+ */
@Override
- public Pager<Media> getMediainHierarchy(SpecimenOrObservationBase arg0, Integer arg1, Integer arg2,
- List<String> arg3) {
- // TODO Auto-generated method stub
- return null;
+ public MergeResult<SpecimenOrObservationBase> merge(SpecimenOrObservationBase arg0, boolean arg1) {
+ return defaultService.merge(arg0, arg1);
}
/**
return defaultService.listAssociatedTaxa(arg0, arg1, arg2, arg3, arg4);
}
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.api.service.IService#loadWithUpdate(java.util.UUID)
+ */
+ @Override
+ public SpecimenOrObservationBase loadWithUpdate(UUID arg0) {
+ return defaultService.loadWithUpdate(arg0);
+ }
+
}
import eu.etaxonomy.cdm.model.view.AuditEvent;
import eu.etaxonomy.cdm.model.view.AuditEventRecord;
import eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort;
+import eu.etaxonomy.cdm.persistence.dto.MergeResult;
import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
import eu.etaxonomy.cdm.persistence.query.Grouping;
import eu.etaxonomy.cdm.persistence.query.MatchMode;
}
/* (non-Javadoc)
- * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase, boolean)
+ * @see eu.etaxonomy.cdm.api.service.IService#merge(java.util.List, boolean)
*/
@Override
- public Reference merge(Reference arg0, boolean arg1) {
+ public List<MergeResult<Reference>> merge(List<Reference> arg0, boolean arg1) {
return defaultService.merge(arg0, arg1);
}
/* (non-Javadoc)
- * @see eu.etaxonomy.cdm.api.service.IService#merge(java.util.List, boolean)
+ * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase, boolean)
*/
@Override
- public List<Reference> merge(List<Reference> arg0, boolean arg1) {
+ public MergeResult<Reference> merge(Reference arg0, boolean arg1) {
return defaultService.merge(arg0, arg1);
}
+
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.api.service.IService#loadWithUpdate(java.util.UUID)
+ */
+ @Override
+ public Reference loadWithUpdate(UUID arg0) {
+ return defaultService.loadWithUpdate(arg0);
+ }
+
+
}
import eu.etaxonomy.cdm.model.view.AuditEvent;
import eu.etaxonomy.cdm.model.view.AuditEventRecord;
import eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort;
+import eu.etaxonomy.cdm.persistence.dto.MergeResult;
import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
import eu.etaxonomy.cdm.persistence.fetch.CdmFetch;
import eu.etaxonomy.cdm.persistence.query.Grouping;
}
/* (non-Javadoc)
- * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase, boolean)
+ * @see eu.etaxonomy.cdm.api.service.IService#merge(java.util.List, boolean)
*/
@Override
- public TaxonBase merge(TaxonBase arg0, boolean arg1) {
+ public List<MergeResult<TaxonBase>> merge(List<TaxonBase> arg0, boolean arg1) {
return defaultService.merge(arg0, arg1);
}
/* (non-Javadoc)
- * @see eu.etaxonomy.cdm.api.service.IService#merge(java.util.List, boolean)
+ * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase, boolean)
*/
@Override
- public List<TaxonBase> merge(List<TaxonBase> arg0, boolean arg1) {
+ public MergeResult<TaxonBase> merge(TaxonBase arg0, boolean arg1) {
return defaultService.merge(arg0, arg1);
}
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.api.service.IService#loadWithUpdate(java.util.UUID)
+ */
+ @Override
+ public TaxonBase loadWithUpdate(UUID arg0) {
+ return defaultService.loadWithUpdate(arg0);
+ }
+
+
}
import eu.etaxonomy.cdm.model.view.AuditEvent;
import eu.etaxonomy.cdm.model.view.AuditEventRecord;
import eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort;
+import eu.etaxonomy.cdm.persistence.dto.MergeResult;
import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
import eu.etaxonomy.cdm.persistence.query.Grouping;
import eu.etaxonomy.cdm.persistence.query.MatchMode;
}
/* (non-Javadoc)
- * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase, boolean)
+ * @see eu.etaxonomy.cdm.api.service.IService#merge(java.util.List, boolean)
*/
@Override
- public DefinedTermBase merge(DefinedTermBase arg0, boolean arg1) {
+ public List<MergeResult<DefinedTermBase>> merge(List<DefinedTermBase> arg0, boolean arg1) {
return defaultService.merge(arg0, arg1);
}
/* (non-Javadoc)
- * @see eu.etaxonomy.cdm.api.service.IService#merge(java.util.List, boolean)
+ * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase, boolean)
*/
@Override
- public List<DefinedTermBase> merge(List<DefinedTermBase> arg0, boolean arg1) {
+ public MergeResult<DefinedTermBase> merge(DefinedTermBase arg0, boolean arg1) {
return defaultService.merge(arg0, arg1);
}
+
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.api.service.IService#loadWithUpdate(java.util.UUID)
+ */
+ @Override
+ public DefinedTermBase loadWithUpdate(UUID arg0) {
+ return defaultService.loadWithUpdate(arg0);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Language getLanguageByLabel(String arg0) {
+ return defaultService.getLanguageByLabel(arg0);
+ }
+
}
@Override
public void merge() {
if(CdmStore.getCurrentSessionManager().isRemoting()) {
- List<SpecimenOrObservationBase> mergedEntities = CdmApplicationState.getCurrentAppConfig().getOccurrenceService().merge(new ArrayList(getRootEntities()), true);
+ CdmApplicationState.getCurrentAppConfig().getOccurrenceService().merge(new ArrayList(getRootEntities()), true);
}
}
excludeTaxa.add(actualTaxon.getUuid());
}
Classification classification = null;
+ TaxonNode actualNode = null;
if (actualTaxon != null){
if (!actualTaxon.getTaxonNodes().isEmpty() && actualTaxon.getTaxonNodes().size() ==1){
- classification = actualTaxon.getTaxonNodes().iterator().next().getClassification();
+ actualNode = actualTaxon.getTaxonNodes().iterator().next();
+ classification = actualNode.getClassification();
+
}
}
TaxonNode newAcceptedTaxonNode = TaxonNodeSelectionDialog.select(HandlerUtil.getActiveShell(event),
editor.getConversationHolder(),
"Choose the accepted taxon",
excludeTaxa,
- null,classification
+ null, classification
);
if (newAcceptedTaxonNode != null){
Taxon targetTaxon = newAcceptedTaxonNode.getTaxon();
* @return a {@link java.util.List} object.
*/
public List<Classification> getParentBeans() {
- List<String> propertyPaths = Arrays.asList(new String[]{"name"});
+ List<String> propertyPaths = Arrays.asList(new String[]{
+ "name",
+ "rootNode.childNodes"});
List<Classification> classifications = CdmStore.getService(IClassificationService.class).list(null, null, null, null, propertyPaths);
TaxonNode targetNode = (TaxonNode) targetITaxonTreeNode;
AbstractPostOperation operation = new MoveTaxonOperation
- ("Move Taxon", workspaceUndoContext, uuids, targetNode.getParent(), this, taxonNavigator, false);
+ ("Move Taxon", workspaceUndoContext, uuids, targetNode, this, taxonNavigator, false);
NavigationUtil.executeOperation(operation);
logger.info("Moved taxa to new parent " + targetITaxonTreeNode);
NavigationUtil.executeOperation(operation, null);
} else {
AbstractPostOperation operation = new MoveTaxonOperation
- ("Move Taxon", workspaceUndoContext, uuids, targetNode.getParent(), this, taxonNavigator, false);
+ ("Move Taxon", workspaceUndoContext, uuids, targetNode, this, taxonNavigator, false);
NavigationUtil.executeOperation(operation);
}
logger.info("Moved taxa to new parent " + targetITaxonTreeNode);
if (!result.getExceptions().isEmpty() && result.isOk()){
String separator = ", ";
String exceptionString = "";
+ int count = result.getExceptions().size();
+ int n = 0;
for (Exception exception : result.getExceptions()) {
- exceptionString += exception.getLocalizedMessage()+separator;
+ n++;
+ exceptionString += exception.getLocalizedMessage();
+ if (n<count){
+ exceptionString += separator;
+ }
}
- MessagingUtils.informationDialog("Synonym created but taxon is not deleted.", exceptionString);
+ MessagingUtils.informationDialog("Synonym created but taxon deletion not possible.", exceptionString);
} else if (result.isAbort() || result.isError()){
- MessagingUtils.errorDialog("Synonym could not created", null, result.toString(), TaxeditorNavigationPlugin.PLUGIN_ID, null, true);
+ MessagingUtils.errorDialog("Synonym creation not possible", null, result.toString(), TaxeditorNavigationPlugin.PLUGIN_ID, null, true);
}
} catch (IllegalArgumentException e) {
MessagingUtils.errorDialog("Operation failed", this, e.getMessage(), TaxeditorNavigationPlugin.PLUGIN_ID, e, false);
monitor.worked(20);
ICdmApplicationConfiguration controller = CdmStore.getCurrentApplicationConfiguration();
ITaxonNodeService service = controller.getTaxonNodeService();
- if(taxonNode != null && taxonNode instanceof TaxonNode){
- //((TaxonNode) treeNode).delete();
-
- element = ((TaxonNode)taxonNode).getTaxon();
-
- DeleteResult result = service.deleteTaxonNode((TaxonNode)taxonNode, config);
- if (result.isError() && !result.getExceptions().isEmpty()){
-
- DeleteResultMessagingUtils.messageDialogWithDetails(result, "TaxonNode could not be deleted.", TaxeditorNavigationPlugin.PLUGIN_ID);
- } else if (!result.getExceptions().isEmpty()){
- String separator = ", ";
- String exceptionString = "";
- for (Exception exception : result.getExceptions()) {
- exceptionString += exception.getLocalizedMessage()+separator;
- }
- DeleteResultMessagingUtils.messageDialogWithDetails(result, "TaxonNode was successfully deleted, but related object(s) could not be deleted", TaxeditorNavigationPlugin.PLUGIN_ID);
- }
+ if(taxonNode != null && taxonNode instanceof TaxonNode){
+ //((TaxonNode) treeNode).delete();
+
+ element = ((TaxonNode)taxonNode).getTaxon();
+
+ DeleteResult result = service.deleteTaxonNode((TaxonNode)taxonNode, config);
+ if (result.isError() && !result.getExceptions().isEmpty()){
+
+ DeleteResultMessagingUtils.messageDialogWithDetails(result, "TaxonNode could not be deleted.", TaxeditorNavigationPlugin.PLUGIN_ID);
+ } else if (!result.getExceptions().isEmpty()){
+ String separator = ", ";
+ String exceptionString = "";
+ for (Exception exception : result.getExceptions()) {
+ exceptionString += exception.getLocalizedMessage()+separator;
+ }
+ DeleteResultMessagingUtils.messageDialogWithDetails(result, "TaxonNode was successfully deleted, but related object(s) could not be deleted", TaxeditorNavigationPlugin.PLUGIN_ID);
+ }
- }else if(taxonNode != null && taxonNode instanceof Classification){
- Classification taxonomicTree = (Classification) taxonNode;
+ }else if(taxonNode != null && taxonNode instanceof Classification){
+ Classification taxonomicTree = (Classification) taxonNode;
- DeleteResult result = CdmStore.getService(IClassificationService.class).delete(taxonomicTree.getUuid());
- if (result.isError() && !result.getExceptions().isEmpty()){
- //TODO:Error message!
- DeleteResultMessagingUtils.messageDialogWithDetails(result, "TaxonNode could not be deleted.", TaxeditorNavigationPlugin.PLUGIN_ID);
- }
+ DeleteResult result = CdmStore.getService(IClassificationService.class).delete(taxonomicTree.getUuid());
+ if (result.isError() && !result.getExceptions().isEmpty()){
+ //TODO:Error message!
+ DeleteResultMessagingUtils.messageDialogWithDetails(result, "TaxonNode could not be deleted.", TaxeditorNavigationPlugin.PLUGIN_ID);
+ }
} else {
Set<UUID> treeNodeUuids = new HashSet<UUID>();
ITaxonTreeNode entity = null;
bind();
monitor.worked(20);
- UpdateResult result = CdmStore.getService(ITaxonNodeService.class).moveTaxonNodes(this.taxonNodesUuid,newParentTreeNode.getUuid());
+ UpdateResult result = CdmStore.getService(ITaxonNodeService.class).moveTaxonNodes(this.taxonNodesUuid,newParentTreeNode.getUuid(), moveToParentNode);
// try {
// for (TaxonNode taxonNode : taxonNodes){
// TaxonNode newTaxonNode = newParentTreeNode.addChildNode(taxonNode,
private final static String LABEL = "Move Taxon operation";
- private Set<UUID> taxonNodesToMoveUuid;
+ private final Set<UUID> taxonNodesToMoveUuid;
private final UUID newParentTreeNodeUuid;
private final boolean moveToParentNode;
@Override
protected UpdateResult doUpdateExecute(IProgressMonitor monitor, IAdaptable info) throws Exception {
return CdmApplicationState.getService(ITaxonNodeService.class).moveTaxonNodes(taxonNodesToMoveUuid,
- newParentTreeNodeUuid);
+ newParentTreeNodeUuid, moveToParentNode);
}
}
// $Id$
/**
* Copyright (C) 2007 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.
*/
import java.util.List;
-import org.eclipse.core.commands.ExecutionException;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ListViewer;
import eu.etaxonomy.cdm.api.service.DeleteResult;
import eu.etaxonomy.cdm.api.service.IFeatureTreeService;
-import eu.etaxonomy.cdm.api.service.exception.DataChangeNoRollbackException;
import eu.etaxonomy.cdm.model.description.FeatureTree;
import eu.etaxonomy.taxeditor.store.CdmStore;
-import eu.etaxonomy.taxeditor.store.StoreUtil;
/**
* <p>SelectFeatureTreeWizardPage class.</p>
super(pageName);
setMessage("Select a Feature Tree or create a new one.");
}
-
+
/* (non-Javadoc)
* @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite)
*/
@Override
public void createControl(Composite parent) {
Composite composite = new Composite(parent, SWT.NULL);
-
+
composite.setLayout(new GridLayout());
-
+
Composite composite_treeContent = new Composite(composite, SWT.NULL);
composite_treeContent.setLayoutData(new GridData(SWT.FILL, SWT.FILL,
true, true));
composite_treeContent.setLayout(new GridLayout(2, false));
-
+
viewer = new ListViewer(composite_treeContent);
viewer.getControl().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
-
+
button_remove = new Button(composite_treeContent, SWT.PUSH);
button_remove.setText("Remove");
button_remove.setLayoutData(new GridData(SWT.RIGHT, SWT.TOP, false, false));
-
+
Composite composite_treeTitle = new Composite(composite, SWT.NULL);
composite_treeTitle.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true,
false));
composite_treeTitle.setLayout(new GridLayout(3, false));
-
-
+
+
Label label_title = new Label(composite_treeTitle, SWT.NULL);
label_title.setText("New Feature Tree");
text_title = new Text(composite_treeTitle, SWT.NULL);
text_title.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));
-
+
button_add = new Button(composite_treeTitle, SWT.PUSH);
button_add.setText("Add");
-
+
viewer.setContentProvider(new FeatureTreeContentProvider());
viewer.setLabelProvider(new FeatureTreeLabelProvider());
-
+
viewer.addSelectionChangedListener(this);
-
+
text_title.addModifyListener(this);
button_add.addSelectionListener(new AddButtonSelectionListener());
button_remove.addSelectionListener(new RemoveButtonSelectionListener());
-
+
List<FeatureTree> input = CdmStore.getService(IFeatureTreeService.class).list(FeatureTree.class, null, null, null, null);
-
+
viewer.setInput(input);
modifyText(null);
setControl(composite);
@Override
public void selectionChanged(SelectionChangedEvent event) {
IStructuredSelection selection = (IStructuredSelection) event.getSelection();
-
+
if(selection.size() == 1){
FeatureTree selectedFeatureTree = (FeatureTree) selection.getFirstElement();
((FeatureTreeEditorWizard) getWizard()).setSelectedFeatureTree(selectedFeatureTree);
-
+
}
-
+
setPageComplete(true);
-
+
button_remove.setEnabled(selection.size() >= 1);
}
public boolean canFlipToNextPage() {
return ((IStructuredSelection) viewer.getSelection()).size() == 1;
}
-
+
/** {@inheritDoc} */
@Override
public void modifyText(ModifyEvent e) {
button_add.setEnabled(! text_title.getText().isEmpty());
}
-
+
private class AddButtonSelectionListener extends SelectionAdapter {
- public void widgetSelected(SelectionEvent e) {
+ @Override
+ public void widgetSelected(SelectionEvent e) {
FeatureTree featureTree = FeatureTree.NewInstance();
featureTree.setTitleCache(text_title.getText(), true);
-
+
viewer.add(featureTree);
- CdmStore.getService(IFeatureTreeService.class).saveOrUpdate(featureTree);
+ if(CdmStore.getCurrentSessionManager().isRemoting()) {
+ CdmStore.getService(IFeatureTreeService.class).merge(featureTree);
+ } else {
+ CdmStore.getService(IFeatureTreeService.class).saveOrUpdate(featureTree);
+ }
text_title.setText("");
viewer.setSelection(new StructuredSelection(featureTree));
-
+
}
}
-
+
private class RemoveButtonSelectionListener extends SelectionAdapter {
- public void widgetSelected(SelectionEvent e) {
+ @Override
+ public void widgetSelected(SelectionEvent e) {
IStructuredSelection selection = (IStructuredSelection) viewer.getSelection();
for(Object element : selection.toArray()){
viewer.remove(element);
-
- DeleteResult result = CdmStore.getService(IFeatureTreeService.class).delete((FeatureTree) element);
-
+
+ DeleteResult result = CdmStore.getService(IFeatureTreeService.class).delete(((FeatureTree) element).getUuid());
+
if (result.isError()){
-
+
}
viewer.setSelection(new StructuredSelection(new Object[0]));
}
while (objects.hasNext()){
CdmBase object = objects.next();
if (object instanceof IdentifiableEntity){
- relatedObjects.add("[" + object.getClass().getSimpleName() + "] " +((IdentifiableEntity)object).getTitleCache() );
+
+ relatedObjects.add(((IdentifiableEntity)object).getTitleCache() );
} else{
relatedObjects.add(object.getUserFriendlyTypeName());
}
for (String relatedObject: relatedObjects){
relatedObjectsString.append(relatedObject);
- relatedObjectsString.append("\n");
+ relatedObjectsString.append(System.lineSeparator());
}
}
message = message + "\n" ;
public NewDerivedUnitBaseWizard() {
super();
+ CdmStore.getCurrentSessionManager().bindNullSession();
}
public NewDerivedUnitBaseWizard(SpecimenOrObservationType specOrObsType) {
MessagingUtils.error(NewDerivedUnitBaseWizard.class, e);
}
}
+
return performFinish;
}
@Override
public void widgetSelected(SelectionEvent e) {
int selectionIndex = combo_globalLanguage.getSelectionIndex();
- globalLanguage = Language.getLanguageByLabel(combo_globalLanguage.getItem(selectionIndex));
+ globalLanguage = CdmStore.getCurrentApplicationConfiguration().getTermService().getLanguageByLabel(combo_globalLanguage.getItem(selectionIndex));
}
});
}
doAuthenticate(username, password);
} catch (CdmAuthenticationException e) {
MessagingUtils.warningDialog("Could not authenticate", this, e.getMessage());
+ return false;
}
return true;
}
*/
package eu.etaxonomy.taxeditor.ui.dialog;
+import java.text.SimpleDateFormat;
+import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import org.apache.commons.lang.StringUtils;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.osgi.service.prefs.BackingStoreException;
import org.osgi.service.prefs.Preferences;
+import eu.etaxonomy.cdm.api.application.CdmApplicationState;
+import eu.etaxonomy.cdm.model.metadata.CdmMetaData;
import eu.etaxonomy.taxeditor.model.MessagingUtils;
import eu.etaxonomy.taxeditor.remoting.server.CDMServerException;
import eu.etaxonomy.taxeditor.remoting.source.CdmRemoteSource;
private final static String STATUS_NO_INSTANCES = "No Instances Found";
private final static String STATUS_ERROR = "Error";
private final static String STATUS_REMOTING_NOT_ACTIVATED = "Remoting not activated";
+ private final static String STATUS_NOT_COMPATIBLE = "Not Compatible";
+
+ private final static String MESG_COMPATIBLE_EDITOR_OLD = "Please update the Taxonomic Editor (Help->Check for Updates) or choose a compatible cdm-server";
+ private final static String MESG_COMPATIBLE_SERVER_OLD = "Please choose a compatible cdm-server or update the chosen cdm-server";
+
private final static String STORE_PREFERENCES_NODE = "eu.etaxonomy.taxeditor.store";
private final static String LOGIN_NODE = "login";
private final int MIN_WIDTH = 530;
private final int MIN_HEIGHT = 220;
- private final int MIN_EXP_HEIGHT = 350;
+ private final int MIN_EXP_HEIGHT = 380;
private final int MESSAGE_HEIGHT = 25;
private Label lblEditorVersion;
private Text txtEditorVersion;
readPrefLastServerInstance();
}
+ setEditorInfo();
populateCdmServerCombo();
shlConnect.open();
shlConnect.layout();
lblServerVersion = new Label(compAdvanced, SWT.CENTER);
lblServerVersion.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, false, false, 1, 1));
- lblServerVersion.setText("Server Version :");
+ lblServerVersion.setText("Server Cdmlib Version :");
lblServerVersion.setFont(SWTResourceManager.getFont("Ubuntu", 9, SWT.NORMAL));
txtServerVersion = new Text(compAdvanced, SWT.BORDER);
- txtServerVersion.setEnabled(false);
txtServerVersion.setEditable(false);
txtServerVersion.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false, 1, 1));
new Label(compAdvanced, SWT.NONE);
lblEditorVersion = new Label(compAdvanced, SWT.CENTER);
lblEditorVersion.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, false, false, 1, 1));
- lblEditorVersion.setText("Editor Version :");
+ lblEditorVersion.setText("Editor Cdmlib Version :");
lblEditorVersion.setFont(SWTResourceManager.getFont("Ubuntu", 9, SWT.NORMAL));
txtEditorVersion = new Text(compAdvanced, SWT.BORDER);
- txtEditorVersion.setEnabled(false);
txtEditorVersion.setEditable(false);
txtEditorVersion.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
new Label(compAdvanced, SWT.NONE);
lblServerCDMVersion.setFont(SWTResourceManager.getFont("Ubuntu", 9, SWT.NORMAL));
txtServerCDMVersion = new Text(compAdvanced, SWT.BORDER);
- txtServerCDMVersion.setEnabled(false);
txtServerCDMVersion.setEditable(false);
txtServerCDMVersion.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
new Label(compAdvanced, SWT.NONE);
lblEditorCDMVersion.setFont(SWTResourceManager.getFont("Ubuntu", 9, SWT.NORMAL));
txtEditorCDMVersion = new Text(compAdvanced, SWT.BORDER);
- txtEditorCDMVersion.setEnabled(false);
txtEditorCDMVersion.setEditable(false);
txtEditorCDMVersion.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
private void checkSelectedCdmServer() {
- txtCdmInstanceStatus.setText("");
- txtPort.setEditable(false);
- txtPort.setEnabled(false);
+ clearOnServerChange();
emptyCredentials();
if(selectedCsii != null) {
if(selectedCsii.pingServer()) {
txtCdmServerStatus.setText(STATUS_AVAILABLE);
populateCdmInstanceCombo(true);
+ txtServerVersion.setText(selectedCsii.getCdmlibServicesVersion());
+ txtServerVersion.setToolTipText(generateLastModifiedTooltip(selectedCsii.getCdmlibLastModified()));
} else {
txtCdmServerStatus.setText(STATUS_NOT_AVAILABLE);
comboCdmInstance.setEnabled(false);
btnConnect.setEnabled(false);
txtCdmInstanceStatus.setText(STATUS_RETRIEVING);
+ txtCdmInstanceStatus.setToolTipText("");
Job job = new Job("Retrieve Server Instances") {
@Override
}
});
}
- } catch (CDMServerException e) {
+ } catch (final CDMServerException e) {
MessagingUtils.warn(getClass(), e);
Display.getDefault().asyncExec(new Runnable() {
@Override
public void run() {
- txtCdmInstanceStatus.setText(STATUS_REMOTING_NOT_ACTIVATED);
+ txtCdmInstanceStatus.setText(STATUS_NOT_AVAILABLE);
+ txtCdmInstanceStatus.setToolTipText(e.getMessage());
comboCdmInstance.setEnabled(false);
btnConnect.setEnabled(false);
}
private void refreshCdmInstance() {
txtCdmInstanceStatus.setText(STATUS_CHECKING_AVAILABILITY);
+ clearOnInstanceChange();
updateSelectedCdmInstance();
checkSelectedCdmInstance();
}
}
private void checkSelectedCdmInstance() {
+ boolean available = false;
+ String status = STATUS_NOT_AVAILABLE;
+ String message = null;
+
if(txtCdmServerStatus.getText().equals(STATUS_AVAILABLE)) {
try {
if(selectedCsii.pingInstance(selectedCdmInstance, getPort())) {
- txtCdmInstanceStatus.setText(STATUS_AVAILABLE);
- btnConnect.setEnabled(true);
+ status = STATUS_AVAILABLE;
+ available = true;
} else {
- txtCdmInstanceStatus.setText(STATUS_NOT_AVAILABLE);
- btnConnect.setEnabled(false);
+ status = STATUS_NOT_AVAILABLE;
+ available = false;
+ }
+
+ if(available) {
+ txtServerCDMVersion.setText(selectedCsii.getCdmRemoteSource(selectedCdmInstance, getPort()).getDbSchemaVersion());
+ int compareDbSchemaVersion = selectedCsii.compareDbSchemaVersion(selectedCdmInstance, getPort());
+ int compareCdmlibServicesVersion = selectedCsii.compareCdmlibServicesVersion();
+
+ if(compareDbSchemaVersion > 0 || compareCdmlibServicesVersion > 0) {
+ status = STATUS_NOT_COMPATIBLE;
+ available = false;
+ message = MESG_COMPATIBLE_EDITOR_OLD;
+ } else if(compareDbSchemaVersion < 0 || compareCdmlibServicesVersion < 0) {
+ status = STATUS_NOT_COMPATIBLE;
+ available = false;
+ message = MESG_COMPATIBLE_SERVER_OLD;
+ } else {
+ status = STATUS_AVAILABLE;
+ available = true;
+ message = "";
+ }
+
+
}
+
} catch (Exception e) {
- txtCdmInstanceStatus.setText(STATUS_NOT_AVAILABLE);
txtCdmInstanceStatus.setToolTipText(e.getMessage());
+ } finally {
+ btnConnect.setEnabled(available);
+ txtCdmInstanceStatus.setText(status);
+ if(!StringUtils.isBlank(message)) {
+ setMessage(message);
+ }
}
+
}
}
styledTxtMessage.setText(message);
styledTxtMessage.setVisible(true);
((GridData)styledTxtMessage.getLayoutData()).exclude = false;
- shlConnect.setSize(MIN_WIDTH, MIN_HEIGHT+MESSAGE_HEIGHT);
- shlConnect.setMinimumSize(MIN_WIDTH, MIN_HEIGHT+MESSAGE_HEIGHT);
+ shlConnect.setSize(MIN_WIDTH, getHeightWithoutMessage() + MESSAGE_HEIGHT);
+ shlConnect.setMinimumSize(MIN_WIDTH, getHeightWithoutMessage() + MESSAGE_HEIGHT);
} else {
styledTxtMessage.setText("");
styledTxtMessage.setVisible(false);
((GridData)styledTxtMessage.getLayoutData()).exclude = true;
- shlConnect.setSize(MIN_WIDTH, MIN_HEIGHT);
- shlConnect.setMinimumSize(MIN_WIDTH, MIN_HEIGHT);
+ shlConnect.setSize(MIN_WIDTH, getHeightWithoutMessage());
+ shlConnect.setMinimumSize(MIN_WIDTH, getHeightWithoutMessage());
}
remotingComposite.layout();
}
+ private int getHeightWithoutMessage() {
+ if(xpndblcmpstAdvanced.isExpanded()) {
+ return MIN_EXP_HEIGHT;
+ } else {
+ return MIN_HEIGHT;
+ }
+ }
public void hide(boolean isHidden) {
}
});
}
+
+ private String generateLastModifiedTooltip(String cdmlibLastModified) {
+ SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd 'at' HH:mm:ss z");
+ Date cdmlibLastModifiedDate;
+ String cdmlibLastModifiedTimestamp = "";
+
+ cdmlibLastModifiedDate = new Date(Long.valueOf(cdmlibLastModified));
+ cdmlibLastModifiedTimestamp = sdf.format(cdmlibLastModifiedDate);
+
+ return "last modified : " + cdmlibLastModifiedTimestamp;
+ }
+
+ private void setEditorInfo() {
+ txtEditorCDMVersion.setText(CdmMetaData.getDbSchemaVersion());
+ txtEditorVersion.setText(CdmApplicationState.getCdmlibVersion());
+ txtEditorVersion.setToolTipText(generateLastModifiedTooltip(CdmApplicationState.getCdmlibLastModified()));
+ }
+
+ private void clearOnServerChange() {
+ setMessage("");
+ txtServerCDMVersion.setText("");
+ txtServerVersion.setText("");
+ txtServerVersion.setToolTipText("");
+ txtServerCDMVersion.setText("");
+ txtPort.setEditable(false);
+ txtPort.setEnabled(false);
+ }
+
+ private void clearOnInstanceChange() {
+ setMessage("");
+ txtServerCDMVersion.setText("");
+ }
+
+ private void updateOnServerChange(String serverVersion, String serverVersionTooltip) {
+
+ }
+
}
this.settings = settings;
this.conversation = conversation;
-
+ this.cdmBaseToBeFiltered = cdmObject;
Cursor cursor = shell.getCursor();
shell.setCursor(shell.getDisplay().getSystemCursor(SWT.CURSOR_WAIT));
init();
/** {@inheritDoc} */
@Override
public void refresh() {
- //initModel();
+ initModel();
filterExcludedObjects();
super.refresh();
}
import eu.etaxonomy.cdm.api.service.IVocabularyService;
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
import eu.etaxonomy.cdm.model.common.CdmBase;
+import eu.etaxonomy.cdm.model.common.TermType;
import eu.etaxonomy.cdm.model.common.TermVocabulary;
import eu.etaxonomy.cdm.model.location.Country;
import eu.etaxonomy.cdm.model.location.NamedArea;
}
}
- private Collection<TermVocabulary<NamedArea>> selectedVocabularies;
+ private Collection<TermVocabulary> selectedVocabularies;
private ArrayList<TermVocabulary> preselectedVocabularies;
selectedVocabularies = getAvailableVocabularies();
}
- private List<TermVocabulary<NamedArea>> getAvailableVocabularies(){
- List<TermVocabulary<NamedArea>> vocabularies = CdmStore.getService(IVocabularyService.class).listByTermClass(NamedArea.class, null, null, null, null);
- vocabularies.add(CdmStore.getService(IVocabularyService.class).find(Country.uuidCountryVocabulary));
+ private List<TermVocabulary> getAvailableVocabularies(){
+ List<TermVocabulary> vocabularies = CdmStore.getService(IVocabularyService.class).listByTermType(TermType.NamedArea, true, null, null, null, null);
return vocabularies;
}
private List<Classification> classifications;
private Classification selectedClassification;
+ private final List<UUID> excludeTaxa;
protected TaxonNodeSelectionDialog(Shell shell, ConversationHolder conversation, String title, List<UUID> excludeTaxa, boolean multi, TaxonNode node, Classification classification) {
super(shell, conversation, title, multi, TaxonNodeSelectionDialog.class.getCanonicalName(), node);
setListLabelProvider(labelProvider);
setDetailsLabelProvider(labelProvider);
-
+ this.excludeTaxa = excludeTaxa;
if(classification != null){
selectedClassification = classification;
}
+ initModel();
}
/** {@inheritDoc} */
return o1.getTitleCache().compareTo(o2.getTitleCache());
}
});
- selectedClassification = classifications.iterator().next();
+ if (this.cdmBaseToBeFiltered == null){
+ selectedClassification = classifications.iterator().next();
+ } else {
+ selectedClassification = this.cdmBaseToBeFiltered.getClassification();
+ }
}
- model = CdmStore.getService(IClassificationService.class).getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(selectedClassification);
+ model = CdmStore.getService(IClassificationService.class).getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(selectedClassification, excludeTaxa);
}
/** {@inheritDoc} */
.getDefaultLanguage() }));
element_languageString.setLanguageString(preferredLanguageString);
+
if (PreferencesUtil.isMultilanguageTextEditingCapability()) {
- combo_language.setSelection(preferredLanguageString.getLanguage());
+ combo_language.setSelection(preferredLanguageString == null?CdmStore.getDefaultLanguage():preferredLanguageString.getLanguage());
button.setEnabled(true);
}
}
// change others passwords
CdmStore.getService(IUserService.class).changePasswordForUser(user.getUsername(), passwordPage.getNewPassword());
}
+ CdmStore.getService(IUserService.class).loadWithUpdate(user.getUuid());
internalConversation.commit(false);
internalConversation.unbind();
internalConversation.close();
return false;
}catch (AuthenticationException e){
MessagingUtils.warningDialog("Could not change password", this, "The old password is not correct.");
-
+
return false;
}catch(Exception e){
MessagingUtils.warningDialog("Problem with changing password", this, "The password could not be changed. " + e.getMessage());
selection_parentTaxonNode = formFactory
.createTaxonNodeSelectionElement(getConversationHolder(), formElement, "Parent", null,
EntitySelectionElement.DELETABLE, style);
- selection_SecRef = formFactory
- .createSelectionElement(Reference.class,getConversationHolder(), formElement, "Secundum Reference", null,
- EntitySelectionElement.DELETABLE, style);
+
selection_reuseExistingTaxon = formFactory
.createSelectionElement(Taxon.class,
getConversationHolder(), formElement,
getConversationHolder(), formElement,
"Reuse existing name", null,
EntitySelectionElement.DELETABLE, style);
-
+ selection_SecRef = formFactory
+ .createSelectionElement(Reference.class,getConversationHolder(), formElement, "Secundum Reference", null,
+ EntitySelectionElement.DELETABLE, style);
textNewTaxonName = formFactory.createTextWithLabelElement(formElement,
"New Taxon", "", style);
textNewTaxonName.setFocus();
selection_classification.setEntity(classification);
selection_parentTaxonNode.setEntity(null);
selection_parentTaxonNode.setClassification(classification);
+ selection_SecRef.setEntity(classification.getReference());
} else if (parentTreeNode instanceof TaxonNode) {
classification = (Classification) HibernateProxyHelper
.deproxy(((TaxonNode) parentTreeNode).getClassification());
selection_classification.setEntity(classification);
selection_parentTaxonNode.setEntity((TaxonNode) parentTreeNode);
selection_parentTaxonNode.setClassification(classification);
+ selection_SecRef.setEntity(((TaxonNode)parentTreeNode).getTaxon().getSec());
} else if(parentTreeNode == null){
this.parentTreeNode = selection_classification.getEntity();
}
private void setTaxon(Taxon taxon) {
this.taxon = taxon;
textNewTaxonName.setText(taxon.getName().getTitleCache());
- this.secReference = taxon.getSec();
+ selection_SecRef.setEntity(taxon.getSec());
}
private void setTaxon(String taxonNameString) {
if (getParentTreeNode() != null) {
if (this.secReference != null){
secundum = this.secReference;
- } else if (getParentTreeNode() instanceof Classification) {
+ } /*else if (getParentTreeNode() instanceof Classification) {
secundum = ((Classification) getParentTreeNode())
.getReference();
} else if (getParentTreeNode() instanceof TaxonNode) {
secundum = ((TaxonNode) getParentTreeNode()).getTaxon()
.getSec();
- }
+ }*/
}
if (taxonName != null){
taxon = Taxon.NewInstance(taxonName, secundum);
- textNewTaxonName.setText(taxonName.getTitleCache());
+ if (!taxonName.getTitleCache().trim().equals(textNewTaxonName.getText().trim())){
+ textNewTaxonName.setText(taxonName.getTitleCache());
+ }
} else {
textNewTaxonName.setText(null);
}
// FIXME due to a bug in the rest map service we have to ensure that width will always be an even number
// image.calculateWidth() % 2 == 1 ? image.calculateWidth() + 1 :
int width = image.calculateWidth();
-
+ IEditGeoService editGeoService;
List<Language> languages = Arrays.asList(new Language[]{CdmStore.getDefaultLanguage()});
-
- IEditGeoService editGeoService = ((CdmApplicationRemoteConfiguration)CdmStore.getCurrentApplicationConfiguration()).getEditGeoService();
+ if(CdmStore.getCurrentApplicationConfiguration() instanceof CdmApplicationRemoteConfiguration) {
+ editGeoService = ((CdmApplicationRemoteConfiguration)CdmStore.getCurrentApplicationConfiguration()).getEditGeoService();
+ }else{
+ editGeoService =(IEditGeoService) CdmStore.getCurrentApplicationConfiguration().getBean(
+ "editGeoService");
+ }
String parameter = editGeoService.getDistributionServiceRequestParameterString(
getTaxonDescriptions(),
false,
if (eventSource == element_question) {
getEntity().getParent().setQuestion(element_question.updateKeyStatement(getEntity().getQuestion()));
} else if (eventSource == element_statement) {
- getEntity().getParent().setStatement(element_statement.updateKeyStatement(getEntity().getStatement()));
+ getEntity().setStatement(element_statement.updateKeyStatement(getEntity().getStatement()));
} else if (eventSource == selection_feature) {
getEntity().getParent().setFeature(selection_feature.getEntity());
} else if (eventSource == selection_taxon) {
toggleable_cache.setVisible(false);
combo_nomenclaturalCode.setVisible(false);
}
-
+ textLsid = formFactory.createLsidWithExceptionLabelElement(formElement, "Lsid", entity.getLsid(), style);
section_name = formFactory.createNameDetailSection(getConversationHolder(), formElement, null, ExpandableComposite.TWISTIE | ExpandableComposite.EXPANDED);
section_name.setLayoutData(LayoutConstants.FILL_HORIZONTALLY(2, 1));
addControl(section_name);
addElement(section_hybrid);
}
- textLsid = formFactory.createLsidWithExceptionLabelElement(formElement, "Lsid", entity.getLsid(), style);
+
}
/** {@inheritDoc} */
// in a recursive call
PolytomousKey pkey1 = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH1_INIT_STRATEGY),PolytomousKey.class);
-
// checking to make sure the root object is in the session cache
- Assert.assertSame(pkey1.getRoot(), cacher.getFromCache(pkey1.getRoot()));
+ Assert.assertSame(CdmBase.deproxy(pkey1.getRoot(),PolytomousKeyNode.class), cacher.getFromCache(pkey1.getRoot()));
}
PolytomousKey pkey = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH2_INIT_STRATEGY),PolytomousKey.class);
CdmTransientEntityCacher cacher = getCacher(sessionOwner);
// checking to make sure the root object is in the session cache
- Assert.assertSame(pkey.getRoot(), cacher.getFromCache(pkey.getRoot()));
- Assert.assertSame(pkey.getRoot().getStatement(), cacher.getFromCache(pkey.getRoot().getStatement()));
- Assert.assertSame(pkey.getRoot().getQuestion(), cacher.getFromCache(pkey.getRoot().getQuestion()));
+ Assert.assertSame(CdmBase.deproxy(pkey.getRoot(),PolytomousKeyNode.class), cacher.getFromCache(pkey.getRoot()));
+ Assert.assertSame(CdmBase.deproxy(pkey.getRoot().getStatement(),KeyStatement.class), cacher.getFromCache(pkey.getRoot().getStatement()));
+ Assert.assertSame(CdmBase.deproxy(pkey.getRoot().getQuestion(),KeyStatement.class), cacher.getFromCache(pkey.getRoot().getQuestion()));
}
// |- statement : KeyStatement
PolytomousKey pkey1 = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH2_INIT_STRATEGY),PolytomousKey.class);
KeyStatement ks1 = pkey1.getRoot().getStatement();
- Assert.assertSame(cacher.getFromCache(pkey1.getRoot().getStatement()), pkey1.getRoot().getStatement());
+ Assert.assertSame(ks1, pkey1.getRoot().getStatement());
CdmTransientEntityCacher cacher = getCacher(sessionOwner);
// this call will load into the session cache the graph and update the objects in the sub-graph for a
// that it exists in the cache and
// that both the original object and the
// cached object are the same
- Assert.assertNotNull(pkey1.getRoot().getStatement());
+ Assert.assertNotNull(CdmBase.deproxy(pkey1.getRoot().getStatement(), KeyStatement.class));
Assert.assertNotNull(cacher.getFromCache(pkey1.getRoot().getStatement()));
// this call will load into the session cache the graph and update the objects in the sub-graph for a
PolytomousKey pkey2 = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH2_INIT_STRATEGY),PolytomousKey.class);
- Assert.assertSame(pkey2.getRoot().getStatement(), cacher.getFromCache(pkey2.getRoot().getStatement(), KeyStatement.class));
- Assert.assertSame(st, pkey2.getRoot().getStatement());
+ Assert.assertSame(CdmBase.deproxy(pkey2.getRoot().getStatement(), KeyStatement.class), cacher.getFromCache(pkey2.getRoot().getStatement(), KeyStatement.class));
+ Assert.assertSame(st, CdmBase.deproxy(pkey2.getRoot().getStatement(), KeyStatement.class));
Assert.assertSame(cacher.getFromCache(st), cacher.getFromCache(pkey2.getRoot().getStatement(), KeyStatement.class));
}
Taxon grandChildTaxon = Taxon.NewInstance(null, null);
TaxonNode grandChildTaxonNode = childTaxonNode.addChildTaxon(grandChildTaxon, null, null);
- CdmStore.getService(ITaxonNodeService.class).merge(taxonNode, true);
+ CdmStore.getService(ITaxonNodeService.class).merge(taxonNode,true);
Assert.assertEquals(taxonNode.getChildNodes().get(0).getId(), childTaxonNode.getId());
+
+ Assert.assertTrue(childTaxonNode.treeIndex() != null);
+ Assert.assertEquals(taxonNode.getChildNodes().get(0).treeIndex(), childTaxonNode.treeIndex());
+ Assert.assertFalse(childTaxon.getId() == 0);
Assert.assertEquals(taxonNode.getChildNodes().get(0).getTaxon().getId(), childTaxon.getId());
+
+ Assert.assertTrue(grandChildTaxonNode.treeIndex() != null);
Assert.assertEquals(taxonNode.getChildNodes().get(0).getChildNodes().get(0).getId(), grandChildTaxonNode.getId());
+ Assert.assertFalse(grandChildTaxon.getId() == 0);
Assert.assertEquals(taxonNode.getChildNodes().get(0).getChildNodes().get(0).getTaxon().getId(), grandChildTaxon.getId());
}
--- /dev/null
+// $Id$
+/**
+* Copyright (C) 2015 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.session;
+
+import org.junit.Test;
+import org.springframework.util.Assert;
+import org.unitils.UnitilsJUnit4;
+
+import eu.etaxonomy.cdm.api.application.CdmApplicationState;
+
+/**
+ * @author cmathew
+ * @date 5 Oct 2015
+ *
+ */
+public class CdmApplicationStateTest extends UnitilsJUnit4 {
+
+ @Test
+ public void testCdmlibManifestInfoUpdate() {
+ CdmApplicationState.updateCdmlibManifestInfo();
+ Assert.notNull(CdmApplicationState.getCdmlibVersion());
+ Assert.notNull(CdmApplicationState.getCdmlibLastModified());
+ }
+}
PolytomousKeyNode grandChildNode = PolytomousKeyNode.NewInstance();
rootChildNode.addChild(grandChildNode);
- pKey = polytomousKeyService.merge(pKey, true);
+ polytomousKeyService.merge(pKey, true);
grandChildNode = pKey.getRoot().getChildAt(0).getChildAt(0);
Assert.assertTrue(0 != grandChildNode.getId());
KeyStatement ks = KeyStatement.NewInstance("test");
grandChildNode.setStatement(ks);
- pKey = polytomousKeyService.merge(pKey, true);
+ polytomousKeyService.merge(pKey, true);
//grandChildNode = pKey.getRoot().getChildAt(0).getChildAt(0);
//KeyStatement ks = grandChildNode.getStatement();
}
}
- @Ignore // should be enabled once resolution of #5066 is merged into cdmlib main branch
@Test
public void saveNewTerm() {
UUID vocNameFeatureUuid = UUID.fromString("fa7ca3eef-4092-49e1-beec-ed5096193e5e");
import org.junit.Test;
import org.unitils.UnitilsJUnit4;
+import eu.etaxonomy.cdm.api.application.CdmApplicationState;
+import eu.etaxonomy.cdm.config.CdmSourceException;
import eu.etaxonomy.taxeditor.remoting.server.CDMServerException;
import eu.etaxonomy.taxeditor.remoting.source.CdmServerInfo;
import eu.etaxonomy.taxeditor.remoting.source.CdmServerInfo.CdmInstanceInfo;
Assert.assertTrue(instances != null && !instances.isEmpty());
}
+ @Test
+ public void compareCdmlibServicesVersionTest() throws CdmSourceException {
+ String editorVersion = CdmApplicationState.getCdmlibVersion();
+ String editorCdmlibLastModified = CdmApplicationState.getCdmlibLastModified();
+ Long editorCdmlibLastModifiedLong = Long.valueOf(editorCdmlibLastModified);
+
+ String[] editorVersionSplit = editorVersion.split("\\.");
+
+ Assert.assertEquals(0, CdmServerInfo.compareCdmlibServicesVersion(editorVersion, editorCdmlibLastModified));
+
+
+ int editorVersionMajor = Integer.valueOf(editorVersionSplit[0]);
+ int editorVersionMinor = Integer.valueOf(editorVersionSplit[1]);
+ int editorVersionPatch = Integer.valueOf(editorVersionSplit[2]);
+
+ String serverVersionMajorNew = String.valueOf(editorVersionMajor+1) + "." + String.valueOf(editorVersionMinor) + "." + String.valueOf(editorVersionPatch);
+ Assert.assertTrue(CdmServerInfo.compareCdmlibServicesVersion(serverVersionMajorNew, editorCdmlibLastModified) > 0);
+
+ String serverVersionMinorNew = String.valueOf(editorVersionMajor) + "." + String.valueOf(editorVersionMinor+1) + "." + String.valueOf(editorVersionPatch);
+ Assert.assertTrue(CdmServerInfo.compareCdmlibServicesVersion(serverVersionMinorNew, editorCdmlibLastModified) > 0);
+
+ String serverVersionPatchNew = String.valueOf(editorVersionMajor) + "." + String.valueOf(editorVersionMinor) + "." + String.valueOf(editorVersionPatch+1);
+ Assert.assertTrue(CdmServerInfo.compareCdmlibServicesVersion(serverVersionPatchNew, editorCdmlibLastModified) > 0);
+
+ String serverVersionMajorOld = String.valueOf(editorVersionMajor-1) + "." + String.valueOf(editorVersionMinor) + "." + String.valueOf(editorVersionPatch);
+ Assert.assertTrue(CdmServerInfo.compareCdmlibServicesVersion(serverVersionMajorOld, editorCdmlibLastModified) < 0);
+
+ String serverVersionMinorOld = String.valueOf(editorVersionMajor) + "." + String.valueOf(editorVersionMinor-1) + "." + String.valueOf(editorVersionPatch);
+ Assert.assertTrue(CdmServerInfo.compareCdmlibServicesVersion(serverVersionMinorOld, editorCdmlibLastModified) < 0);
+
+ String serverVersionPatchOld = String.valueOf(editorVersionMajor) + "." + String.valueOf(editorVersionMinor) + "." + String.valueOf(editorVersionPatch-1);
+ Assert.assertTrue(CdmServerInfo.compareCdmlibServicesVersion(serverVersionPatchOld, editorCdmlibLastModified) < 0);
+
+ String serverCdmlibLastModifiedNew = String.valueOf(editorCdmlibLastModifiedLong+1);
+ Assert.assertTrue(CdmServerInfo.compareCdmlibServicesVersion(editorVersion, serverCdmlibLastModifiedNew) > 0);
+
+ String serverCdmlibLastModifiedOld = String.valueOf(editorCdmlibLastModifiedLong-1);
+ Assert.assertTrue(CdmServerInfo.compareCdmlibServicesVersion(editorVersion, serverCdmlibLastModifiedOld) < 0);
+
+ }
+
@Test
public void convertToServerConfigTest() {
BGBM BDI Projects / taxeditor.git / commitdiff