Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Copyright 2012-2024 Ping Identity Corporation
* All Rights Reserved.
*/
/*
* Copyright 2012-2024 Ping Identity Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* Copyright (C) 2012-2024 Ping Identity Corporation
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License (GPLv2 only)
* or the terms of the GNU Lesser General Public License (LGPLv2.1 only)
* as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see .
*/
package com.unboundid.ldap.sdk.unboundidds.controls;
import java.util.List;
import java.util.ArrayList;
import com.unboundid.asn1.ASN1Element;
import com.unboundid.asn1.ASN1Sequence;
import com.unboundid.ldap.matchingrules.BooleanMatchingRule;
import com.unboundid.ldap.matchingrules.OctetStringMatchingRule;
import com.unboundid.ldap.sdk.Control;
import com.unboundid.ldap.sdk.AddRequest;
import com.unboundid.ldap.sdk.Attribute;
import com.unboundid.ldap.sdk.JSONControlDecodeHelper;
import com.unboundid.ldap.sdk.LDAPException;
import com.unboundid.ldap.sdk.Modification;
import com.unboundid.ldap.sdk.ResultCode;
import com.unboundid.ldif.LDIFModifyChangeRecord;
import com.unboundid.util.Debug;
import com.unboundid.util.NotMutable;
import com.unboundid.util.NotNull;
import com.unboundid.util.Nullable;
import com.unboundid.util.StaticUtils;
import com.unboundid.util.ThreadSafety;
import com.unboundid.util.ThreadSafetyLevel;
import com.unboundid.util.json.JSONField;
import com.unboundid.util.json.JSONObject;
import static com.unboundid.ldap.sdk.unboundidds.controls.ControlMessages.*;
/**
* This class provides a request control which may be included in an add request
* to indicate that the contents of the resulting entry should come not from the
* data of the add request itself but instead from a soft-deleted entry. This
* can be used to recover an entry that was previously removed by a delete
* request containing the {@link SoftDeleteRequestControl}.
*
*
* NOTE: This class, and other classes within the
* {@code com.unboundid.ldap.sdk.unboundidds} package structure, are only
* supported for use against Ping Identity, UnboundID, and
* Nokia/Alcatel-Lucent 8661 server products. These classes provide support
* for proprietary functionality or for external specifications that are not
* considered stable or mature enough to be guaranteed to work in an
* interoperable way with other types of LDAP servers.
*
*
* The criticality for this control should always be {@code TRUE}. The
* criticality will have no effect on servers that do support this control, but
* a criticality of {@code TRUE} will ensure that a server which does not
* support soft deletes does not attempt to process the add request. If the
* criticality were {@code FALSE}, then any server that does not support the
* control would simply ignore it and attempt to add the entry specified in the
* add request (which will have details about the undelete to be processed).
*
* The control may optionally have a value. If a value is provided, then it
* must be the encoded representation of an empty ASN.1 sequence, like:
*
* UndeleteRequestValue ::= SEQUENCE {
* ... }
*
* In the future, the value sequence may allow one or more elements to customize
* the behavior of the undelete operation, but at present no such elements are
* defined.
* See the documentation for the {@link SoftDeleteRequestControl} class for an
* example demonstrating the use of this control.
*
* @see HardDeleteRequestControl
* @see SoftDeleteRequestControl
*/
@NotMutable()
@ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE)
public final class UndeleteRequestControl
extends Control
{
/**
* The OID (1.3.6.1.4.1.30221.2.5.23) for the undelete request control.
*/
@NotNull public static final String UNDELETE_REQUEST_OID =
"1.3.6.1.4.1.30221.2.5.23";
/**
* The name of the optional attribute used to specify a set of changes to
* apply to the soft-deleted entry during the course of the undelete.
*/
@NotNull public static final String ATTR_CHANGES = "ds-undelete-changes";
/**
* The name of the optional attribute used to indicate whether the
* newly-undeleted user account should be disabled and prevented from
* authenticating.
*/
@NotNull public static final String ATTR_DISABLE_ACCOUNT =
"ds-undelete-disable-account";
/**
* The name of the optional attribute used to indicate whether the
* newly-undeleted user will be required to change his/her password
* immediately after authenticating and before being required to request any
* other operations.
*/
@NotNull public static final String ATTR_MUST_CHANGE_PASSWORD =
"ds-undelete-must-change-password";
/**
* The name of the optional attribute used to specify the new password for use
* in the newly-undeleted entry.
*/
@NotNull public static final String ATTR_NEW_PASSWORD =
"ds-undelete-new-password";
/**
* The name of the optional attribute used to specify the password currently
* contained in the soft-deleted entry, to be validated as part of the
* undelete process.
*/
@NotNull public static final String ATTR_OLD_PASSWORD =
"ds-undelete-old-password";
/**
* The name of the required attribute used to specify the DN of the
* soft-deleted entry to be undeleted.
*/
@NotNull public static final String ATTR_SOFT_DELETED_ENTRY_DN =
"ds-undelete-from-dn";
/**
* The serial version UID for this serializable class.
*/
private static final long serialVersionUID = 5338045977962112876L;
/**
* Creates a undelete request control with a criticality of TRUE and no value.
*/
public UndeleteRequestControl()
{
super(UNDELETE_REQUEST_OID, true, null);
}
/**
* Creates a new undelete request control which is decoded from the
* provided generic control.
*
* @param control The generic control to be decoded as an undelete request
* control.
*
* @throws LDAPException If the provided control cannot be decoded as an
* undelete request control.
*/
public UndeleteRequestControl(@NotNull final Control control)
throws LDAPException
{
super(control);
if (control.hasValue())
{
try
{
final ASN1Sequence valueSequence =
ASN1Sequence.decodeAsSequence(control.getValue().getValue());
final ASN1Element[] elements = valueSequence.elements();
if (elements.length > 0)
{
throw new LDAPException(ResultCode.DECODING_ERROR,
ERR_UNDELETE_REQUEST_UNSUPPORTED_VALUE_ELEMENT_TYPE.get(
StaticUtils.toHex(elements[0].getType())));
}
}
catch (final LDAPException le)
{
Debug.debugException(le);
throw le;
}
catch (final Exception e)
{
Debug.debugException(e);
throw new LDAPException(ResultCode.DECODING_ERROR,
ERR_UNDELETE_REQUEST_CANNOT_DECODE_VALUE.get(
StaticUtils.getExceptionMessage(e)),
e);
}
}
}
/**
* Creates a new undelete request that may be used to recover the specified
* soft-deleted entry.
*
* @param targetDN The DN to use for the entry recovered
* from the soft-deleted entry contents. It must
* not be {@code null}.
* @param softDeletedEntryDN The DN of the soft-deleted entry to be used in
* the restore process. It must not be
* {@code null}.
*
* @return An add request with an appropriate set of content
*/
@NotNull()
public static AddRequest createUndeleteRequest(@NotNull final String targetDN,
@NotNull final String softDeletedEntryDN)
{
return createUndeleteRequest(targetDN, softDeletedEntryDN, null, null, null,
null, null);
}
/**
* Creates a new undelete request that may be used to recover the specified
* soft-deleted entry.
*
* @param targetDN The DN to use for the entry recovered
* from the soft-deleted entry contents. It must
* not be {@code null}.
* @param softDeletedEntryDN The DN of the soft-deleted entry to be used in
* the restore process. It must not be
* {@code null}.
* @param changes An optional set of changes that should be
* applied to the entry during the course of
* undelete processing. It may be {@code null} or
* empty if this element should be omitted from
* the resulting add request.
* @param oldPassword An optional copy of the password currently
* contained in the soft-deleted entry to be
* recovered. If this is non-{@code null}, then
* this password will be required to match that
* contained in the target entry for the undelete
* to succeed.
* @param newPassword An optional new password to set for the user
* as part of the undelete processing. It may be
* {@code null} if no new password should be
* provided.
* @param mustChangePassword Indicates whether the recovered user will be
* required to change his/her password before
* being allowed to request any other operations.
* It may be {@code null} if this should be
* omitted from the resulting add request.
* @param disableAccount Indicates whether the undeleted entry should be
* made disabled so that it cannot be used to
* authenticate. It may be {@code null} if this
* should be omitted from the resulting add
* request.
*
* @return An add request with an appropriate set of content
*/
@NotNull()
public static AddRequest createUndeleteRequest(@NotNull final String targetDN,
@NotNull final String softDeletedEntryDN,
@Nullable final List changes,
@Nullable final String oldPassword,
@Nullable final String newPassword,
@Nullable final Boolean mustChangePassword,
@Nullable final Boolean disableAccount)
{
final ArrayList attributes = new ArrayList<>(6);
attributes.add(new Attribute(ATTR_SOFT_DELETED_ENTRY_DN,
softDeletedEntryDN));
if ((changes != null) && (! changes.isEmpty()))
{
// The changes attribute should be an LDIF-encoded representation of the
// modification, with the first two lines (the DN and changetype)
// removed.
final LDIFModifyChangeRecord changeRecord =
new LDIFModifyChangeRecord(targetDN, changes);
final String[] modLdifLines = changeRecord.toLDIF(0);
final StringBuilder modLDIFBuffer = new StringBuilder();
for (int i=2; i < modLdifLines.length; i++)
{
modLDIFBuffer.append(modLdifLines[i]);
modLDIFBuffer.append(StaticUtils.EOL);
}
attributes.add(new Attribute(ATTR_CHANGES,
OctetStringMatchingRule.getInstance(), modLDIFBuffer.toString()));
}
if (oldPassword != null)
{
attributes.add(new Attribute(ATTR_OLD_PASSWORD,
OctetStringMatchingRule.getInstance(), oldPassword));
}
if (newPassword != null)
{
attributes.add(new Attribute(ATTR_NEW_PASSWORD,
OctetStringMatchingRule.getInstance(), newPassword));
}
if (mustChangePassword != null)
{
attributes.add(new Attribute(ATTR_MUST_CHANGE_PASSWORD,
BooleanMatchingRule.getInstance(),
(mustChangePassword ? "true" : "false")));
}
if (disableAccount != null)
{
attributes.add(new Attribute(ATTR_DISABLE_ACCOUNT,
BooleanMatchingRule.getInstance(),
(disableAccount ? "true" : "false")));
}
final Control[] controls =
{
new UndeleteRequestControl()
};
return new AddRequest(targetDN, attributes, controls);
}
/**
* {@inheritDoc}
*/
@Override()
@NotNull()
public String getControlName()
{
return INFO_CONTROL_NAME_UNDELETE_REQUEST.get();
}
/**
* Retrieves a representation of this undelete request control as a JSON
* object. The JSON object uses the following fields (note that since this
* control does not have a value, neither the {@code value-base64} nor
* {@code value-json} fields may be present):
*
*
* {@code oid} -- A mandatory string field whose value is the object
* identifier for this control. For the undelete request control, the OID
* is "1.3.6.1.4.1.30221.2.5.23".
*
*
* {@code control-name} -- An optional string field whose value is a
* human-readable name for this control. This field is only intended for
* descriptive purposes, and when decoding a control, the {@code oid}
* field should be used to identify the type of control.
*
*
* {@code criticality} -- A mandatory Boolean field used to indicate
* whether this control is considered critical.
*
*
*
* @return A JSON object that contains a representation of this control.
*/
@Override()
@NotNull()
public JSONObject toJSONControl()
{
return new JSONObject(
new JSONField(JSONControlDecodeHelper.JSON_FIELD_OID,
UNDELETE_REQUEST_OID),
new JSONField(JSONControlDecodeHelper.JSON_FIELD_CONTROL_NAME,
INFO_CONTROL_NAME_UNDELETE_REQUEST.get()),
new JSONField(JSONControlDecodeHelper.JSON_FIELD_CRITICALITY,
isCritical()));
}
/**
* Attempts to decode the provided object as a JSON representation of an
* undelete request control.
*
* @param controlObject The JSON object to be decoded. It must not be
* {@code null}.
* @param strict Indicates whether to use strict mode when decoding
* the provided JSON object. If this is {@code true},
* then this method will throw an exception if the
* provided JSON object contains any unrecognized
* fields. If this is {@code false}, then unrecognized
* fields will be ignored.
*
* @return The undelete request control that was decoded from the provided
* JSON object.
*
* @throws LDAPException If the provided JSON object cannot be parsed as a
* valid undelete request control.
*/
@NotNull()
public static UndeleteRequestControl decodeJSONControl(
@NotNull final JSONObject controlObject,
final boolean strict)
throws LDAPException
{
final JSONControlDecodeHelper jsonControl = new JSONControlDecodeHelper(
controlObject, strict, false, false);
return new UndeleteRequestControl();
}
/**
* {@inheritDoc}
*/
@Override()
public void toString(@NotNull final StringBuilder buffer)
{
buffer.append("UndeleteRequestControl(isCritical=");
buffer.append(isCritical());
buffer.append(')');
}
}
