001/*
002 * Copyright 2020-2023 Ping Identity Corporation
003 * All Rights Reserved.
004 */
005/*
006 * Copyright 2020-2023 Ping Identity Corporation
007 *
008 * Licensed under the Apache License, Version 2.0 (the "License");
009 * you may not use this file except in compliance with the License.
010 * You may obtain a copy of the License at
011 *
012 *    http://www.apache.org/licenses/LICENSE-2.0
013 *
014 * Unless required by applicable law or agreed to in writing, software
015 * distributed under the License is distributed on an "AS IS" BASIS,
016 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
017 * See the License for the specific language governing permissions and
018 * limitations under the License.
019 */
020/*
021 * Copyright (C) 2020-2023 Ping Identity Corporation
022 *
023 * This program is free software; you can redistribute it and/or modify
024 * it under the terms of the GNU General Public License (GPLv2 only)
025 * or the terms of the GNU Lesser General Public License (LGPLv2.1 only)
026 * as published by the Free Software Foundation.
027 *
028 * This program is distributed in the hope that it will be useful,
029 * but WITHOUT ANY WARRANTY; without even the implied warranty of
030 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
031 * GNU General Public License for more details.
032 *
033 * You should have received a copy of the GNU General Public License
034 * along with this program; if not, see <http://www.gnu.org/licenses>.
035 */
036package com.unboundid.ldap.sdk.unboundidds.tasks;
037
038
039
040import java.util.Collections;
041import java.util.LinkedHashMap;
042import java.util.List;
043import java.util.Map;
044
045import com.unboundid.ldap.sdk.Attribute;
046import com.unboundid.ldap.sdk.Entry;
047import com.unboundid.util.NotMutable;
048import com.unboundid.util.NotNull;
049import com.unboundid.util.StaticUtils;
050import com.unboundid.util.ThreadSafety;
051import com.unboundid.util.ThreadSafetyLevel;
052
053import static com.unboundid.ldap.sdk.unboundidds.tasks.TaskMessages.*;
054
055
056
057/**
058 * This class defines a Directory Server task that can be used to safely remove
059 * an attribute type from the server schema.  It will make sure that the
060 * attribute type is not in use in the server before removing it.
061 * <BR>
062 * <BLOCKQUOTE>
063 *   <B>NOTE:</B>  This class, and other classes within the
064 *   {@code com.unboundid.ldap.sdk.unboundidds} package structure, are only
065 *   supported for use against Ping Identity, UnboundID, and
066 *   Nokia/Alcatel-Lucent 8661 server products.  These classes provide support
067 *   for proprietary functionality or for external specifications that are not
068 *   considered stable or mature enough to be guaranteed to work in an
069 *   interoperable way with other types of LDAP servers.
070 * </BLOCKQUOTE>
071 * <BR>
072 * The properties that are available for use with this type of task include:
073 * <UL>
074 *   <LI>The name or OID of the attribute type to remove from the server
075 *       schema.</LI>
076 * </UL>
077 */
078@NotMutable()
079@ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE)
080public final class RemoveAttributeTypeTask
081       extends Task
082{
083  /**
084   * The fully-qualified name of the Java class that is used for the remove
085   * attribute type task.
086   */
087  @NotNull static final String REMOVE_ATTRIBUTE_TYPE_TASK_CLASS =
088       "com.unboundid.directory.server.tasks.RemoveAttributeTypeTask";
089
090
091
092  /**
093   * The name of the attribute used to specify the name or OID of the attribute
094   * type to remove from the server schema.
095   */
096  @NotNull public static final String ATTR_ATTRIBUTE_TYPE =
097       "ds-task-remove-attribute-type-attribute";
098
099
100
101  /**
102   * The name of the object class used in remove attribute type task entries.
103   */
104  @NotNull public static final String OC_REMOVE_ATTRIBUTE_TYPE_TASK =
105       "ds-task-remove-attribute-type";
106
107
108
109  /**
110   * The task property that will be used for the attribute type name or OID.
111   */
112  @NotNull static final TaskProperty PROPERTY_ATTRIBUTE_TYPE =
113     new TaskProperty(ATTR_ATTRIBUTE_TYPE,
114          INFO_REMOVE_ATTR_TYPE_DISPLAY_NAME_ATTRIBUTE_TYPE.get(),
115          INFO_REMOVE_ATTR_TYPE_DESCRIPTION_ATTRIBUTE_TYPE.get(),
116          String.class, true, false, false);
117
118
119
120  /**
121   * The serial version UID for this serializable class.
122   */
123  private static final long serialVersionUID = -3118507632013307187L;
124
125
126
127  // The name or OID for the attribute type to remove.
128  @NotNull private final String attributeType;
129
130
131
132  /**
133   * Creates a new uninitialized remove attribute type task instance that should
134   * only be used for obtaining general information about this task, including
135   * the task name, description, and supported properties.  Attempts to use a
136   * task created with this constructor for any other reason will likely fail.
137   */
138  RemoveAttributeTypeTask()
139  {
140    super();
141
142    attributeType = null;
143  }
144
145
146
147  /**
148   * Creates a new remove attribute type task instance that will remove the
149   * specified attribute type from the server schema and will use the default
150   * values for all other properties.
151   *
152   * @param  attributeType  The name or OID of the attribute type to remove from
153   *                        the server schema.
154   */
155  public RemoveAttributeTypeTask(@NotNull final String attributeType)
156  {
157    this(new RemoveAttributeTypeTaskProperties(attributeType));
158  }
159
160
161
162  /**
163   * Creates a new remove attribute type task instance using the provided
164   * properties.
165   *
166   * @param  properties  The properties to use to create the remove attribute
167   *                     type task.  It must not be {@code null}.
168   */
169  public RemoveAttributeTypeTask(
170              @NotNull final RemoveAttributeTypeTaskProperties properties)
171  {
172    super(properties.getTaskID(), REMOVE_ATTRIBUTE_TYPE_TASK_CLASS,
173         properties.getScheduledStartTime(), properties.getDependencyIDs(),
174         properties.getFailedDependencyAction(), properties.getNotifyOnStart(),
175         properties.getNotifyOnCompletion(), properties.getNotifyOnSuccess(),
176         properties.getNotifyOnError(), properties.getAlertOnStart(),
177         properties.getAlertOnSuccess(), properties.getAlertOnError());
178
179    attributeType = properties.getAttributeType();
180  }
181
182
183
184  /**
185   * Creates a new remove attribute type task from the provided entry.
186   *
187   * @param  entry  The entry to use to create this remove attribute type task.
188   *
189   * @throws  TaskException  If the provided entry cannot be parsed as a remove
190   *                         attribute tyep task entry.
191   */
192  public RemoveAttributeTypeTask(@NotNull final Entry entry)
193         throws TaskException
194  {
195    super(entry);
196
197    attributeType = entry.getAttributeValue(ATTR_ATTRIBUTE_TYPE);
198    if (attributeType == null)
199    {
200      throw new TaskException(ERR_REMOVE_ATTR_TYPE_ENTRY_MISSING_ATTR_TYPE.get(
201           entry.getDN(), ATTR_ATTRIBUTE_TYPE));
202    }
203  }
204
205
206
207  /**
208   * Creates a new remove attribute type task from the provided set of task
209   * properties.
210   *
211   * @param  properties  The set of task properties and their corresponding
212   *                     values to use for the task.  It must not be
213   *                     {@code null}.
214   *
215   * @throws  TaskException  If the provided set of properties cannot be used to
216   *                         create a valid remove attribute type task.
217   */
218  public RemoveAttributeTypeTask(
219              @NotNull final Map<TaskProperty,List<Object>> properties)
220         throws TaskException
221  {
222    super(REMOVE_ATTRIBUTE_TYPE_TASK_CLASS, properties);
223
224    String attrType = null;
225    for (final Map.Entry<TaskProperty,List<Object>> entry :
226         properties.entrySet())
227    {
228      final TaskProperty p = entry.getKey();
229      final String attrName = StaticUtils.toLowerCase(p.getAttributeName());
230      final List<Object> values = entry.getValue();
231
232      if (attrName.equals(ATTR_ATTRIBUTE_TYPE))
233      {
234        attrType = parseString(p, values, attrType);
235      }
236    }
237
238    attributeType = attrType;
239    if (attributeType == null)
240    {
241      throw new TaskException(ERR_REMOVE_ATTR_TYPE_PROPS_MISSING_ATTR_TYPE.get(
242           ATTR_ATTRIBUTE_TYPE));
243    }
244  }
245
246
247
248  /**
249   * {@inheritDoc}
250   */
251  @Override()
252  @NotNull()
253  public String getTaskName()
254  {
255    return INFO_REMOVE_ATTR_TYPE_TASK_NAME.get();
256  }
257
258
259
260  /**
261   * {@inheritDoc}
262   */
263  @Override()
264  @NotNull()
265  public String getTaskDescription()
266  {
267    return INFO_REMOVE_ATTR_TYPE_TASK_DESCRIPTION.get();
268  }
269
270
271
272  /**
273   * Retrieves the name or OID of the attribute type to remove from the server
274   * schema.
275   *
276   * @return  The name or OID of the attribute type to remove from the server
277   *          schema.
278   */
279  @NotNull()
280  public String getAttributeType()
281  {
282    return attributeType;
283  }
284
285
286
287  /**
288   * {@inheritDoc}
289   */
290  @Override()
291  @NotNull()
292  protected List<String> getAdditionalObjectClasses()
293  {
294    return Collections.singletonList(OC_REMOVE_ATTRIBUTE_TYPE_TASK);
295  }
296
297
298
299  /**
300   * {@inheritDoc}
301   */
302  @Override()
303  @NotNull()
304  protected List<Attribute> getAdditionalAttributes()
305  {
306    return Collections.singletonList(
307         new Attribute(ATTR_ATTRIBUTE_TYPE, attributeType));
308  }
309
310
311
312  /**
313   * {@inheritDoc}
314   */
315  @Override()
316  @NotNull()
317  public List<TaskProperty> getTaskSpecificProperties()
318  {
319    return Collections.singletonList(PROPERTY_ATTRIBUTE_TYPE);
320  }
321
322
323
324  /**
325   * {@inheritDoc}
326   */
327  @Override()
328  @NotNull()
329  public Map<TaskProperty,List<Object>> getTaskPropertyValues()
330  {
331    final Map<TaskProperty,List<Object>> props =
332         new LinkedHashMap<>(StaticUtils.computeMapCapacity(20));
333    props.put(PROPERTY_ATTRIBUTE_TYPE,
334         Collections.<Object>singletonList(attributeType));
335
336    props.putAll(super.getTaskPropertyValues());
337    return Collections.unmodifiableMap(props);
338  }
339}