001    /*
002     * CDDL HEADER START
003     *
004     * The contents of this file are subject to the terms of the
005     * Common Development and Distribution License, Version 1.0 only
006     * (the "License").  You may not use this file except in compliance
007     * with the License.
008     *
009     * You can obtain a copy of the license at
010     * trunk/opends/resource/legal-notices/OpenDS.LICENSE
011     * or https://OpenDS.dev.java.net/OpenDS.LICENSE.
012     * See the License for the specific language governing permissions
013     * and limitations under the License.
014     *
015     * When distributing Covered Code, include this CDDL HEADER in each
016     * file and include the License file at
017     * trunk/opends/resource/legal-notices/OpenDS.LICENSE.  If applicable,
018     * add the following below this CDDL HEADER, with the fields enclosed
019     * by brackets "[]" replaced with your own identifying information:
020     *      Portions Copyright [yyyy] [name of copyright owner]
021     *
022     * CDDL HEADER END
023     *
024     *
025     *      Copyright 2008 Sun Microsystems, Inc.
026     */
027    package org.opends.server.admin.std.meta;
028    
029    
030    
031    import java.util.Collection;
032    import java.util.SortedSet;
033    import org.opends.server.admin.AdministratorAction;
034    import org.opends.server.admin.AliasDefaultBehaviorProvider;
035    import org.opends.server.admin.AttributeTypePropertyDefinition;
036    import org.opends.server.admin.BooleanPropertyDefinition;
037    import org.opends.server.admin.ClassPropertyDefinition;
038    import org.opends.server.admin.client.AuthorizationException;
039    import org.opends.server.admin.client.CommunicationException;
040    import org.opends.server.admin.client.ConcurrentModificationException;
041    import org.opends.server.admin.client.ManagedObject;
042    import org.opends.server.admin.client.MissingMandatoryPropertiesException;
043    import org.opends.server.admin.client.OperationRejectedException;
044    import org.opends.server.admin.DefaultBehaviorProvider;
045    import org.opends.server.admin.DefinedDefaultBehaviorProvider;
046    import org.opends.server.admin.ManagedObjectAlreadyExistsException;
047    import org.opends.server.admin.ManagedObjectDefinition;
048    import org.opends.server.admin.PropertyOption;
049    import org.opends.server.admin.PropertyProvider;
050    import org.opends.server.admin.server.ConfigurationChangeListener;
051    import org.opends.server.admin.server.ServerManagedObject;
052    import org.opends.server.admin.std.client.SMTPAccountStatusNotificationHandlerCfgClient;
053    import org.opends.server.admin.std.server.AccountStatusNotificationHandlerCfg;
054    import org.opends.server.admin.std.server.SMTPAccountStatusNotificationHandlerCfg;
055    import org.opends.server.admin.StringPropertyDefinition;
056    import org.opends.server.admin.Tag;
057    import org.opends.server.admin.UndefinedDefaultBehaviorProvider;
058    import org.opends.server.types.AttributeType;
059    import org.opends.server.types.DN;
060    
061    
062    
063    /**
064     * An interface for querying the SMTP Account Status Notification
065     * Handler managed object definition meta information.
066     * <p>
067     * The SMTP Account Status Notification Handler is a notification
068     * handler that sends email messages to end users and/or administrators
069     * whenever an account status notification is generated.
070     */
071    public final class SMTPAccountStatusNotificationHandlerCfgDefn extends ManagedObjectDefinition<SMTPAccountStatusNotificationHandlerCfgClient, SMTPAccountStatusNotificationHandlerCfg> {
072    
073      // The singleton configuration definition instance.
074      private static final SMTPAccountStatusNotificationHandlerCfgDefn INSTANCE = new SMTPAccountStatusNotificationHandlerCfgDefn();
075    
076    
077    
078      // The "email-address-attribute-type" property definition.
079      private static final AttributeTypePropertyDefinition PD_EMAIL_ADDRESS_ATTRIBUTE_TYPE;
080    
081    
082    
083      // The "java-class" property definition.
084      private static final ClassPropertyDefinition PD_JAVA_CLASS;
085    
086    
087    
088      // The "message-subject" property definition.
089      private static final StringPropertyDefinition PD_MESSAGE_SUBJECT;
090    
091    
092    
093      // The "message-template-file" property definition.
094      private static final StringPropertyDefinition PD_MESSAGE_TEMPLATE_FILE;
095    
096    
097    
098      // The "recipient-address" property definition.
099      private static final StringPropertyDefinition PD_RECIPIENT_ADDRESS;
100    
101    
102    
103      // The "sender-address" property definition.
104      private static final StringPropertyDefinition PD_SENDER_ADDRESS;
105    
106    
107    
108      // The "send-message-without-end-user-address" property definition.
109      private static final BooleanPropertyDefinition PD_SEND_MESSAGE_WITHOUT_END_USER_ADDRESS;
110    
111    
112    
113      // Build the "email-address-attribute-type" property definition.
114      static {
115          AttributeTypePropertyDefinition.Builder builder = AttributeTypePropertyDefinition.createBuilder(INSTANCE, "email-address-attribute-type");
116          builder.setOption(PropertyOption.MULTI_VALUED);
117          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "email-address-attribute-type"));
118          builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<AttributeType>(INSTANCE, "email-address-attribute-type"));
119          PD_EMAIL_ADDRESS_ATTRIBUTE_TYPE = builder.getInstance();
120          INSTANCE.registerPropertyDefinition(PD_EMAIL_ADDRESS_ATTRIBUTE_TYPE);
121      }
122    
123    
124    
125      // Build the "java-class" property definition.
126      static {
127          ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class");
128          builder.setOption(PropertyOption.MANDATORY);
129          builder.setOption(PropertyOption.ADVANCED);
130          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "java-class"));
131          DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("org.opends.server.extensions.SMTPAccountStatusNotificationHandler");
132          builder.setDefaultBehaviorProvider(provider);
133          builder.addInstanceOf("org.opends.server.api.AccountStatusNotificationHandler");
134          PD_JAVA_CLASS = builder.getInstance();
135          INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
136      }
137    
138    
139    
140      // Build the "message-subject" property definition.
141      static {
142          StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "message-subject");
143          builder.setOption(PropertyOption.MULTI_VALUED);
144          builder.setOption(PropertyOption.MANDATORY);
145          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "message-subject"));
146          builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
147          PD_MESSAGE_SUBJECT = builder.getInstance();
148          INSTANCE.registerPropertyDefinition(PD_MESSAGE_SUBJECT);
149      }
150    
151    
152    
153      // Build the "message-template-file" property definition.
154      static {
155          StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "message-template-file");
156          builder.setOption(PropertyOption.MULTI_VALUED);
157          builder.setOption(PropertyOption.MANDATORY);
158          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "message-template-file"));
159          builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
160          PD_MESSAGE_TEMPLATE_FILE = builder.getInstance();
161          INSTANCE.registerPropertyDefinition(PD_MESSAGE_TEMPLATE_FILE);
162      }
163    
164    
165    
166      // Build the "recipient-address" property definition.
167      static {
168          StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "recipient-address");
169          builder.setOption(PropertyOption.MULTI_VALUED);
170          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "recipient-address"));
171          builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<String>(INSTANCE, "recipient-address"));
172          PD_RECIPIENT_ADDRESS = builder.getInstance();
173          INSTANCE.registerPropertyDefinition(PD_RECIPIENT_ADDRESS);
174      }
175    
176    
177    
178      // Build the "sender-address" property definition.
179      static {
180          StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "sender-address");
181          builder.setOption(PropertyOption.MANDATORY);
182          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "sender-address"));
183          builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
184          PD_SENDER_ADDRESS = builder.getInstance();
185          INSTANCE.registerPropertyDefinition(PD_SENDER_ADDRESS);
186      }
187    
188    
189    
190      // Build the "send-message-without-end-user-address" property definition.
191      static {
192          BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "send-message-without-end-user-address");
193          builder.setOption(PropertyOption.MANDATORY);
194          builder.setOption(PropertyOption.ADVANCED);
195          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "send-message-without-end-user-address"));
196          DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true");
197          builder.setDefaultBehaviorProvider(provider);
198          PD_SEND_MESSAGE_WITHOUT_END_USER_ADDRESS = builder.getInstance();
199          INSTANCE.registerPropertyDefinition(PD_SEND_MESSAGE_WITHOUT_END_USER_ADDRESS);
200      }
201    
202    
203    
204      // Register the tags associated with this managed object definition.
205      static {
206        INSTANCE.registerTag(Tag.valueOf("user-management"));
207      }
208    
209    
210    
211      /**
212       * Get the SMTP Account Status Notification Handler configuration
213       * definition singleton.
214       *
215       * @return Returns the SMTP Account Status Notification Handler
216       *         configuration definition singleton.
217       */
218      public static SMTPAccountStatusNotificationHandlerCfgDefn getInstance() {
219        return INSTANCE;
220      }
221    
222    
223    
224      /**
225       * Private constructor.
226       */
227      private SMTPAccountStatusNotificationHandlerCfgDefn() {
228        super("smtp-account-status-notification-handler", AccountStatusNotificationHandlerCfgDefn.getInstance());
229      }
230    
231    
232    
233      /**
234       * {@inheritDoc}
235       */
236      public SMTPAccountStatusNotificationHandlerCfgClient createClientConfiguration(
237          ManagedObject<? extends SMTPAccountStatusNotificationHandlerCfgClient> impl) {
238        return new SMTPAccountStatusNotificationHandlerCfgClientImpl(impl);
239      }
240    
241    
242    
243      /**
244       * {@inheritDoc}
245       */
246      public SMTPAccountStatusNotificationHandlerCfg createServerConfiguration(
247          ServerManagedObject<? extends SMTPAccountStatusNotificationHandlerCfg> impl) {
248        return new SMTPAccountStatusNotificationHandlerCfgServerImpl(impl);
249      }
250    
251    
252    
253      /**
254       * {@inheritDoc}
255       */
256      public Class<SMTPAccountStatusNotificationHandlerCfg> getServerConfigurationClass() {
257        return SMTPAccountStatusNotificationHandlerCfg.class;
258      }
259    
260    
261    
262      /**
263       * Get the "email-address-attribute-type" property definition.
264       * <p>
265       * Specifies which attribute in the user's entries may be used to
266       * obtain the email address when notifying the end user.
267       * <p>
268       * You can specify more than one email address as separate values.
269       * In this case, the OpenDS server sends a notification to all email
270       * addresses identified.
271       *
272       * @return Returns the "email-address-attribute-type" property definition.
273       */
274      public AttributeTypePropertyDefinition getEmailAddressAttributeTypePropertyDefinition() {
275        return PD_EMAIL_ADDRESS_ATTRIBUTE_TYPE;
276      }
277    
278    
279    
280      /**
281       * Get the "enabled" property definition.
282       * <p>
283       * Indicates whether the SMTP Account Status Notification Handler is
284       * enabled. Only enabled handlers are invoked whenever a related
285       * event occurs in the server.
286       *
287       * @return Returns the "enabled" property definition.
288       */
289      public BooleanPropertyDefinition getEnabledPropertyDefinition() {
290        return AccountStatusNotificationHandlerCfgDefn.getInstance().getEnabledPropertyDefinition();
291      }
292    
293    
294    
295      /**
296       * Get the "java-class" property definition.
297       * <p>
298       * Specifies the fully-qualified name of the Java class that
299       * provides the SMTP Account Status Notification Handler
300       * implementation.
301       *
302       * @return Returns the "java-class" property definition.
303       */
304      public ClassPropertyDefinition getJavaClassPropertyDefinition() {
305        return PD_JAVA_CLASS;
306      }
307    
308    
309    
310      /**
311       * Get the "message-subject" property definition.
312       * <p>
313       * Specifies the subject that should be used for email messages
314       * generated by this account status notification handler.
315       * <p>
316       * The values for this property should begin with the name of an
317       * account status notification type followed by a colon and the
318       * subject that should be used for the associated notification
319       * message. If an email message is generated for an account status
320       * notification type for which no subject is defined, then that
321       * message is given a generic subject.
322       *
323       * @return Returns the "message-subject" property definition.
324       */
325      public StringPropertyDefinition getMessageSubjectPropertyDefinition() {
326        return PD_MESSAGE_SUBJECT;
327      }
328    
329    
330    
331      /**
332       * Get the "message-template-file" property definition.
333       * <p>
334       * Specifies the path to the file containing the message template to
335       * generate the email notification messages.
336       * <p>
337       * The values for this property should begin with the name of an
338       * account status notification type followed by a colon and the path
339       * to the template file that should be used for that notification
340       * type. If an account status notification has a notification type
341       * that is not associated with a message template file, then no email
342       * message is generated for that notification.
343       *
344       * @return Returns the "message-template-file" property definition.
345       */
346      public StringPropertyDefinition getMessageTemplateFilePropertyDefinition() {
347        return PD_MESSAGE_TEMPLATE_FILE;
348      }
349    
350    
351    
352      /**
353       * Get the "recipient-address" property definition.
354       * <p>
355       * Specifies an email address to which notification messages are
356       * sent, either instead of or in addition to the end user for whom
357       * the notification has been generated.
358       * <p>
359       * This may be used to ensure that server administrators also
360       * receive a copy of any notification messages that are generated.
361       *
362       * @return Returns the "recipient-address" property definition.
363       */
364      public StringPropertyDefinition getRecipientAddressPropertyDefinition() {
365        return PD_RECIPIENT_ADDRESS;
366      }
367    
368    
369    
370      /**
371       * Get the "sender-address" property definition.
372       * <p>
373       * Specifies the email address from which the message is sent. Note
374       * that this does not necessarily have to be a legitimate email
375       * address.
376       *
377       * @return Returns the "sender-address" property definition.
378       */
379      public StringPropertyDefinition getSenderAddressPropertyDefinition() {
380        return PD_SENDER_ADDRESS;
381      }
382    
383    
384    
385      /**
386       * Get the "send-message-without-end-user-address" property definition.
387       * <p>
388       * Indicates whether an email notification message should be
389       * generated and sent to the set of notification recipients even if
390       * the user entry does not contain any values for any of the email
391       * address attributes (that is, in cases when it is not be possible
392       * to notify the end user).
393       * <p>
394       * This is only applicable if both one or more email address
395       * attribute types and one or more additional recipient addresses are
396       * specified.
397       *
398       * @return Returns the "send-message-without-end-user-address" property definition.
399       */
400      public BooleanPropertyDefinition getSendMessageWithoutEndUserAddressPropertyDefinition() {
401        return PD_SEND_MESSAGE_WITHOUT_END_USER_ADDRESS;
402      }
403    
404    
405    
406      /**
407       * Managed object client implementation.
408       */
409      private static class SMTPAccountStatusNotificationHandlerCfgClientImpl implements
410        SMTPAccountStatusNotificationHandlerCfgClient {
411    
412        // Private implementation.
413        private ManagedObject<? extends SMTPAccountStatusNotificationHandlerCfgClient> impl;
414    
415    
416    
417        // Private constructor.
418        private SMTPAccountStatusNotificationHandlerCfgClientImpl(
419            ManagedObject<? extends SMTPAccountStatusNotificationHandlerCfgClient> impl) {
420          this.impl = impl;
421        }
422    
423    
424    
425        /**
426         * {@inheritDoc}
427         */
428        public SortedSet<AttributeType> getEmailAddressAttributeType() {
429          return impl.getPropertyValues(INSTANCE.getEmailAddressAttributeTypePropertyDefinition());
430        }
431    
432    
433    
434        /**
435         * {@inheritDoc}
436         */
437        public void setEmailAddressAttributeType(Collection<AttributeType> values) {
438          impl.setPropertyValues(INSTANCE.getEmailAddressAttributeTypePropertyDefinition(), values);
439        }
440    
441    
442    
443        /**
444         * {@inheritDoc}
445         */
446        public Boolean isEnabled() {
447          return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
448        }
449    
450    
451    
452        /**
453         * {@inheritDoc}
454         */
455        public void setEnabled(boolean value) {
456          impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value);
457        }
458    
459    
460    
461        /**
462         * {@inheritDoc}
463         */
464        public String getJavaClass() {
465          return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
466        }
467    
468    
469    
470        /**
471         * {@inheritDoc}
472         */
473        public void setJavaClass(String value) {
474          impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
475        }
476    
477    
478    
479        /**
480         * {@inheritDoc}
481         */
482        public SortedSet<String> getMessageSubject() {
483          return impl.getPropertyValues(INSTANCE.getMessageSubjectPropertyDefinition());
484        }
485    
486    
487    
488        /**
489         * {@inheritDoc}
490         */
491        public void setMessageSubject(Collection<String> values) {
492          impl.setPropertyValues(INSTANCE.getMessageSubjectPropertyDefinition(), values);
493        }
494    
495    
496    
497        /**
498         * {@inheritDoc}
499         */
500        public SortedSet<String> getMessageTemplateFile() {
501          return impl.getPropertyValues(INSTANCE.getMessageTemplateFilePropertyDefinition());
502        }
503    
504    
505    
506        /**
507         * {@inheritDoc}
508         */
509        public void setMessageTemplateFile(Collection<String> values) {
510          impl.setPropertyValues(INSTANCE.getMessageTemplateFilePropertyDefinition(), values);
511        }
512    
513    
514    
515        /**
516         * {@inheritDoc}
517         */
518        public SortedSet<String> getRecipientAddress() {
519          return impl.getPropertyValues(INSTANCE.getRecipientAddressPropertyDefinition());
520        }
521    
522    
523    
524        /**
525         * {@inheritDoc}
526         */
527        public void setRecipientAddress(Collection<String> values) {
528          impl.setPropertyValues(INSTANCE.getRecipientAddressPropertyDefinition(), values);
529        }
530    
531    
532    
533        /**
534         * {@inheritDoc}
535         */
536        public String getSenderAddress() {
537          return impl.getPropertyValue(INSTANCE.getSenderAddressPropertyDefinition());
538        }
539    
540    
541    
542        /**
543         * {@inheritDoc}
544         */
545        public void setSenderAddress(String value) {
546          impl.setPropertyValue(INSTANCE.getSenderAddressPropertyDefinition(), value);
547        }
548    
549    
550    
551        /**
552         * {@inheritDoc}
553         */
554        public boolean isSendMessageWithoutEndUserAddress() {
555          return impl.getPropertyValue(INSTANCE.getSendMessageWithoutEndUserAddressPropertyDefinition());
556        }
557    
558    
559    
560        /**
561         * {@inheritDoc}
562         */
563        public void setSendMessageWithoutEndUserAddress(boolean value) {
564          impl.setPropertyValue(INSTANCE.getSendMessageWithoutEndUserAddressPropertyDefinition(), value);
565        }
566    
567    
568    
569        /**
570         * {@inheritDoc}
571         */
572        public ManagedObjectDefinition<? extends SMTPAccountStatusNotificationHandlerCfgClient, ? extends SMTPAccountStatusNotificationHandlerCfg> definition() {
573          return INSTANCE;
574        }
575    
576    
577    
578        /**
579         * {@inheritDoc}
580         */
581        public PropertyProvider properties() {
582          return impl;
583        }
584    
585    
586    
587        /**
588         * {@inheritDoc}
589         */
590        public void commit() throws ManagedObjectAlreadyExistsException,
591            MissingMandatoryPropertiesException, ConcurrentModificationException,
592            OperationRejectedException, AuthorizationException,
593            CommunicationException {
594          impl.commit();
595        }
596    
597      }
598    
599    
600    
601      /**
602       * Managed object server implementation.
603       */
604      private static class SMTPAccountStatusNotificationHandlerCfgServerImpl implements
605        SMTPAccountStatusNotificationHandlerCfg {
606    
607        // Private implementation.
608        private ServerManagedObject<? extends SMTPAccountStatusNotificationHandlerCfg> impl;
609    
610        // The value of the "email-address-attribute-type" property.
611        private final SortedSet<AttributeType> pEmailAddressAttributeType;
612    
613        // The value of the "enabled" property.
614        private final boolean pEnabled;
615    
616        // The value of the "java-class" property.
617        private final String pJavaClass;
618    
619        // The value of the "message-subject" property.
620        private final SortedSet<String> pMessageSubject;
621    
622        // The value of the "message-template-file" property.
623        private final SortedSet<String> pMessageTemplateFile;
624    
625        // The value of the "recipient-address" property.
626        private final SortedSet<String> pRecipientAddress;
627    
628        // The value of the "sender-address" property.
629        private final String pSenderAddress;
630    
631        // The value of the "send-message-without-end-user-address" property.
632        private final boolean pSendMessageWithoutEndUserAddress;
633    
634    
635    
636        // Private constructor.
637        private SMTPAccountStatusNotificationHandlerCfgServerImpl(ServerManagedObject<? extends SMTPAccountStatusNotificationHandlerCfg> impl) {
638          this.impl = impl;
639          this.pEmailAddressAttributeType = impl.getPropertyValues(INSTANCE.getEmailAddressAttributeTypePropertyDefinition());
640          this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
641          this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
642          this.pMessageSubject = impl.getPropertyValues(INSTANCE.getMessageSubjectPropertyDefinition());
643          this.pMessageTemplateFile = impl.getPropertyValues(INSTANCE.getMessageTemplateFilePropertyDefinition());
644          this.pRecipientAddress = impl.getPropertyValues(INSTANCE.getRecipientAddressPropertyDefinition());
645          this.pSenderAddress = impl.getPropertyValue(INSTANCE.getSenderAddressPropertyDefinition());
646          this.pSendMessageWithoutEndUserAddress = impl.getPropertyValue(INSTANCE.getSendMessageWithoutEndUserAddressPropertyDefinition());
647        }
648    
649    
650    
651        /**
652         * {@inheritDoc}
653         */
654        public void addSMTPChangeListener(
655            ConfigurationChangeListener<SMTPAccountStatusNotificationHandlerCfg> listener) {
656          impl.registerChangeListener(listener);
657        }
658    
659    
660    
661        /**
662         * {@inheritDoc}
663         */
664        public void removeSMTPChangeListener(
665            ConfigurationChangeListener<SMTPAccountStatusNotificationHandlerCfg> listener) {
666          impl.deregisterChangeListener(listener);
667        }
668        /**
669         * {@inheritDoc}
670         */
671        public void addChangeListener(
672            ConfigurationChangeListener<AccountStatusNotificationHandlerCfg> listener) {
673          impl.registerChangeListener(listener);
674        }
675    
676    
677    
678        /**
679         * {@inheritDoc}
680         */
681        public void removeChangeListener(
682            ConfigurationChangeListener<AccountStatusNotificationHandlerCfg> listener) {
683          impl.deregisterChangeListener(listener);
684        }
685    
686    
687    
688        /**
689         * {@inheritDoc}
690         */
691        public SortedSet<AttributeType> getEmailAddressAttributeType() {
692          return pEmailAddressAttributeType;
693        }
694    
695    
696    
697        /**
698         * {@inheritDoc}
699         */
700        public boolean isEnabled() {
701          return pEnabled;
702        }
703    
704    
705    
706        /**
707         * {@inheritDoc}
708         */
709        public String getJavaClass() {
710          return pJavaClass;
711        }
712    
713    
714    
715        /**
716         * {@inheritDoc}
717         */
718        public SortedSet<String> getMessageSubject() {
719          return pMessageSubject;
720        }
721    
722    
723    
724        /**
725         * {@inheritDoc}
726         */
727        public SortedSet<String> getMessageTemplateFile() {
728          return pMessageTemplateFile;
729        }
730    
731    
732    
733        /**
734         * {@inheritDoc}
735         */
736        public SortedSet<String> getRecipientAddress() {
737          return pRecipientAddress;
738        }
739    
740    
741    
742        /**
743         * {@inheritDoc}
744         */
745        public String getSenderAddress() {
746          return pSenderAddress;
747        }
748    
749    
750    
751        /**
752         * {@inheritDoc}
753         */
754        public boolean isSendMessageWithoutEndUserAddress() {
755          return pSendMessageWithoutEndUserAddress;
756        }
757    
758    
759    
760        /**
761         * {@inheritDoc}
762         */
763        public Class<? extends SMTPAccountStatusNotificationHandlerCfg> configurationClass() {
764          return SMTPAccountStatusNotificationHandlerCfg.class;
765        }
766    
767    
768    
769        /**
770         * {@inheritDoc}
771         */
772        public DN dn() {
773          return impl.getDN();
774        }
775    
776      }
777    }