001    /*
002     * Copyright 2015 UnboundID Corp.
003     * All Rights Reserved.
004     */
005    /*
006     * Copyright (C) 2015 UnboundID Corp.
007     *
008     * This program is free software; you can redistribute it and/or modify
009     * it under the terms of the GNU General Public License (GPLv2 only)
010     * or the terms of the GNU Lesser General Public License (LGPLv2.1 only)
011     * as published by the Free Software Foundation.
012     *
013     * This program is distributed in the hope that it will be useful,
014     * but WITHOUT ANY WARRANTY; without even the implied warranty of
015     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
016     * GNU General Public License for more details.
017     *
018     * You should have received a copy of the GNU General Public License
019     * along with this program; if not, see <http://www.gnu.org/licenses>.
020     */
021    package com.unboundid.ldap.sdk.unboundidds.extensions;
022    
023    
024    
025    import java.io.Serializable;
026    
027    import com.unboundid.util.NotMutable;
028    import com.unboundid.util.ThreadSafety;
029    import com.unboundid.util.ThreadSafetyLevel;
030    import com.unboundid.util.Validator;
031    
032    
033    
034    /**
035     * <BLOCKQUOTE>
036     *   <B>NOTE:</B>  This class is part of the Commercial Edition of the UnboundID
037     *   LDAP SDK for Java.  It is not available for use in applications that
038     *   include only the Standard Edition of the LDAP SDK, and is not supported for
039     *   use in conjunction with non-UnboundID products.
040     * </BLOCKQUOTE>
041     * This class provides a data structure with information about a one-time
042     * password delivery mechanism that is supported by the Directory Server and may
043     * or may not be supported for a particular user.
044     */
045    @NotMutable()
046    @ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE)
047    public final class SupportedOTPDeliveryMechanismInfo
048           implements Serializable
049    {
050      /**
051       * The serial version UID for this serializable class.
052       */
053      private static final long serialVersionUID = -6315998976212985213L;
054    
055    
056    
057      // Indicates whether the delivery mechanism is supported for the user targeted
058      // by the get supported OTP delivery mechanisms extended request.
059      private final Boolean isSupported;
060    
061      // The name of the OTP delivery mechanism.
062      private final String deliveryMechanism;
063    
064      // An optional recipient ID that may be used for the target user in
065      // conjunction with the delivery mechanism.
066      private final String recipientID;
067    
068    
069    
070      /**
071       * Creates a new supported OTP delivery mechanism info object with the
072       * provided information.
073       *
074       * @param  deliveryMechanism  The name of the one-time password delivery
075       *                            mechanism to which this object corresponds.
076       * @param  isSupported        Indicates whether the specified delivery
077       *                            mechanism is expected to be supported for the
078       *                            target user.  This may be {@code true} (to
079       *                            indicate that the delivery mechanism is expected
080       *                            to be supported for the target user,
081       *                            {@code false} if the delivery mechanism is not
082       *                            supported for the target user, or {@code null}
083       *                            if it cannot be determined whether the delivery
084       *                            mechanism is supported for the target user.
085       * @param  recipientID        An optional recipient ID that can be used in
086       *                            conjunction with the delivery mechanism if it
087       *                            is supported for the user (e.g., it may be an
088       *                            email address for an email-based delivery
089       *                            mechanism or a mobile phone number for an
090       *                            SMS-based delivery mechanism).  This may be
091       *                            {@code null} if the delivery mechanism is not
092       *                            supported or if no recipient ID is applicable.
093       */
094      public SupportedOTPDeliveryMechanismInfo(final String deliveryMechanism,
095                                               final Boolean isSupported,
096                                               final String recipientID)
097      {
098        Validator.ensureNotNull(deliveryMechanism);
099    
100        this.deliveryMechanism = deliveryMechanism;
101        this.isSupported       = isSupported;
102        this.recipientID       = recipientID;
103      }
104    
105    
106    
107      /**
108       * Retrieves the name of the one-time password delivery mechanism to which
109       * this object corresponds.
110       *
111       * @return  The name of the one-time password delivery mechanism to which this
112       *          object corresponds.
113       */
114      public String getDeliveryMechanism()
115      {
116        return deliveryMechanism;
117      }
118    
119    
120    
121      /**
122       * Retrieves information about whether the one-time password delivery
123       * mechanism is supported for the target user.
124       *
125       * @return  {@code true} if the delivery mechanism is expected to be supported
126       *          for the user, {@code false} if the delivery mechanism is not
127       *          supported for the user, or {@code null} if it cannot be determined
128       *          whether the delivery mechanism is supported for the target user.
129       */
130      public Boolean isSupported()
131      {
132        return isSupported;
133      }
134    
135    
136    
137      /**
138       * Retrieves the recipient ID, if any, that may be used for the target user
139       * in conjunction with the associated delivery mechanism.  If a recipient ID
140       * is available, then its format may vary based on the type of delivery
141       * mechanism.
142       *
143       * @return  The recipient ID that may be used for the target user in
144       *          conjunction with the associated delivery mechanism, or
145       *          {@code null} if there is no recipient ID associated with the
146       *          delivery mechanism, or if the delivery mechanism is not expected
147       *          to be supported for the target user.
148       */
149      public String getRecipientID()
150      {
151        return recipientID;
152      }
153    
154    
155    
156      /**
157       * Retrieves a hash code for this supported OTP delivery mechanism info
158       * object.
159       *
160       * @return  A hash code for this supported OTP delivery mechanism info object.
161       */
162      @Override()
163      public int hashCode()
164      {
165        int hc = deliveryMechanism.hashCode();
166    
167        if (isSupported == null)
168        {
169          hc += 2;
170        }
171        else if (isSupported)
172        {
173          hc++;
174        }
175    
176        if (recipientID != null)
177        {
178          hc += recipientID.hashCode();
179        }
180    
181        return hc;
182      }
183    
184    
185    
186      /**
187       * Indicates whether the provided object is considered equal to this supported
188       * OTP delivery mechanism info object.
189       *
190       * @param  o  The object for which to make the determination.
191       *
192       * @return  {@code true} if the provided object is an equivalent supported OTP
193       *          delivery mechanism info object, or {@code false} if not.
194       */
195      @Override()
196      public boolean equals(final Object o)
197      {
198        if (o == this)
199        {
200          return true;
201        }
202    
203        if (! (o instanceof SupportedOTPDeliveryMechanismInfo))
204        {
205          return false;
206        }
207    
208        final SupportedOTPDeliveryMechanismInfo i =
209             (SupportedOTPDeliveryMechanismInfo) o;
210        if (! deliveryMechanism.equals(i.deliveryMechanism))
211        {
212          return false;
213        }
214    
215        if (isSupported == null)
216        {
217          if (i.isSupported != null)
218          {
219            return false;
220          }
221        }
222        else
223        {
224          if (! isSupported.equals(i.isSupported))
225          {
226            return false;
227          }
228        }
229    
230        if (recipientID == null)
231        {
232          return (i.recipientID == null);
233        }
234        else
235        {
236          return recipientID.equals(i.recipientID);
237        }
238      }
239    
240    
241    
242      /**
243       * Retrieves a string representation of this supported OTP delivery mechanism
244       * info object.
245       *
246       * @return  A string representation of this supported OTP delivery mechanism
247       *          object.
248       */
249      @Override()
250      public String toString()
251      {
252        final StringBuilder buffer = new StringBuilder();
253        toString(buffer);
254        return buffer.toString();
255      }
256    
257    
258    
259      /**
260       * Appends a string representation of this supported OTP delivery mechanism
261       * info object to the provided buffer.
262       *
263       * @param  buffer  The buffer to which the information should be appended.
264       */
265      public void toString(final StringBuilder buffer)
266      {
267        buffer.append("SupportedOTPDeliveryMechanismInfo(mechanism='");
268        buffer.append(deliveryMechanism);
269        buffer.append('\'');
270    
271        if (isSupported != null)
272        {
273          buffer.append(", isSupported=");
274          buffer.append(isSupported);
275        }
276    
277        if (recipientID != null)
278        {
279          buffer.append(", recipientID='");
280          buffer.append(recipientID);
281          buffer.append('\'');
282        }
283        buffer.append(')');
284      }
285    }