package eu.etaxonomy.taxeditor;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.equinox.p2.core.IProvisioningAgent;
import org.eclipse.equinox.p2.engine.IProfileRegistry;
import org.eclipse.equinox.p2.operations.ProvisioningSession;
*/
public class TaxonomicEditorPlugin extends AbstractUIPlugin {
- private static final Logger logger = Logger.getLogger(TaxonomicEditorPlugin.class);
+ private static final Logger logger = LogManager.getLogger(TaxonomicEditorPlugin.class);
// The plug-in ID
/** Constant <code>PLUGIN_ID="eu.etaxonomy.taxeditor.application"</code> */
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
/**
* <p>Abstract EntityListener class.</p>
abstract public class EntityListener implements PropertyChangeListener {
@SuppressWarnings("unused")
- private static final Logger logger = Logger.getLogger(EntityListener.class);
+ private static final Logger logger = LogManager.getLogger(EntityListener.class);
@Override
public void propertyChange(PropertyChangeEvent evt) {
*/
package eu.etaxonomy.taxeditor.bulkeditor.command;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.expressions.PropertyTester;
import eu.etaxonomy.taxeditor.bulkeditor.e4.BulkEditor;
public class BulkEditorPropertyTester extends PropertyTester {
@SuppressWarnings("unused")
- private static final Logger logger = Logger.getLogger(BulkEditorPropertyTester.class);
+ private static final Logger logger = LogManager.getLogger(BulkEditorPropertyTester.class);
private static final String IS_MERGING_ENABLED = "isMergingEnabled";
import java.util.HashMap;
import java.util.Map;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import eu.etaxonomy.cdm.model.agent.Person;
import eu.etaxonomy.cdm.model.agent.Team;
*/
public class AgentCreator implements IEntityCreator<TeamOrPersonBase> {
- private static final Logger logger = Logger.getLogger(AgentCreator.class);
+ private static final Logger logger = LogManager.getLogger(AgentCreator.class);
@Override
public TeamOrPersonBase createEntity(String text) {
import java.util.LinkedHashMap;
import java.util.Map;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.wizard.WizardDialog;
IEntityCreator<SpecimenOrObservationBase> {
@SuppressWarnings("unused")
- private static final Logger logger = Logger.getLogger(OccurrenceCreator.class);
+ private static final Logger logger = LogManager.getLogger(OccurrenceCreator.class);
@Override
public SpecimenOrObservationBase createEntity(String text) {
import java.util.Collection;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.Viewer;
IStructuredContentProvider {
@SuppressWarnings("unused")
- private static final Logger logger = Logger.getLogger(ReferencingObjectsContentProvider.class);
+ private static final Logger logger = LogManager.getLogger(ReferencingObjectsContentProvider.class);
@Override
public Object[] getElements(Object inputElement) {
package eu.etaxonomy.taxeditor.bulkeditor.referencingobjects;
import org.apache.commons.lang3.StringUtils;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.swt.graphics.Image;
public class ReferencingObjectsLabelProvider extends LabelProvider implements ITableLabelProvider {
@SuppressWarnings("unused")
- private static final Logger logger = Logger.getLogger(ReferencingObjectsLabelProvider.class);
+ private static final Logger logger = LogManager.getLogger(ReferencingObjectsLabelProvider.class);
/**
* <p>Constructor for ReferencingObjectsLabelProvider.</p>
import javax.annotation.PreDestroy;
import org.apache.commons.lang3.StringUtils;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
*/
public class ReferencingObjectsViewE4 extends AbstractCdmEditorPartE4 implements IReferencingObjectsView{
- private static final Logger logger = Logger.getLogger(ReferencingObjectsViewE4.class);
+ private static final Logger logger = LogManager.getLogger(ReferencingObjectsViewE4.class);
private static final List<ReferencingObjectDto> EMPTY_LIST = Arrays.asList(); //immutable empty list
private static final RefObjectDtoComparator COMPARATOR = new RefObjectDtoComparator();
import java.util.Map;\r
\r
import org.apache.commons.lang3.StringUtils;\r
-import org.apache.log4j.Logger;\r
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;\r
import org.springframework.beans.BeansException;\r
import org.springframework.context.ApplicationContext;\r
import org.springframework.context.ApplicationContextAware;\r
public class CdmApplicationRemoteConfiguration implements ICdmRepository, ApplicationContextAware {\r
\r
@SuppressWarnings("unused")\r
- private static final Logger logger = Logger.getLogger(CdmApplicationRemoteConfiguration.class);\r
+ private static final Logger logger = LogManager.getLogger(CdmApplicationRemoteConfiguration.class);\r
\r
/**\r
* Timeout for service lookup etc. This timeout (milliseconds) should be more\r
import java.util.List;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.hibernate.collection.internal.AbstractPersistentCollection;
import org.hibernate.proxy.AbstractLazyInitializer;
import org.springframework.context.ApplicationListener;
*/
public class CdmApplicationRemoteController extends CdmApplicationController {
- private static final Logger logger = Logger.getLogger(CdmApplicationRemoteController.class);
+ private static final Logger logger = LogManager.getLogger(CdmApplicationRemoteController.class);
public static final Resource DEFAULT_REMOTE_APPLICATION_CONTEXT_RESOURCE =
new ClassPathResource("/eu/etaxonomy/cdm/remotingApplicationContext.xml");
import java.util.List;
import java.util.Properties;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.jdom.Attribute;
import org.jdom.Element;
implements ICdmPersistentSource{
@SuppressWarnings("unused")
- private static final Logger logger = Logger.getLogger(CdmPersistentRemoteSource.class);
+ private static final Logger logger = LogManager.getLogger(CdmPersistentRemoteSource.class);
public static final String REMOTESOURCE_BEAN_POSTFIX = "RemoteSource";
private String beanName;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.util.EntityUtils;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
*/
public class CdmServerInfo {
- public static final Logger logger = Logger.getLogger(CdmServerInfo.class);
+ public static final Logger logger = LogManager.getLogger(CdmServerInfo.class);
protected final static String CDMSERVER_PREFIX = "cdmserver/";
private final static String NAME_PRODUCTION = "cybertaxonomy.org";
import java.util.Map;
import java.util.Set;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.springframework.remoting.support.RemoteInvocation;
import org.springframework.remoting.support.RemoteInvocationResult;
public class RemoteInvocationTermCacher implements IRemoteInvocationTermCacher {
- private static final Logger logger = Logger.getLogger(RemoteInvocationTermCacher.class);
+ private static final Logger logger = LogManager.getLogger(RemoteInvocationTermCacher.class);
private static Map<TermType, RemoteInvocationResult> termTypeMap = new HashMap<>();
import java.util.Map;
import java.util.UUID;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import eu.etaxonomy.cdm.api.service.IService;
import eu.etaxonomy.cdm.api.service.UpdateResult;
*/
public class CdmEntitySession implements ICdmEntitySession {
- private static final Logger logger = Logger.getLogger(CdmEntitySession.class);
+ private static final Logger logger = LogManager.getLogger(CdmEntitySession.class);
private final CdmEntitySessionManager cdmEntitySessionManager;
import java.util.Map;
import java.util.Set;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.springframework.stereotype.Component;
import eu.etaxonomy.cdm.api.service.UpdateResult;
@Component
public class CdmEntitySessionManager implements ICdmEntitySessionManager {
- private static final Logger logger = Logger.getLogger(CdmEntitySessionManager.class);
+ private static final Logger logger = LogManager.getLogger(CdmEntitySessionManager.class);
private final Map<ICdmEntitySessionEnabled, ICdmEntitySession> ownerSessionMap = new HashMap<>();
*/
package eu.etaxonomy.taxeditor.session;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import eu.etaxonomy.cdm.api.application.CdmApplicationRemoteController;
import eu.etaxonomy.cdm.api.application.CdmApplicationState;
*/
public class DefaultNewEntityListener implements NewEntityListener {
- private static final Logger logger = Logger.getLogger(DefaultNewEntityListener.class);
+ private static final Logger logger = LogManager.getLogger(DefaultNewEntityListener.class);
@Override
public void onCreate(CdmBase cdmBase) {
import java.util.Set;
import org.aopalliance.intercept.MethodInvocation;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.springframework.remoting.support.RemoteInvocation;
import org.springframework.remoting.support.RemoteInvocationResult;
*/
public class CachingHttpInvokerProxyFactoryBean extends HttpInvokerProxyFactoryBean {
- private static final Logger logger = Logger.getLogger(CachingHttpInvokerProxyFactoryBean.class);
+ private static final Logger logger = LogManager.getLogger(CachingHttpInvokerProxyFactoryBean.class);
private static final String PROP_KEY_MEASURE_DURATION = "remoting.httpinvoker.measureDuration";
import java.util.Iterator;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
* @version 1.0
*/
public class RulerWithIcon implements IVerticalRuler, IVerticalRulerExtension {
- private static final Logger logger = Logger.getLogger(RulerWithIcon.class);
+ private static final Logger logger = LogManager.getLogger(RulerWithIcon.class);
/**
* Internal listener class.
import java.util.List;
import java.util.UUID;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.swt.dnd.ByteArrayTransfer;
import org.eclipse.swt.dnd.TransferData;
public class CdmDataTransfer extends ByteArrayTransfer {
@SuppressWarnings("unused")
- private static final Logger logger = Logger.getLogger(CdmDataTransfer.class);
+ private static final Logger logger = LogManager.getLogger(CdmDataTransfer.class);
private static int SEPARATOR = -10;
private static int EOF = -20;
package eu.etaxonomy.taxeditor.editor.internal;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.ui.plugin.AbstractUIPlugin;
import org.osgi.framework.BundleContext;
public class TaxeditorEditorPlugin extends AbstractUIPlugin {
/** Constant <code>logger</code> */
- public static final Logger logger = Logger.getLogger(TaxeditorEditorPlugin.class);
+ public static final Logger logger = LogManager.getLogger(TaxeditorEditorPlugin.class);
// The plug-in ID
/** Constant <code>PLUGIN_ID="eu.etaxonomy.taxeditor.editor"</code> */
package eu.etaxonomy.taxeditor.editor.name.container;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.resources.IMarker;
import org.eclipse.jface.text.Position;
import org.eclipse.jface.text.source.Annotation;
public class EditorAnnotation extends Annotation implements IAnnotationPresentation {
@SuppressWarnings("unused")
- private static final Logger logger = Logger.getLogger(EditorAnnotation.class);
+ private static final Logger logger = LogManager.getLogger(EditorAnnotation.class);
private final IMarker marker;
private String text;
private int line;
/**
* 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.
*/
package eu.etaxonomy.taxeditor.editor.name.container;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.jface.text.TextViewer;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.events.ModifyEvent;
* @created 19.05.2008
*/
public class LineWrapSupport {
- private static final Logger logger = Logger
- .getLogger(LineWrapSupport.class);
-
+ private static final Logger logger = LogManager.getLogger(LineWrapSupport.class);
+
ModifyListener listener = new LineWrapListener();
int lineCount;
private ScrolledForm scrolledForm;
// private TextViewer viewer;
-
+
/**
* <p>Constructor for LineWrapSupport.</p>
*
// return viewer;
// }
public LineWrapSupport(TextViewer viewer, IManagedForm form) {
-
+
if (viewer == null) {
throw new IllegalArgumentException(
"The provided TextViewer object is null."); //$NON-NLS-1$
}
-
+
// this.viewer = viewer;
-
+
textWidget = viewer.getTextWidget();
textWidget.addModifyListener(listener);
-
+
this.lineCount = textWidget.getLinePixel(textWidget.getLineCount());
this.scrolledForm = form.getForm();
-
+
logger.trace(this.getClass().getSimpleName() + " created"); //$NON-NLS-1$
}
-
+
/**
- * Redraws the scrolledForm if a line wrap is detected.
+ * Redraws the scrolledForm if a line wrap is detected.
*/
private void checkLineCount() {
scrolledForm.getBody().layout();
}
}
-
+
/**
* Calls <code>checkLineCount()</code> on a modify event.
- *
+ *
* @author p.ciardelli
* @created 21.05.2008
*/
class LineWrapListener implements ModifyListener {
- public void modifyText(ModifyEvent e) {
+ @Override
+ public void modifyText(ModifyEvent e) {
checkLineCount();
}
}
import java.util.Iterator;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
* @created 27.01.2009
*/
public class RulerWithIcon implements IVerticalRuler, IVerticalRulerExtension {
- private static final Logger logger = Logger.getLogger(RulerWithIcon.class);
+ private static final Logger logger = LogManager.getLogger(RulerWithIcon.class);
/**
* Internal listener class.
import javax.inject.Named;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.e4.core.di.annotations.CanExecute;
import org.eclipse.e4.core.di.annotations.Execute;
import org.eclipse.e4.ui.di.UISynchronize;
*/
public class ChangeSynonymToAcceptedTaxonHandlerE4 implements IPostOperationEnabled {
- private static final Logger logger = Logger.getLogger(ChangeSynonymToAcceptedTaxonHandlerE4.class);
+ private static final Logger logger = LogManager.getLogger(ChangeSynonymToAcceptedTaxonHandlerE4.class);
private TaxonNameEditorE4 editor;
private EPartService partService;
import javax.inject.Inject;
import javax.inject.Named;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.e4.core.di.annotations.CanExecute;
import org.eclipse.e4.core.di.annotations.Execute;
import org.eclipse.e4.ui.di.UISynchronize;
import eu.etaxonomy.taxeditor.ui.dialog.selection.TaxonNodeSelectionDialog;
public class MoveSynonymToAnotherAcceptedTaxonHandlerE4 implements IPostOperationEnabled{
- private static final Logger logger = Logger
- .getLogger(MoveSynonymToAnotherAcceptedTaxonHandlerE4.class);
+
+ private static final Logger logger = Logger.getLogger(MoveSynonymToAnotherAcceptedTaxonHandlerE4.class);
private TaxonNameEditorE4 editor;
UUID newSecUuid = null;
Reference synSecRef = synonym.getSec();
-
+
Reference parentSecRef = newParentNode.getTaxon() != null? newParentNode.getTaxon().getSec():null;
if ((synSecRef != parentSecRef && secHandling.equals(SecReferenceHandlingEnum.KeepOrWarn) )|| secHandling.equals(SecReferenceHandlingEnum.KeepOrSelect)){
package eu.etaxonomy.taxeditor.editor.validation;\r
\r
-import org.apache.log4j.Logger;\r
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;\r
import org.eclipse.core.runtime.IProgressMonitor;\r
import org.eclipse.ui.IMemento;\r
\r
public class ValidationContextListener implements IContextListener {\r
\r
@SuppressWarnings("unused")\r
- private static final Logger logger = Logger.getLogger(ValidationContextListener.class);\r
+ private static final Logger logger = LogManager.getLogger(ValidationContextListener.class);\r
\r
private ValidationDaemon daemon;\r
\r
\r
import java.util.List;\r
\r
-import org.apache.log4j.Logger;\r
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;\r
import org.eclipse.core.runtime.IProgressMonitor;\r
import org.eclipse.core.runtime.IStatus;\r
import org.eclipse.core.runtime.Status;\r
*/\r
public class ValidationDaemon extends Job {\r
@SuppressWarnings("unused")\r
- private static final Logger logger = Logger.getLogger(ValidationDaemon.class);\r
+ private static final Logger logger = LogManager.getLogger(ValidationDaemon.class);\r
\r
private final IEntityValidationService entityValidationService;\r
\r
import java.util.UUID;
import org.apache.commons.collections4.map.LinkedMap;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.layout.GridLayoutFactory;
import org.eclipse.jface.wizard.WizardDialog;
public class DistributionEditor extends Composite implements IDistributionEditor{
@SuppressWarnings("unused")
- private static final Logger logger = Logger.getLogger(DistributionEditor.class);
+ private static final Logger logger = LogManager.getLogger(DistributionEditor.class);
private static final String DISTRIBUTION_EDITOR = "Distribution Editor"; //$NON-NLS-1$
private static final String LOADING_TAXA = Messages.ChecklistEditor_LOAD_TAXA;
package eu.etaxonomy.taxeditor.editor.name.operation;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.commands.ExecutionException;
import org.junit.Assert;
import org.junit.BeforeClass;
* @created 07.04.2009
*/
public class ChangeConceptToSynonymOperationTest extends AbstractTaxeditorOperationTestBase {
- private static final Logger logger = Logger.getLogger(ChangeConceptToSynonymOperationTest.class);
+ private static final Logger logger = LogManager.getLogger(ChangeConceptToSynonymOperationTest.class);
private static Taxon taxon;
package eu.etaxonomy.taxeditor.editor.name.operation;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.commands.ExecutionException;
import org.junit.Assert;
import org.junit.BeforeClass;
*/
public class ChangeHomotypicGroupOperationTest extends AbstractTaxeditorOperationTestBase {
- private static final Logger logger = Logger.getLogger(ChangeHomotypicGroupOperationTest.class);
+ private static final Logger logger = LogManager.getLogger(ChangeHomotypicGroupOperationTest.class);
private static AbstractPostOperation<Taxon> operation;
/**
* 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.
*/
package eu.etaxonomy.taxeditor.editor.name.operation;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.commands.ExecutionException;
import org.junit.BeforeClass;
import org.junit.Test;
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
import eu.etaxonomy.cdm.model.taxon.Synonym;
import eu.etaxonomy.cdm.model.taxon.Taxon;
-import eu.etaxonomy.taxeditor.editor.name.operation.ChangeHomotypicalGroupBasionymOperation;
import eu.etaxonomy.taxeditor.store.operations.AbstractTaxeditorOperationTestBase;
/**
* @created 08.04.2009
*/
public class ChangeHomotypicalGroupBasionymOperationTest extends AbstractTaxeditorOperationTestBase {
- private static final Logger logger = Logger
- .getLogger(ChangeHomotypicalGroupBasionymOperationTest.class);
+
+ private static final Logger logger = Logger.getLogger(ChangeHomotypicalGroupBasionymOperationTest.class);
private static Synonym synonym;
private static HomotypicalGroup homotypicalGroup;
-
+
@BeforeClass
public static void setUpBeforeClass() throws Exception {
-
+
taxon = Taxon.NewInstance(null, null);
synonym = Synonym.NewInstance(null, null);
homotypicalGroup = HomotypicalGroup.NewInstance();
// FIXME homotypical group and basionym related methods are not implemented in the library
// wait till this gets done before implementing the test
-
+
operation = new ChangeHomotypicalGroupBasionymOperation("", undoContext, taxon, synonym, postOperation);
}
@Test
public void testExecuteIProgressMonitorIAdaptable() throws ExecutionException {
operation.execute(monitor, info);
-
+
logger.warn("Wating for functionality in library");
}
/**
* Test method for {@link eu.etaxonomy.taxeditor.editor.name.operation.ChangeHomotypicalGroupBasionymOperation#undo(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)}.
- * @throws ExecutionException
+ * @throws ExecutionException
*/
@Test
public void testUndoIProgressMonitorIAdaptable() throws ExecutionException {
operation.undo(monitor, info);
-
+
logger.warn("Wating for functionality in library");
}
/**
* Test method for {@link eu.etaxonomy.taxeditor.editor.name.operation.ChangeHomotypicalGroupBasionymOperation#redo(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)}.
- * @throws ExecutionException
+ * @throws ExecutionException
*/
@Test
public void testRedoIProgressMonitorIAdaptable() throws ExecutionException {
operation.redo(monitor, info);
-
+
logger.warn("Wating for functionality in library");
}
*/
package eu.etaxonomy.taxeditor.editor.name.operation;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.commands.ExecutionException;
import org.junit.Assert;
import org.junit.BeforeClass;
*/
public class ChangeSynonymToConceptOperationTest extends AbstractTaxeditorOperationTestBase{
- private static final Logger logger = Logger.getLogger(ChangeSynonymToConceptOperationTest.class);
+ private static final Logger logger = LogManager.getLogger(ChangeSynonymToConceptOperationTest.class);
private static TaxonRelationshipType taxonRelationshipType;
private static Synonym synonym;
package eu.etaxonomy.taxeditor.editor.name.operation;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
import eu.etaxonomy.cdm.model.taxon.Synonym;
import eu.etaxonomy.cdm.model.taxon.Taxon;
-import eu.etaxonomy.taxeditor.editor.name.operation.ChangeSynonymToHomotypicalGroupBasionymOperation;
import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;
public class ChangeSynonymToHomotypicalGroupBasionymOperationTest {
- private static final Logger logger = Logger
- .getLogger(ChangeSynonymToHomotypicalGroupBasionymOperationTest.class);
+
+ private static final Logger logger = Logger.getLogger(ChangeSynonymToHomotypicalGroupBasionymOperationTest.class);
// TODO move this to a superclass
public static final IProgressMonitor monitor = null;
- public static final IAdaptable info = null;
-
+ public static final IAdaptable info = null;
+
private static AbstractPostOperation operation;
private static Taxon taxon;
private static Synonym synonym;
-
+
private static Synonym basionym;
private static HomotypicalGroup homotypicalGroup;
-
+
@BeforeClass
public static void setUpBeforeClass() throws Exception {
taxon = Taxon.NewInstance(null, null);
synonym = Synonym.NewInstance(null, null);
basionym = Synonym.NewInstance(null, null);
homotypicalGroup = HomotypicalGroup.NewInstance();
-
+
// FIXME homotypical group and basionym related maethods are not implemented in the library
// wait till this gets done before implementing the test
-
+
operation = new ChangeSynonymToHomotypicalGroupBasionymOperation("Change Synonym To Basionym of Homotypical Group",
null, taxon, synonym);
}
@Test
public void testExecuteIProgressMonitorIAdaptable() throws ExecutionException {
operation.execute(monitor, info);
-
+
logger.warn("Wating for functionality in library");
}
@Test
public void testUndoIProgressMonitorIAdaptable() throws ExecutionException {
operation.undo(monitor, info);
-
+
logger.warn("Wating for functionality in library");
}
-
+
@Test
public void testRedoIProgressMonitorIAdaptable() throws ExecutionException {
operation.redo(monitor, info);
-
+
logger.warn("Wating for functionality in library");
}
*/
package eu.etaxonomy.taxeditor.editor.name.operation;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.commands.ExecutionException;
import org.junit.Assert;
import org.junit.BeforeClass;
*/
public class ChangeSynonymToMisapplicationOperationTest extends AbstractTaxeditorOperationTestBase {
- private static final Logger logger = Logger.getLogger(ChangeSynonymToMisapplicationOperationTest.class);
+ private static final Logger logger = LogManager.getLogger(ChangeSynonymToMisapplicationOperationTest.class);
private static AbstractPostOperation<Taxon> operation;
*/
package eu.etaxonomy.taxeditor.editor.name.operation;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.commands.ExecutionException;
import org.junit.Assert;
import org.junit.BeforeClass;
*/
public class CreateConceptRelationOperationTest extends AbstractTaxeditorOperationTestBase {
- private static final Logger logger = Logger.getLogger(CreateConceptRelationOperationTest.class);
+ private static final Logger logger = LogManager.getLogger(CreateConceptRelationOperationTest.class);
private static TaxonRelationshipType taxonRelationshipType;
private static Taxon concept;
-
+/**
+ * Copyright (C) 2010 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.editor.name.operation;
-import junit.framework.Assert;
-
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
+import org.junit.Assert;
import org.eclipse.core.commands.ExecutionException;
import org.junit.BeforeClass;
import org.junit.Test;
import eu.etaxonomy.taxeditor.store.operations.AbstractTaxeditorOperationTestBase;
public class CreateDescriptionElementOperationTest extends AbstractTaxeditorOperationTestBase {
- private static final Logger logger = Logger
- .getLogger(CreateDescriptionElementOperationTest.class);
+ private static final Logger logger = Logger.getLogger(CreateDescriptionElementOperationTest.class);
private static TaxonDescription description;
*/
package eu.etaxonomy.taxeditor.editor.name.operation;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.commands.ExecutionException;
import org.junit.Assert;
import org.junit.BeforeClass;
*/
public class DeleteConceptRelationOperationTest extends AbstractTaxeditorOperationTestBase{
- private static final Logger logger = Logger.getLogger(DeleteConceptRelationOperationTest.class);
+ private static final Logger logger = LogManager.getLogger(DeleteConceptRelationOperationTest.class);
private static TaxonRelationshipType relationshipType;
private static Taxon relatedTaxon;
*/
package eu.etaxonomy.taxeditor.editor.name.operation;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.commands.ExecutionException;
import org.junit.Assert;
import org.junit.BeforeClass;
*/
public class DeleteMisapplicationOperationTest extends AbstractTaxeditorOperationTestBase{
- private static final Logger logger = Logger.getLogger(DeleteMisapplicationOperationTest.class);
+ private static final Logger logger = LogManager.getLogger(DeleteMisapplicationOperationTest.class);
private static Taxon taxon;
private static Taxon misapplication;
* 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.editor.name.operation;
-import org.apache.log4j.Logger;
import org.eclipse.core.commands.ExecutionException;
import org.junit.Assert;
import org.junit.BeforeClass;
* @created 08.04.2009
*/
public class DeleteSynonymOperationTest extends AbstractTaxeditorOperationTestBase{
- @SuppressWarnings("unused")
- private static final Logger logger = Logger
- .getLogger(DeleteSynonymOperationTest.class);
- private static Synonym synonym;
+ private static Synonym synonym;
private static SynonymType synonymType;
package eu.etaxonomy.taxeditor.editor.name.operation;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
+
import org.eclipse.core.commands.ExecutionException;
import org.junit.Assert;
import org.junit.BeforeClass;
* @created 02.04.2009
*/
public class SwapSynonymAndAcceptedOperationTest extends AbstractTaxeditorOperationTestBase {
- private static final Logger logger = Logger
- .getLogger(SwapSynonymAndAcceptedOperationTest.class);
+
+ private static final Logger logger = Logger.getLogger(SwapSynonymAndAcceptedOperationTest.class);
private static SwapSynonymAndAcceptedOperation operation;
import javax.management.remote.JMXServiceURL;
import org.apache.commons.lang3.StringUtils;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jetty.server.Server;
*/
public class CdmServer {
- public static final Logger logger = Logger.getLogger(CdmServer.class);
+ public static final Logger logger = LogManager.getLogger(CdmServer.class);
//TODO use the constants defined in eu.etaxonomy.cdm.opt.config.DataSourceConfigurer
private static final String ATTRIBUTE_FORCE_SCHEMA_CREATE = "cdm.forceSchemaCreate";
import java.util.List;
import org.apache.commons.lang3.StringUtils;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
*/
public class RemotingLoginDialogLocal extends RemotingLoginDialog {
- private Logger logger = Logger.getLogger(getClass());
+ private Logger logger = LogManager.getLogger(getClass());
// protected Shell shlConnect;
// private Text txtCdmServerStatus;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
@Inject
private UISynchronize sync;
- private static final Logger logger = Logger.getLogger(CdmDataSourceViewPartE4.class);
+ private static final Logger logger = LogManager.getLogger(CdmDataSourceViewPartE4.class);
private class ContextListener extends ContextListenerAdapter{
@Override
* 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.navigation;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.jface.action.ContributionItem;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.IContributionManager;
*
* @author p.ciardelli
* @created 23.04.2009
- * @version 1.0
*/
public class RecentNamesContributionItem extends ContributionItem {
+
//FIXME E4 migrate recent menu items
- private static final Logger logger = Logger
- .getLogger(RecentNamesContributionItem.class);
+ private static final Logger logger = Logger.getLogger(RecentNamesContributionItem.class);
private IContributionItem recentWindows;
private IContributionManager parent;
* 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.navigation;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
+
import org.eclipse.core.commands.operations.IUndoContext;
import org.eclipse.core.commands.operations.UndoContext;
import org.eclipse.core.runtime.IAdapterFactory;
-
/**
- * <p>WorkbenchUndoContextAdapterFactory class.</p>
- *
* @author p.ciardelli
* @created 04.06.2009
- * @version 1.0
*/
public class WorkbenchUndoContextAdapterFactory implements IAdapterFactory {
- private static final Logger logger = Logger
- .getLogger(WorkbenchUndoContextAdapterFactory.class);
+
+ private static final Logger logger = Logger.getLogger(WorkbenchUndoContextAdapterFactory.class);
private UndoContext defaultUndoContext;
private static final Class[] ADAPTER_LIST = new Class[] { IUndoContext.class };
- /* (non-Javadoc)
- * @see org.eclipse.core.runtime.IAdapterFactory#getAdapter(java.lang.Object, java.lang.Class)
- */
- /** {@inheritDoc} */
@Override
public Object getAdapter(Object adaptableObject, Class adapterType) {
// if (IUndoContext.class.equals(adapterType)) {
return null;
}
- /**
- * @return
- */
private Object getDefaultUndoContext() {
if (defaultUndoContext == null) {
defaultUndoContext = new UndoContext();
return defaultUndoContext;
}
- /* (non-Javadoc)
- * @see org.eclipse.core.runtime.IAdapterFactory#getAdapterList()
- */
- /**
- * <p>getAdapterList</p>
- *
- * @return an array of {@link java.lang.Class} objects.
- */
@Override
public Class[] getAdapterList() {
return ADAPTER_LIST;
}
-}
+}
\ No newline at end of file
import javax.inject.Inject;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.commands.operations.IUndoContext;
import org.eclipse.e4.ui.workbench.modeling.EPartService;
import org.eclipse.jface.dialogs.MessageDialog;
protected static final String DO_YOU_WANT_TO_MOVE_THE_TAXONNODE_AS_CHILD_OR_BEHIND_THE_TARGET_NODE = Messages.TreeNodeDropAdapter_MOVE_BEHIND;
protected static final String TARGET_NODE = Messages.TreeNodeDropAdapter_TARGET_NODE;
- private static final Logger logger = Logger.getLogger(TreeNodeDropAdapterE4.class);
+ private static final Logger logger = LogManager.getLogger(TreeNodeDropAdapterE4.class);
private TaxonNavigatorE4 taxonNavigator;
UpdateResult result;
import java.util.UUID;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.e4.ui.model.application.MApplication;
implements IPostMoniteredOperationEnabled{
@SuppressWarnings("unused")
- private static final Logger logger = Logger.getLogger(SetPublishForSubtreeOperation.class);
+ private static final Logger logger = LogManager.getLogger(SetPublishForSubtreeOperation.class);
private final static String LABEL = Messages.SetPublishForSubtreeOperation_CHANGE_PUBLISH_OP;
import java.util.UUID;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.e4.ui.model.application.MApplication;
private final static String LABEL = Messages.SetSecundumForSubtreeOperation_CHANGE_SEC_OP;
@SuppressWarnings("unused")
- private static final Logger logger = Logger.getLogger(SetSecundumForSubtreeOperation.class);
+ private static final Logger logger = LogManager.getLogger(SetSecundumForSubtreeOperation.class);
public SetSecundumForSubtreeOperation(Object source, boolean async, UUID taxonNodeUuid, EPartService partService,
MPart activePart, MApplication application, EModelService modelService, SecundumForSubtreeConfigurator config) {
import java.util.ArrayList;
import java.util.List;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
* @since Sep 24, 2020
*/
public class SearchPluginHandler {
- private Logger logger = Logger.getLogger(getClass());
+ private Logger logger = LogManager.getLogger(getClass());
private UpdateOperation operation;
import java.net.URI;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
*/
public class UpdateHandler {
- private Logger logger = Logger.getLogger(getClass());
+ private Logger logger = LogManager.getLogger(getClass());
private UpdateOperation operation;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
extends AbstractIOManager<IExportConfigurator>
implements IPostMoniteredOperationEnabled {
- private static final Logger logger = Logger.getLogger(ExportManager.class);
+ private static final Logger logger = LogManager.getLogger(ExportManager.class);
/** Constant <code>DATE_FORMAT_NOW="yyyyMMddHHmm"</code> */
public static final String DATE_FORMAT_NOW = "yyyyMMddHHmm";
import javax.inject.Inject;
import org.apache.commons.io.IOUtils;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.e4.core.contexts.ContextInjectionFactory;
import org.eclipse.e4.core.contexts.IEclipseContext;
private ImportFromFileAndChooseVocIdWizardPageE4 dataSourcePage;
- private static final Logger logger = Logger.getLogger(ExcelDistributionUpdateWizardE4.class);
+ private static final Logger logger = LogManager.getLogger(ExcelDistributionUpdateWizardE4.class);
@Inject
public ExcelDistributionUpdateWizardE4(IEclipseContext context, EPartService partService) {
import javax.inject.Named;
import org.apache.commons.io.IOUtils;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.e4.core.contexts.ContextInjectionFactory;
import org.eclipse.e4.core.contexts.IEclipseContext;
private NormalExplicitImportConfigurator configurator;
private ImportFromFileDataSourceWithReferenceWizardPage dataSourcePage;
- private static final Logger logger = Logger.getLogger(ExcelNormalExplicitTaxaImportWizardE4.class);
+ private static final Logger logger = LogManager.getLogger(ExcelNormalExplicitTaxaImportWizardE4.class);
@Inject
public ExcelNormalExplicitTaxaImportWizardE4(IEclipseContext context, EPartService partService,
import javax.inject.Inject;
import org.apache.commons.io.IOUtils;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.e4.core.contexts.ContextInjectionFactory;
import org.eclipse.e4.core.contexts.IEclipseContext;
private ImportFromFileDataSourceWithReferenceWizardPage dataSourcePage;
- private static final Logger logger = Logger.getLogger(ExcelDistributionUpdateWizardE4.class);
+ private static final Logger logger = LogManager.getLogger(ExcelDistributionUpdateWizardE4.class);
@Inject
public RISImportWizardE4(IEclipseContext context, EPartService partService) {
import java.util.zip.ZipOutputStream;
import org.apache.commons.lang3.StringUtils;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.operations.AbstractOperation;
import org.eclipse.core.commands.operations.IOperationHistory;
*/
public abstract class AbstractUtility {
- protected static final Logger logger = Logger.getLogger(AbstractUtility.class);
+ protected static final Logger logger = LogManager.getLogger(AbstractUtility.class);
/** Constant <code>statusLineManager</code> */
protected static IStatusLineManager statusLineManager;
import java.util.List;
import org.apache.commons.lang3.exception.ExceptionUtils;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Platform;
* @return a {@link org.apache.log4j.Logger} object.
*/
public static Logger getLog4JLogger(Class<?> clazz) {
- return Logger.getLogger(clazz);
+ return LogManager.getLogger(clazz);
}
/**
import java.util.ArrayList;
import java.util.List;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import eu.etaxonomy.cdm.api.service.INameService;
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
*/
public class ParseHandler{
- public static final Logger logger = Logger.getLogger(ParseHandler.class);
+ public static final Logger logger = LogManager.getLogger(ParseHandler.class);
private static NonViralNameParserImpl nonViralNameParser = NonViralNameParserImpl.NewInstance();
import java.util.Map;
import java.util.UUID;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import eu.etaxonomy.cdm.api.application.ICdmRepository;
import eu.etaxonomy.cdm.api.service.ITermService;
private static CdmPreferenceCache instance;
- private final static Logger logger = Logger.getLogger(CdmPreferenceCache.class);
+ private final static Logger logger = LogManager.getLogger(CdmPreferenceCache.class);
public static CdmPreferenceCache instance(){
if(instance == null){
import java.util.UUID;
import org.apache.commons.lang3.StringUtils;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.runtime.preferences.ConfigurationScope;
import org.eclipse.core.runtime.preferences.IEclipsePreferences;
import org.eclipse.equinox.internal.p2.ui.model.MetadataRepositoryElement;
- private final static Logger logger = Logger.getLogger(PreferencesUtil.class);
+ private final static Logger logger = LogManager.getLogger(PreferencesUtil.class);
public static IPreferenceStore getPreferenceStore() {
return TaxeditorStorePlugin.getDefault().getPreferenceStore();
import java.util.Observable;
import java.util.Set;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.ui.IMemento;
import org.springframework.security.authentication.BadCredentialsException;
*/
public class LoginManager extends Observable implements IConversationEnabled, IContextListener{
- public static final Logger logger = Logger.getLogger(LoginManager.class);
+ public static final Logger logger = LogManager.getLogger(LoginManager.class);
private ConversationHolder conversation;
import java.util.Map;
import org.apache.commons.lang3.StringUtils;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
*/
public class RemotingLoginDialog extends Dialog implements ICdmServerError {
- private Logger logger = Logger.getLogger(getClass());
+ private Logger logger = LogManager.getLogger(getClass());
public static final String DEFAULT_PASS = "00000"; //$NON-NLS-1$
public static final String DEFAULT_USER = "admin"; //$NON-NLS-1$
* 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.ui.section.description;
import java.util.List;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
+
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
*
* @author n.hoffmann
* @created Sep 16, 2010
- * @version 1.0
*/
public class NaturalLanguageDetailElement extends AbstractCdmDetailElement<TaxonDescription> {
+ private static final Logger logger = Logger.getLogger(NaturalLanguageDetailElement.class);
- private static final Logger logger = Logger
- .getLogger(NaturalLanguageDetailElement.class);
private LabelElement label;
/**
import java.util.UUID;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.springframework.security.core.GrantedAuthority;
import eu.etaxonomy.cdm.api.service.IAgentService;
public class GrantedAuthorityLabelTextProvider {
- public static final Logger logger = Logger.getLogger(CdmAuthority.class);
+ public static final Logger logger = LogManager.getLogger(CdmAuthority.class);
public static String getText(GrantedAuthority grantedAuthority){
import java.util.Comparator;
import java.util.List;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.swt.SWT;
import eu.etaxonomy.cdm.model.metadata.PreferencePredicate;
extends AbstractIdentifiableEntityDetailElement<INonViralName>
implements ISelectableElement {
- private final Logger logger = Logger.getLogger(NameDetailElement.class);
+ private final Logger logger = LogManager.getLogger(NameDetailElement.class);
private SelectionArbitrator selectionArbitrator;
*/
package eu.etaxonomy.taxeditor.ui.section.occurrence.dna;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import eu.etaxonomy.cdm.api.facade.DerivedUnitFacade;
import eu.etaxonomy.cdm.api.service.IVocabularyService;
public class TissueSampleGeneralDetailElement extends AbstractCdmDetailElement<DerivedUnitFacade> {
@SuppressWarnings("unused")
- static private final Logger logger = Logger.getLogger(TissueSampleGeneralDetailElement.class);
+ static private final Logger logger = LogManager.getLogger(TissueSampleGeneralDetailElement.class);
private final TermVocabulary<?> plantKindOfUnitVocabulary = CdmStore.getService(IVocabularyService.class).find(VocabularyEnum.PlantKindOfUnit.getUuid());
import java.util.Map;\r
import java.util.Set;\r
\r
-import org.apache.log4j.Logger;\r
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;\r
import org.eclipse.swt.events.SelectionEvent;\r
import org.eclipse.swt.events.SelectionListener;\r
\r
AbstractCdmDetailElement<CategoricalData> implements SelectionListener {\r
\r
@SuppressWarnings("unused")\r
- private static final Logger logger = Logger.getLogger(UseRecordDetailElement.class);\r
+ private static final Logger logger = LogManager.getLogger(UseRecordDetailElement.class);\r
\r
private TermComboElement<State> combo_UseCategory;\r
private TermComboElement<State> combo_UseSubCategory;\r
import java.util.List;
import java.util.UUID;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.runtime.SubMonitor;
import org.springframework.remoting.RemoteAccessException;
* @date 23 Oct 2015
*/
public class ProgressMonitorClientManager {
- private static final Logger logger = Logger.getLogger(ProgressMonitorClientManager.class);
+ private static final Logger logger = LogManager.getLogger(ProgressMonitorClientManager.class);
/**
* Polls the progress monitor service for the progress status of a monitor
import java.util.Collection;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
import eu.etaxonomy.cdm.ext.occurrence.OccurenceQuery;
*/
public abstract class DataImportEditorInput<T> {
- protected static Logger logger = Logger.getLogger(DataImportEditorInput.class);
+ protected static Logger logger = LogManager.getLogger(DataImportEditorInput.class);
private Collection<T> results;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.e4.ui.di.Focus;
import org.eclipse.jface.viewers.CheckboxTableViewer;
public abstract class DataImportView<T> implements IPartContentHasFactualData,
IConversationEnabled, IPartContentHasDetails, IPartContentHasSupplementalData, IContextListener, Listener, IEditorAreaPart{
- protected final Logger logger = Logger.getLogger(DataImportView.class);
+ protected final Logger logger = LogManager.getLogger(DataImportView.class);
protected Collection<T> results = new ArrayList<>();
import javax.inject.Inject;
import javax.inject.Named;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.e4.core.contexts.IEclipseContext;
import org.eclipse.e4.core.di.annotations.Optional;
import org.eclipse.e4.ui.di.PersistState;
public abstract class AbstractCdmEditorPartE4
implements IConversationEnabled, IDirtyMarkable, ISelectionElementEditingPart, IPostOperationEnabled{
- private static final Logger logger = Logger.getLogger(AbstractCdmEditorPartE4.class);
+ private static final Logger logger = LogManager.getLogger(AbstractCdmEditorPartE4.class);
private DelaySelection delaySelection = null;
/**
import java.util.Set;
import java.util.UUID;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.junit.Assert;
import org.junit.Test;
import org.unitils.dbunit.annotation.DataSet;
public class CdmClientCachingTest extends RemotingSessionAwareTest {
@SuppressWarnings("unused")
- private static final Logger logger = Logger.getLogger(CdmClientCachingTest.class);
+ private static final Logger logger = LogManager.getLogger(CdmClientCachingTest.class);
private final UUID polytomousKeyUuid = UUID.fromString("0d53ba20-7de4-4baa-bd8a-401048447d66");
private final UUID polytomousKeyNodeUuid1 = UUID.fromString("75e4c924-ff58-4ee7-a59d-fd9173517d08");
import java.lang.reflect.Field;
import java.util.Map;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.junit.BeforeClass;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
@SpringApplicationContext("file:./target/classes/eu/etaxonomy/cdm/testRemotingApplicationContext.xml")
public abstract class BaseRemotingTest extends ThreadedTest {
@SuppressWarnings("unused")
- private static final Logger logger = Logger.getLogger(BaseRemotingTest.class);
+ private static final Logger logger = LogManager.getLogger(BaseRemotingTest.class);
private static ICdmRemoteSource cdmRemoteSource;
private static CdmPersistentRemoteSource remotePersistentSource;
*/
package eu.etaxonomy.taxeditor.httpinvoker;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.junit.Assert;
import org.junit.Test;
import org.springframework.remoting.RemoteAccessException;
import eu.etaxonomy.taxeditor.remoting.source.CdmRemoteSource;
public class CdmRemoteSourceTest extends BaseRemotingTest {
- private static final Logger logger = Logger.getLogger(RemotePersistentCollectionTest.class);
+ private static final Logger logger = LogManager.getLogger(RemotePersistentCollectionTest.class);
@Test
import java.net.URISyntaxException;
import java.net.URL;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Platform;
import org.junit.Assert;
public class CdmServerTest extends TestConfig {
@SuppressWarnings("unused")
- private static final Logger logger = Logger.getLogger(CdmServerTest.class);
+ private static final Logger logger = LogManager.getLogger(CdmServerTest.class);
@Test
public void generateConfigFile() throws IOException {
*/
package eu.etaxonomy.taxeditor.httpinvoker;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;
* Class to test the HttpInvoker services exposed by the CDM Sever
*/
public class HttpInvokerServicesTest extends BaseRemotingTest {
- private static final Logger logger = Logger.getLogger(HttpInvokerServicesTest.class);
+ private static final Logger logger = LogManager.getLogger(HttpInvokerServicesTest.class);
ITestService testService = getRemoteApplicationController().getTestService();
import java.util.UUID;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.junit.After;
import org.junit.Before;
import org.springframework.security.core.userdetails.UserDetails;
*/
public abstract class RemotingSessionAwareTest extends BaseRemotingTest {
- private static final Logger logger = Logger.getLogger(RemotingSessionAwareTest.class);
+ private static final Logger logger = LogManager.getLogger(RemotingSessionAwareTest.class);
protected ConversationalTransientEntityCacher cacher;
protected MockSessionOwner sessionOwner;
import java.net.URL;
import java.util.Properties;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Platform;
import org.junit.BeforeClass;
*/
public abstract class TestConfig extends UnitilsJUnit4 {
- private static final Logger logger = Logger.getLogger(TestConfig.class);
+ private static final Logger logger = LogManager.getLogger(TestConfig.class);
private final static String DEFAULT_USER = "admin";
private final static String DEFAULT_PASSWORD = "00000";
import java.util.Set;
import java.util.UUID;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Ignore;
@Ignore
@DataSet
public class AbstractLazyInitializerTest extends BaseRemotingTest {
- private static final Logger logger = Logger.getLogger(AbstractLazyInitializerTest.class);
+ private static final Logger logger = LogManager.getLogger(AbstractLazyInitializerTest.class);
private static IClassificationService classificationService;
private static ITaxonService taxonService;
*/
package eu.etaxonomy.taxeditor.lazyloading;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.junit.Assert;
import org.junit.Test;
public class CdmServiceCacherTest extends RemotingSessionAwareTest {
@SuppressWarnings("unused")
- private static final Logger logger = Logger.getLogger(CdmServiceCacherTest.class);
+ private static final Logger logger = LogManager.getLogger(CdmServiceCacherTest.class);
private static CdmServiceCacher cdmServiceCacher = CdmApplicationState.getCdmServiceCacher();
import java.util.Set;
import java.util.UUID;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Ignore;
@Ignore
public class RemoteLazyLoadingTest extends BaseRemotingTest {
- private static final Logger logger = Logger.getLogger(RemoteLazyLoadingTest.class);
+ private static final Logger logger = LogManager.getLogger(RemoteLazyLoadingTest.class);
private static IClassificationService classificationService;
private static ITaxonService taxonService;
import java.util.Map;
import java.util.Set;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Ignore;
//Could be combined with AbstractLazyInitializerTest
@Ignore
public class RemotePersistentCollectionTest extends BaseRemotingTest {
- private static final Logger logger = Logger.getLogger(RemotePersistentCollectionTest.class);
+ private static final Logger logger = LogManager.getLogger(RemotePersistentCollectionTest.class);
private static IClassificationService classificationService;
private static ICommonService commonService;
import java.util.Set;
import java.util.UUID;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.commands.ExecutionException;
import org.junit.Assert;
import org.junit.BeforeClass;
public class RemotingCdmUpdateOperationTest extends BaseOperationTest {
@SuppressWarnings("unused")
- private static final Logger logger = Logger.getLogger(RemotingCdmUpdateOperationTest.class);
+ private static final Logger logger = LogManager.getLogger(RemotingCdmUpdateOperationTest.class);
private static ITaxonNodeService taxonNodeService = getRemoteApplicationController().getTaxonNodeService();
import java.util.Set;
import java.util.UUID;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.commands.ExecutionException;
import org.junit.Assert;
import org.junit.Ignore;
public class TaxonNameEditorTest extends BaseOperationTest {
@SuppressWarnings("unused")
- private static final Logger logger = Logger.getLogger(TaxonNameEditorTest.class);
+ private static final Logger logger = LogManager.getLogger(TaxonNameEditorTest.class);
ITaxonNodeService taxonNodeService = getRemoteApplicationController().getTaxonNodeService();
ITaxonService taxonService = getRemoteApplicationController().getTaxonService();
import java.util.Set;
import java.util.UUID;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.commands.ExecutionException;
import org.junit.Assert;
import org.junit.Ignore;
public class TaxonNavigatorTest extends BaseOperationTest {
@SuppressWarnings("unused")
- private static final Logger logger = Logger.getLogger(TaxonNameEditorTest.class);
+ private static final Logger logger = LogManager.getLogger(TaxonNameEditorTest.class);
ITaxonNodeService taxonNodeService = getRemoteApplicationController().getTaxonNodeService();
ITaxonService taxonService = getRemoteApplicationController().getTaxonService();
import java.util.List;
import java.util.UUID;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.SubMonitor;
import org.junit.After;
*/
public class ProgressMonitorServiceTest extends RemotingSessionAwareTest {
- private static final Logger logger = Logger.getLogger(ProgressMonitorServiceTest.class);
+ private static final Logger logger = LogManager.getLogger(ProgressMonitorServiceTest.class);
ITestService testService = getRemoteApplicationController().getTestService();
import java.util.List;
import java.util.UUID;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.junit.Assert;
import org.junit.Test;
public class ServiceInterceptorTest extends RemotingSessionAwareTest {
- private static final Logger logger = Logger.getLogger(ServiceInterceptorTest.class);
+ private static final Logger logger = LogManager.getLogger(ServiceInterceptorTest.class);
private final ITermService termService = getRemoteApplicationController().getTermService();
private static CdmServiceCacher cdmServiceCacher = CdmApplicationState.getCdmServiceCacher();
import java.util.Set;
import java.util.UUID;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Ignore;
public class CdmEntitySessionAwareTest extends RemotingSessionAwareTest {
@SuppressWarnings("unused")
- private static final Logger logger = Logger.getLogger(CdmEntitySessionAwareTest.class);
+ private static final Logger logger = LogManager.getLogger(CdmEntitySessionAwareTest.class);
UUID polytomousKeyUuid = UUID.fromString("0d53ba20-7de4-4baa-bd8a-401048447d66");
UUID subKeyUuid = UUID.fromString("9d8bf4f6-a70a-4b80-8556-2ccfb436ff01");
import java.util.List;
import java.util.UUID;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
public class CdmEntitySessionManagerTest extends RemotingSessionAwareTest {
@SuppressWarnings("unused")
- private static final Logger logger = Logger.getLogger(CdmEntitySessionManagerTest.class);
+ private static final Logger logger = LogManager.getLogger(CdmEntitySessionManagerTest.class);
IPolytomousKeyService polytomousKeyService = getRemoteApplicationController().getPolytomousKeyService();
IPolytomousKeyNodeService polytomousKeyNodeService = getRemoteApplicationController().getPolytomousKeyNodeService();
import java.util.Map;
import java.util.Set;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.junit.Assert;
import eu.etaxonomy.cdm.api.application.CdmChangeEvent;
public class MockSessionOwner<T extends CdmBase>
implements ICdmEntitySessionEnabled<T>, ICdmChangeListener {
- private static final Logger logger = Logger.getLogger(MockSessionOwner.class);
+ private static final Logger logger = LogManager.getLogger(MockSessionOwner.class);
private final List<T> rootEntities;
private Set<T> expectedUpdatedObjects;
import java.io.IOException;
import java.net.URL;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.e4.core.di.annotations.Execute;
/**
* @created 04.09.2009
*/
public class OpenExternalAboutPlatformHandler {
- private static final Logger logger = Logger.getLogger(OpenExternalAboutPlatformHandler.class);
+ private static final Logger logger = LogManager.getLogger(OpenExternalAboutPlatformHandler.class);
@Execute
public Object execute() {
import java.io.IOException;
import java.net.URL;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.e4.core.di.annotations.Execute;
/**
*/
public class OpenExternalParserHelpHandler {
- private static final Logger logger = Logger.getLogger(OpenExternalParserHelpHandler.class);
+ private static final Logger logger = LogManager.getLogger(OpenExternalParserHelpHandler.class);
@Execute
/** {@inheritDoc} */
import javax.inject.Named;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtensionRegistry;
private static final String ATT_CLASS = "class"; //$NON-NLS-1$
private static final String EXTENSION_ELEMENT_PAGE = "page"; //$NON-NLS-1$
private static final String EXTENSION_POINT_ID = "eu.etaxonomy.taxeditor.store.adminPreferencePage"; //$NON-NLS-1$
- private Logger logger = Logger.getLogger(OpenAdminPreferencesHandler.class);
+ private Logger logger = LogManager.getLogger(OpenAdminPreferencesHandler.class);
@Execute
public void execute(@Named(IServiceConstants.ACTIVE_SHELL)Shell shell) {
import javax.inject.Named;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtensionRegistry;
private static final String ATT_CLASS = "class"; //$NON-NLS-1$
private static final String EXTENSION_ELEMENT_PAGE = "page"; //$NON-NLS-1$
private static final String EXTENSION_POINT_ID = "eu.etaxonomy.taxeditor.store.preferencePage"; //$NON-NLS-1$
- private Logger logger = Logger.getLogger(OpenPreferencesHandler.class);
+ private Logger logger = LogManager.getLogger(OpenPreferencesHandler.class);
@Execute
public void execute(@Named(IServiceConstants.ACTIVE_SHELL)Shell shell) {
BGBM BDI Projects / taxeditor.git / commitdiff