private void deleteObjectclass() {
ArrayList<LocalizableMessage> errors = new ArrayList<>();
ProgressDialog dlg =
new ProgressDialog(
Utilities.createFrame(),
Utilities.getParentDialog(this),
INFO_CTRL_PANEL_DELETE_OBJECTCLASS_TITLE.get(),
getInfo());
LinkedHashSet<ObjectClass> ocsToDelete = new LinkedHashSet<>();
ocsToDelete.add(objectClass);
LinkedHashSet<AttributeType> attrsToDelete = new LinkedHashSet<>(0);
DeleteSchemaElementsTask newTask =
new DeleteSchemaElementsTask(getInfo(), dlg, ocsToDelete, attrsToDelete);
for (Task task : getInfo().getTasks()) {
task.canLaunch(newTask, errors);
}
Schema schema = getInfo().getServerDescriptor().getSchema();
ArrayList<String> childClasses = new ArrayList<>();
if (schema != null) {
for (ObjectClass o : schema.getObjectClasses().values()) {
for (ObjectClass superior : o.getSuperiorClasses()) {
if (objectClass.equals(superior)) {
childClasses.add(o.getNameOrOID());
}
}
}
} else {
errors.add(ERR_CTRL_PANEL_SCHEMA_NOT_FOUND_DETAILS.get());
}
if (errors.isEmpty()) {
LocalizableMessageBuilder mb = new LocalizableMessageBuilder();
if (!childClasses.isEmpty()) {
mb.append(
INFO_OBJECTCLASS_IS_SUPERIOR.get(
ocName, Utilities.getStringFromCollection(childClasses, ", ")));
mb.append("<br>");
}
LocalizableMessage confirmationMessage =
INFO_CTRL_PANEL_CONFIRMATION_DELETE_OBJECTCLASS_DETAILS.get(ocName);
mb.append(confirmationMessage);
if (displayConfirmationDialog(
INFO_CTRL_PANEL_CONFIRMATION_REQUIRED_SUMMARY.get(), confirmationMessage)) {
launchOperation(
newTask,
INFO_CTRL_PANEL_DELETING_OBJECTCLASS_SUMMARY.get(ocName),
INFO_CTRL_PANEL_DELETING_OBJECTCLASS_COMPLETE.get(),
INFO_CTRL_PANEL_DELETING_OBJECTCLASS_SUCCESSFUL.get(ocName),
ERR_CTRL_PANEL_DELETING_OBJECTCLASS_ERROR_SUMMARY.get(),
ERR_CTRL_PANEL_DELETING_OBJECTCLASS_ERROR_DETAILS.get(ocName),
null,
dlg);
dlg.setVisible(true);
}
} else {
displayErrorDialog(errors);
}
}
private void deleteClicked() {
ArrayList<Message> errors = new ArrayList<Message>();
TreePath[] paths = treePane.getTree().getSelectionPaths();
ArrayList<AbstractIndexDescriptor> indexesToDelete = new ArrayList<AbstractIndexDescriptor>();
ArrayList<String> indexesNames = new ArrayList<String>();
if (paths != null) {
for (TreePath path : paths) {
Object node = path.getLastPathComponent();
if (node instanceof IndexTreeNode) {
indexesToDelete.add(((IndexTreeNode) node).getIndex());
} else if (node instanceof VLVIndexTreeNode) {
indexesToDelete.add(((VLVIndexTreeNode) node).getIndex());
}
}
} else {
errors.add(ERR_CTRL_PANEL_NO_INDEX_SELECTED.get());
}
for (AbstractIndexDescriptor index : indexesToDelete) {
indexesNames.add(index.getName());
}
String nameLabel = Utilities.getStringFromCollection(indexesNames, ", ");
String backendName = indexesToDelete.get(0).getBackend().getBackendID();
if (errors.isEmpty()) {
ProgressDialog dlg =
new ProgressDialog(
Utilities.createFrame(),
Utilities.getParentDialog(this),
INFO_CTRL_PANEL_DELETE_INDEXES_TITLE.get(),
getInfo());
DeleteIndexTask newTask = new DeleteIndexTask(getInfo(), dlg, indexesToDelete);
for (Task task : getInfo().getTasks()) {
task.canLaunch(newTask, errors);
}
if (errors.isEmpty()) {
if (displayConfirmationDialog(
INFO_CTRL_PANEL_CONFIRMATION_REQUIRED_SUMMARY.get(),
INFO_CTRL_PANEL_CONFIRMATION_INDEXES_DELETE_DETAILS.get(nameLabel, backendName))) {
launchOperation(
newTask,
INFO_CTRL_PANEL_DELETING_INDEXES_SUMMARY.get(),
INFO_CTRL_PANEL_DELETING_INDEXES_COMPLETE.get(),
INFO_CTRL_PANEL_DELETING_INDEXES_SUCCESSFUL.get(nameLabel, backendName),
ERR_CTRL_PANEL_DELETING_INDEXES_ERROR_SUMMARY.get(),
ERR_CTRL_PANEL_DELETING_INDEXES_ERROR_DETAILS.get(nameLabel),
null,
dlg);
dlg.setVisible(true);
}
}
}
if (!errors.isEmpty()) {
displayErrorDialog(errors);
}
}
/**
* Saves the index modifications.
*
* @param modal whether the progress dialog for the task must be modal or not.
*/
private void saveIndex(boolean modal) {
newModifyTask = null;
if (!isModified()) {
return;
}
List<LocalizableMessage> errors = getErrors();
if (errors.isEmpty()) {
ProgressDialog dlg =
new ProgressDialog(
Utilities.getFrame(this),
Utilities.getFrame(this),
INFO_CTRL_PANEL_MODIFYING_INDEX_TITLE.get(),
getInfo());
dlg.setModal(modal);
newModifyTask = new ModifyIndexTask(getInfo(), dlg);
for (Task task : getInfo().getTasks()) {
task.canLaunch(newModifyTask, errors);
}
if (errors.isEmpty()) {
String attributeName = index.getName();
String backendName = index.getBackend().getBackendID();
launchOperation(
newModifyTask,
INFO_CTRL_PANEL_MODIFYING_INDEX_SUMMARY.get(attributeName),
INFO_CTRL_PANEL_MODIFYING_INDEX_COMPLETE.get(),
INFO_CTRL_PANEL_MODIFYING_INDEX_SUCCESSFUL.get(attributeName, backendName),
ERR_CTRL_PANEL_MODIFYING_INDEX_ERROR_SUMMARY.get(),
ERR_CTRL_PANEL_MODIFYING_INDEX_ERROR_DETAILS.get(attributeName),
null,
dlg);
saveChanges.setEnabled(false);
dlg.setVisible(true);
}
}
if (!errors.isEmpty()) {
displayErrorDialog(errors);
}
}
private void deleteIndex() {
List<LocalizableMessage> errors = new ArrayList<>();
ProgressDialog dlg =
new ProgressDialog(
Utilities.createFrame(),
Utilities.getParentDialog(this),
INFO_CTRL_PANEL_DELETE_INDEX_TITLE.get(),
getInfo());
ArrayList<AbstractIndexDescriptor> indexesToDelete = new ArrayList<>();
indexesToDelete.add(index);
DeleteIndexTask newTask = new DeleteIndexTask(getInfo(), dlg, indexesToDelete);
for (Task task : getInfo().getTasks()) {
task.canLaunch(newTask, errors);
}
if (errors.isEmpty()) {
String indexName = index.getName();
String backendName = index.getBackend().getBackendID();
if (displayConfirmationDialog(
INFO_CTRL_PANEL_CONFIRMATION_REQUIRED_SUMMARY.get(),
INFO_CTRL_PANEL_CONFIRMATION_INDEX_DELETE_DETAILS.get(indexName, backendName))) {
launchOperation(
newTask,
INFO_CTRL_PANEL_DELETING_INDEX_SUMMARY.get(),
INFO_CTRL_PANEL_DELETING_INDEX_COMPLETE.get(),
INFO_CTRL_PANEL_DELETING_INDEX_SUCCESSFUL.get(indexName, backendName),
ERR_CTRL_PANEL_DELETING_INDEX_ERROR_SUMMARY.get(),
ERR_CTRL_PANEL_DELETING_INDEX_ERROR_DETAILS.get(indexName),
null,
dlg);
dlg.setVisible(true);
}
} else {
displayErrorDialog(errors);
}
}
/** {@inheritDoc} */
public boolean canLaunch(
Task taskToBeLaunched, Collection<LocalizableMessage> incompatibilityReasons) {
boolean canLaunch = true;
if (state == State.RUNNING && runningOnSameServer(taskToBeLaunched)) {
// All the operations are incompatible if they apply to this
// backend for safety. This is a short operation so the limitation
// has not a lot of impact.
Set<String> backends = new TreeSet<>(taskToBeLaunched.getBackends());
backends.retainAll(getBackends());
if (!backends.isEmpty()) {
incompatibilityReasons.add(getIncompatibilityMessage(this, taskToBeLaunched));
canLaunch = false;
}
}
return canLaunch;
}
/** {@inheritDoc} */
public void okClicked() {
setPrimaryValid(lBaseDN);
setSecondaryValid(addRemove.getSelectedLabel());
final LinkedHashSet<Message> errors = new LinkedHashSet<Message>();
String baseDN = getSelectedBaseDN();
if (baseDN == null) {
setPrimaryInvalid(lBaseDN);
if (baseDNs.getItemCount() == 0) {
errors.add(ERR_CTRL_PANEL_NO_BASE_DNS_DEFINED_LABEL.get());
} else {
errors.add(ERR_CTRL_PANEL_MUST_SELECT_BASE_DN.get());
}
}
SortableListModel<AbstractIndexDescriptor> model = addRemove.getSelectedListModel();
if (model.getSize() == 0) {
setSecondaryInvalid(addRemove.getSelectedLabel());
errors.add(ERR_CTRL_PANEL_MUST_SELECT_INDEX_TO_REBUILD.get());
}
if (errors.isEmpty()) {
ProgressDialog progressDialog =
new ProgressDialog(
Utilities.createFrame(), Utilities.getParentDialog(this), getTitle(), getInfo());
HashSet<String> baseDNs = new HashSet<String>();
baseDNs.add(getSelectedBaseDN());
RebuildIndexTask newTask =
new RebuildIndexTask(
getInfo(), progressDialog, baseDNs, addRemove.getSelectedListModel().getData());
for (Task task : getInfo().getTasks()) {
task.canLaunch(newTask, errors);
}
boolean confirmed = true;
if ((errors.isEmpty()) && isServerRunning()) {
String backendName = newTask.getBackends().iterator().next();
confirmed =
displayConfirmationDialog(
INFO_CTRL_PANEL_CONFIRMATION_REQUIRED_SUMMARY.get(),
INFO_CTRL_PANEL_CONFIRM_REBUILD_INDEX_DETAILS.get(backendName));
}
if ((errors.isEmpty()) && confirmed) {
launchOperation(
newTask,
INFO_CTRL_PANEL_REBUILDING_INDEXES_SUMMARY.get(baseDN),
INFO_CTRL_PANEL_REBUILDING_INDEXES_SUCCESSFUL_SUMMARY.get(),
INFO_CTRL_PANEL_REBUILDING_INDEXES_SUCCESSFUL_DETAILS.get(),
ERR_CTRL_PANEL_REBUILDING_INDEXES_ERROR_SUMMARY.get(),
null,
ERR_CTRL_PANEL_REBUILDING_INDEXES_ERROR_DETAILS,
progressDialog);
progressDialog.setVisible(true);
Utilities.getParentDialog(this).setVisible(false);
}
}
if (errors.size() > 0) {
displayErrorDialog(errors);
}
}
private void saveChanges(boolean modal, ArrayList<LocalizableMessage> errors) {
for (JLabel label : labels) {
setPrimaryValid(label);
}
String n = getObjectClassName();
LocalizableMessageBuilder err = new LocalizableMessageBuilder();
if (n.length() == 0) {
errors.add(ERR_CTRL_PANEL_OBJECTCLASS_NAME_REQUIRED.get());
setPrimaryInvalid(lName);
} else if (!n.equalsIgnoreCase(objectClass.getNameOrOID())) {
if (!StaticUtils.isValidSchemaElement(n, 0, n.length(), err)) {
errors.add(ERR_CTRL_PANEL_INVALID_OBJECTCLASS_NAME.get(err));
setPrimaryInvalid(lName);
err = new LocalizableMessageBuilder();
} else {
LocalizableMessage elementType = NewAttributePanel.getSchemaElementType(n, schema);
if (elementType != null) {
errors.add(ERR_CTRL_PANEL_OBJECTCLASS_NAME_ALREADY_IN_USE.get(n, elementType));
setPrimaryInvalid(lName);
}
}
}
n = oid.getText().trim();
if (n.length() > 0 && !n.equalsIgnoreCase(objectClass.getOID())) {
if (!StaticUtils.isValidSchemaElement(n, 0, n.length(), err)) {
errors.add(ERR_CTRL_PANEL_OID_NOT_VALID.get(err));
setPrimaryInvalid(lOID);
err = new LocalizableMessageBuilder();
} else {
LocalizableMessage elementType = NewAttributePanel.getSchemaElementType(n, schema);
if (elementType != null) {
errors.add(ERR_CTRL_PANEL_OID_ALREADY_IN_USE.get(n, elementType));
setPrimaryInvalid(lOID);
}
}
}
Collection<String> aliases = getAliases();
Collection<String> oldAliases = getAliases(objectClass);
if (!aliases.equals(oldAliases)) {
for (String alias : aliases) {
if (alias.trim().length() == 0) {
errors.add(ERR_CTRL_PANEL_EMPTY_ALIAS.get());
setPrimaryInvalid(lAliases);
} else {
boolean notPreviouslyDefined = true;
for (String oldAlias : oldAliases) {
if (oldAlias.equalsIgnoreCase(alias)) {
notPreviouslyDefined = false;
break;
}
}
if (notPreviouslyDefined) {
LocalizableMessage elementType = NewAttributePanel.getSchemaElementType(alias, schema);
if (elementType != null) {
errors.add(ERR_CTRL_PANEL_ALIAS_ALREADY_IN_USE.get(n, elementType));
setPrimaryInvalid(lAliases);
}
}
}
}
}
// validate the superiority.
for (ObjectClass superior : getObjectClassSuperiors()) {
validateSuperiority(superior, errors);
}
checkCompatibleSuperiors(getObjectClassSuperiors(), getObjectClassType(), errors);
if (errors.isEmpty()) {
ProgressDialog dlg =
new ProgressDialog(
Utilities.createFrame(),
Utilities.getParentDialog(this),
INFO_CTRL_PANEL_MODIFY_ATTRIBUTE_TITLE.get(),
getInfo());
ModifyObjectClassTask newTask =
new ModifyObjectClassTask(getInfo(), dlg, objectClass, getNewObjectClass());
for (ConfigurationElementCreatedListener listener :
getConfigurationElementCreatedListeners()) {
newTask.addConfigurationElementCreatedListener(listener);
}
for (Task task : getInfo().getTasks()) {
task.canLaunch(newTask, errors);
}
if (errors.isEmpty()) {
launchOperation(
newTask,
INFO_CTRL_PANEL_MODIFYING_OBJECTCLASS_SUMMARY.get(ocName),
INFO_CTRL_PANEL_MODIFYING_OBJECTCLASS_COMPLETE.get(),
INFO_CTRL_PANEL_MODIFYING_OBJECTCLASS_SUCCESSFUL.get(ocName),
ERR_CTRL_PANEL_MODIFYING_OBJECTCLASS_ERROR_SUMMARY.get(),
ERR_CTRL_PANEL_MODIFYING_OBJECTCLASS_ERROR_DETAILS.get(ocName),
null,
dlg);
dlg.setVisible(true);
}
}
if (!errors.isEmpty()) {
displayErrorDialog(errors);
}
}
