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