/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at
* trunk/opends/resource/legal-notices/OpenDS.LICENSE
* or https://OpenDS.dev.java.net/OpenDS.LICENSE.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at
* trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable,
* add the following below this CDDL HEADER, with the fields enclosed
* by brackets "[]" replaced with your own identifying information:
* Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*
*
* Copyright 2008-2010 Sun Microsystems, Inc.
*/
package org.opends.guitools.controlpanel.ui;
import static org.opends.messages.AdminToolMessages.*;
import java.io.IOException;
import java.io.StringReader;
import java.util.ArrayList;
import javax.swing.SwingUtilities;
import org.opends.guitools.controlpanel.browser.BrowserController;
import org.opends.guitools.controlpanel.event.ConfigurationChangeEvent;
import org.opends.guitools.controlpanel.task.NewEntryTask;
import org.opends.guitools.controlpanel.task.Task;
import org.opends.guitools.controlpanel.ui.nodes.BasicNode;
import org.opends.guitools.controlpanel.util.BackgroundTask;
import org.opends.guitools.controlpanel.util.Utilities;
import org.opends.messages.Message;
import org.opends.server.types.Entry;
import org.opends.server.types.LDIFImportConfig;
import org.opends.server.util.LDIFException;
import org.opends.server.util.LDIFReader;
/**
* Abstract class used to re-factor some code among the different panels that
* are used to create a new entry.
*
*/
public abstract class AbstractNewEntryPanel extends StatusGenericPanel
{
private static final long serialVersionUID = 6894546787832469213L;
/**
* The parent node that was selected when the user clicked on the new entry
* action.
*/
protected BasicNode parentNode;
/**
* The browser controller.
*/
protected BrowserController controller;
/**
* Sets the parent and the browser controller for this panel.
* @param parentNode the selected parent node (or <CODE>null</CODE> if no
* parent node was selected).
* @param controller the browser controller.
*/
public void setParent(BasicNode parentNode, BrowserController controller)
{
this.parentNode = parentNode;
this.controller = controller;
}
/**
* Returns the title for the progress dialog.
* @return the title for the progress dialog.
*/
protected abstract Message getProgressDialogTitle();
/**
* Returns the LDIF representation of the new entry.
* @return the LDIF representation of the new entry.
*/
protected abstract String getLDIF();
/**
* Updates the list of errors by checking the syntax of the entry.
* @param errors the list of errors that must be updated.
*/
protected abstract void checkSyntax(ArrayList<Message> errors);
/**
* Returns <CODE>true</CODE> if the syntax of the entry must be checked in
* the background and <CODE>false</CODE> otherwise.
* @return <CODE>true</CODE> if the syntax of the entry must be checked in
* the background and <CODE>false</CODE> otherwise.
*/
protected boolean checkSyntaxBackground()
{
return false;
}
/**
* {@inheritDoc}
*/
public void okClicked()
{
final ArrayList<Message> errors = new ArrayList<Message>();
if (checkSyntaxBackground())
{
BackgroundTask<Void> worker = new BackgroundTask<Void>()
{
public Void processBackgroundTask()
{
try
{
Thread.sleep(2000);
}
catch (Throwable t)
{
}
checkSyntax(errors);
return null;
}
public void backgroundTaskCompleted(Void returnValue, Throwable t)
{
if (t != null)
{
errors.add(ERR_CTRL_PANEL_UNEXPECTED_DETAILS.get(t.toString()));
}
displayMainPanel();
setEnabledCancel(true);
setEnabledOK(true);
handleErrorsAndLaunchTask(errors);
}
};
displayMessage(INFO_CTRL_PANEL_CHECKING_SUMMARY.get());
setEnabledCancel(false);
setEnabledOK(false);
worker.startBackgroundTask();
}
else
{
checkSyntax(errors);
handleErrorsAndLaunchTask(errors);
}
}
/**
* Checks that there are not errors in the list and launches a new entry
* task.
* @param errors the list of errors.
*/
private void handleErrorsAndLaunchTask(ArrayList<Message> errors)
{
Entry entry = null;
if (errors.size() == 0)
{
try
{
entry = getEntry();
}
catch (Throwable t)
{
// Unexpected error: getEntry() should work after calling checkSyntax
throw new RuntimeException("Unexpected error: "+t, t);
}
String dn = entry.getDN().toString();
// Checking for the existence of an entry is fast enough so we can do
// it on the event thread.
if (entryExists(dn))
{
errors.add(ERR_CTRL_PANEL_ENTRY_ALREADY_EXISTS.get(dn));
}
}
if (errors.size() == 0)
{
final ProgressDialog dlg = new ProgressDialog(
Utilities.createFrame(), Utilities.getParentDialog(this),
getProgressDialogTitle(), getInfo());
try
{
NewEntryTask newTask =
new NewEntryTask(getInfo(), dlg, entry, getLDIF(),
parentNode, controller);
for (Task task : getInfo().getTasks())
{
task.canLaunch(newTask, errors);
}
if (errors.size() == 0)
{
launchOperation(newTask,
INFO_CTRL_PANEL_CREATING_NEW_ENTRY_SUMMARY.get(),
INFO_CTRL_PANEL_CREATING_NEW_ENTRY_SUCCESSFUL_SUMMARY.get(),
INFO_CTRL_PANEL_CREATING_NEW_ENTRY_SUCCESSFUL_DETAILS.get(),
ERR_CTRL_PANEL_CREATING_NEW_ENTRY_ERROR_SUMMARY.get(),
ERR_CTRL_PANEL_CREATING_NEW_ENTRY_ERROR_DETAILS.get(),
null,
dlg);
dlg.setVisible(true);
Utilities.getParentDialog(this).setVisible(false);
SwingUtilities.invokeLater(new Runnable()
{
public void run()
{
dlg.toFront();
}
});
}
}
catch (Throwable t)
{
// Unexpected error: getEntry() should work after calling checkSyntax
throw new RuntimeException("Unexpected error: "+t, t);
}
}
if (errors.size() > 0)
{
displayErrorDialog(errors);
}
}
/**
* {@inheritDoc}
*/
public void configurationChanged(ConfigurationChangeEvent ev)
{
updateErrorPaneIfServerRunningAndAuthRequired(ev.getNewDescriptor(),
INFO_CTRL_PANEL_NEW_ENTRY_REQUIRES_SERVER_RUNNING.get(),
INFO_CTRL_PANEL_NEW_ENTRY_REQUIRES_AUTHENTICATION.get());
}
/**
* Returns the entry object representing what the user provided as data.
* @return the entry object representing what the user provided as data.
* @throws LDIFException if there is an error with the LDIF syntax.
* @throws IOException if there is an error creating the internal stream.
*/
protected Entry getEntry() throws LDIFException, IOException
{
Entry entry;
LDIFImportConfig ldifImportConfig = null;
try
{
String ldif = getLDIF();
if (ldif.trim().length() == 0)
{
throw new LDIFException(ERR_LDIF_REPRESENTATION_REQUIRED.get());
}
ldifImportConfig = new LDIFImportConfig(new StringReader(ldif));
LDIFReader reader = new LDIFReader(ldifImportConfig);
entry = reader.readEntry(checkSchema());
if (entry == null)
{
throw new LDIFException(ERR_LDIF_REPRESENTATION_REQUIRED.get());
}
else
{
if (entry.getObjectClasses().size() == 0)
{
throw new LDIFException(ERR_OBJECTCLASS_FOR_ENTRY_REQUIRED.get());
}
}
}
finally
{
if (ldifImportConfig != null)
{
ldifImportConfig.close();
}
}
return entry;
}
/**
* Returns <CODE>true</CODE> if the schema must be checked and
* <CODE>false</CODE> otherwise.
* @return <CODE>true</CODE> if the schema must be checked and
* <CODE>false</CODE> otherwise.
*/
protected boolean checkSchema()
{
return getInfo().getServerDescriptor().isSchemaEnabled();
}
}