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