/** Writes the data currently in the table editor to the directory. */
public void writeTableData() {
myEditor.stopCellEditing();
if (dataSource == null) // if ds is null, data is not modifiable...
{
CBUtility.error("no datasource to write data to in writeTableData()");
return;
} // shouldn't happen
DXEntry oldEntry = tableData.getOldEntry();
DXEntry newEntry = tableData.getNewEntry();
/* Check to see if major surgery is needed - whether the user has been
* messing with the object class list. */
if (classChangedOriginalEntry != null) {
// use the saved state of the pre-class-changed entry as the 'old entry'
// state.
oldEntry = classChangedOriginalEntry;
classChangedOriginalEntry =
null; // this is only used once! (either the object class change will
// now succeed, or fail - either way, the entry state is reset to
// match what's in the directory.)
if (objectClassesChanged(oldEntry, newEntry)) {
oldEntry.removeEmptyAttributes();
newEntry.setStatus(oldEntry.getStatus());
Object[] delSet =
CBArray.difference(oldEntry.toIDStringArray(), newEntry.toIDStringArray());
/* if there *are* attributes that should no longer exist, delete them by adding them (blanked)
* to the complete 'newAtts' set of *all* known attributes. */
if ((delSet != null) && (delSet.length > 0)) {
for (int i = 0; i < delSet.length; i++) {
newEntry.put(
new DXAttribute(
delSet[i].toString())); // overwrite old values with an empty attribute
}
}
}
}
dataSource.modifyEntry(oldEntry, newEntry);
}
/**
* Clear out all the old editors, and get new editors corresponding to the new object classes.
*
* @param entry the entry to be displayed by all the editors
* @param ds the datasource the editors may use for more info
* @param ocs the object classes (in order) to find editors for.
*/
protected void setEditors(DXEntry entry, DataBrokerQueryInterface ds, Vector ocs) {
try {
clearPluggableEditors(); // clear all extra editors
// search for unique structural editors...
if ("false".equalsIgnoreCase(JXConfig.getProperty("plugins.ignoreUniqueness"))) {
if (ocs == null) // TE: may happen if virtual entry.
return;
int size = ocs.size();
for (int i = 0; i < size; i++) {
Object objectClass = ocs.get(i);
if (objectClass != null) {
PluggableEditor ed = getEditor(objectClass.toString());
if (ed != null && ed.isUnique() == true) // found a unique editor
{ // so clear old ones,
addUniqueEditor(ed); // and use the unique one
refreshEditors(entry, ds); // to display the data
setCurrentEditor(ed);
return; // ... and exit.
}
}
}
} else log.warning("skipping uniqueness test for pluggable editors");
boolean newEdSet = false;
// search for non-unique structural editors
for (int i = 0; i < ocs.size(); i++) {
Object objectClass = ocs.get(i);
if (objectClass != null) {
PluggableEditor ed = getEditor(objectClass.toString());
if (ed != null) {
addEditor(ed);
// Force the displayed editor to be the first pluggable one...
if (newEdSet == false) {
setCurrentEditor(ed);
newEdSet = true;
}
}
}
}
// search for non-structural editors
try {
Attribute allOCs = entry.getAllObjectClasses();
if (allOCs != null) {
Enumeration vals = allOCs.getAll();
while (vals.hasMoreElements()) {
Object oc = vals.nextElement();
if (oc != null) {
String ocName = oc.toString();
if (ocs.contains(ocName)
== false) // don't bother with struct objectclasses dealt with above
{
PluggableEditor ed = getEditor(ocName);
if (ed != null) {
addEditor(ed);
if (ed.isUnique()) // a special service to users...
log.warning(
"WARNING: Illegal unique editor defined for oc: "
+ ocName
+ " not allowed - (oc not in primary structural inheritance chain)");
}
}
}
}
}
} catch (NamingException e) {
log.log(
Level.WARNING,
"WARNING: non-fatal exception getting object classes for plugin editors. ",
e);
}
addEditor(templateDisplay); // and always add old faithfulls...
// XXX
if (entry.getStatus() != DXEntry.NEW) // well, almost always...
addEditor(tableDisplay);
} catch (Exception e) {
log.warning("Unexpected Exception in AttributeDisplay\n" + e);
e.printStackTrace();
}
}
private void displayEntry(
DXEntry entry, DataBrokerQueryInterface ds, boolean storeOriginalEntry) {
myEditor.stopCellEditing();
// checkedDN = null; // hack - resets promptForSave.
// Store original Entry for reset
if (entry != null && storeOriginalEntry && entry.getStatus() == DXEntry.NORMAL)
originalEntry = new DXEntry(entry);
// Set the globals...
currentEntry = entry;
dataSource = ds;
if (entry != null && entry.size() == 0) {
// If there is an entry and its size is zero - it's probably a virtual entry.
// We need to give the user the option of adding an object class to it i.e. so that
// it can be added to the directory as a real entry.
//
// Disable all the buttons except the 'Change Class' button - but rename this button
// to 'Add Class' so the user hopefully has a bit more of an idea about what is going on.
// Sets editor to a blank screen...
tableData.clear();
// Disable all buttons except the 'Change Class' button - rename this one...
submit.setEnabled(false);
reset.setEnabled(false);
changeClass.setText(CBIntText.get("Add Class"));
changeClass.setEnabled(true);
opAttrs.setEnabled(false);
virtualEntry = true;
return;
}
virtualEntry = false;
// Isn't a virtual entry...
if (entry != null) currentDN = entry.getDN();
// May have been changed to 'Add Class'...
changeClass.setText(CBIntText.get("Change Class"));
// Some quick faffing around, to see if we're coming back from a
// change classes operation.
if (classChangedOriginalEntry != null) {
// If they have the same name, then we're reviewing the same entry - otherwise we've moved on
if (entry == null || entry.getDN().equals(classChangedOriginalEntry.getDN()) == false)
classChangedOriginalEntry = null;
}
/*
* Check that we're not displaying a new entry, and leaving unsaved changes
* behind.
*
* This turns out to be quite tricky, and involves a bunch 'o special cases.
*
* First check whether the table data has changed (if not, do nothing)
* -> if the new entry is null, prompt user to save
* -> OR if the DN has changed, and it wasn't due to a rename, prompt user to save
*
*/
if (tableData.changedByUser()) // user made changes - were they saved? (i.e., are we
{ // displaying the result of those changes?)
boolean prompt = false;
DXEntry oldEntry = tableData.getOldEntry();
if (oldEntry != null) {
/*
* The code below is simply checking to see if the name of the
* new entry is different from the old entry, and if it is,
* whether that's due to the old entry being renamed.
*/
if (entry == null) {
prompt = true;
}
// TE: added the isEmpty check see bug: 3194.
else if (!oldEntry.getDN().isEmpty() && entry.getDN().equals(oldEntry.getDN()) == false) {
DN oldParent = oldEntry.getDN().getParent();
DN newParent = entry.getDN().getParent();
if (oldParent.equals(newParent) == false) {
prompt = true;
} else {
if (entry.getDN().getLowestRDN().equals(tableData.getRDN()) == false) {
prompt = true;
}
}
}
if (prompt) // yes, there is a risk of data loss - prompt the user.
{
checkForUnsavedChanges(); // see if the user wants to save their data
}
}
}
myEditor.setDataSource(
ds); // Sets the DataBrokerQueryInterface in AttributeValueCellEditor used to get the syntax
// of attributes.
// only enable buttons if DataBrokerQueryInterface
// is valid *and* we can modify data...
if (dataSource == null || entry == null || dataSource.isModifiable() == false) {
setReadWrite(false, entry);
} else {
setReadWrite(true, entry);
}
// myEditor.stopCellEditing();
if (entry != null) {
entry.expandAllAttributes();
currentDN = entry.getDN();
tableData.insertAttributes(entry);
popupTableTool.setDN(currentDN); // Sets the DN in SmartPopupTableTool.
myEditor.setDN(
currentDN); // Sets the DN in the attributeValueCellEditor which can be used to identify
// the entry that is being modified/
} else {
tableData.clear(); // Sets editor to a blank screen.
}
tableScroller.getVerticalScrollBar().setValue(0); // Sets the scroll bar back to the top.
}
public void displayEntry(DXEntry dxentry, DataBrokerQueryInterface ds) {
// Set the local data variables.
dataSource = ds;
entry = dxentry;
// check that the default editors have been initialised.
if (tableDisplay == null) initTableEditor();
if (templateDisplay == null) initHTMLEditor();
// check for a 'no data' display - if there is no data, revert
// to the default html 'no data' template.
if (entry
== null) // || entry.size() == 0) //TE: This is commented out to allow virtual nodes to be
// edited.
{
if (oldOCSig != null) {
clearPluggableEditors();
if (activeEditors.size() == 0) {
addEditor(templateDisplay);
}
oldOCSig = null;
}
refreshEditors(null, ds);
} else {
dataSource = ds; // may be null...
Vector ocs = entry.getOrderedOCs();
// try to create a unique 'signature' for a group of object classes
// This relies on them being delivered in the same order though. (Less
// efficient if they aren't, but otherwise shouldn't be a big problem).
String newOCSig = new String();
if (ocs != null)
for (int i = 0; i < ocs.size(); i++) {
Object ocSig = ocs.get(i);
if (ocSig != null) newOCSig += ocSig.toString();
}
// Check if signiture hasn't changed. If it *has* changed,
// reset the editors using 'setEditors', and update
// the 'old object class signiture' variable.
if (newOCSig.equals(oldOCSig) == false) {
setEditors(entry, ds, ocs);
oldOCSig = newOCSig;
}
// Some quick sanity checks...
if (entry.getStatus() == DXEntry.NEW) // check for new entries (but *not* NEW_WRITTEN)...
{
// don't allow editors to appear that can't edit a new entry
trimNonNewEntryEditors();
suggestPluggableEditor();
} else {
// make sure that the html template display is around...
// XXX (a bit of a hack - this should really check that *all*
// XXX editor that can't handle new entries have been added back...
// XXX (maybe set flag?)
// TE: added '&& !currentEditor.isUnique()' b/c this code always made sure the HTML
// TE: editor is visible, whereas with a unique plugin we only want that one visible...
// TE: unless of course I am totally confused! See bug 674.
if (activeEditors.contains(templateDisplay) == false && !currentEditor.isUnique()) {
add((PluggableEditor) templateDisplay, 0);
if (currentEditor != null) // XXX hack hack.
setCurrentEditor(currentEditor);
}
}
if (activeEditors.contains(currentEditor) == false) {
suggestPluggableEditor();
}
// now that the editor set we're using has been sorted out,
// actually go and update the editors! (Nb. this triggers an usaved changes check)
refreshEditors(entry, ds);
}
}
