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 }