...
 <b>bis spätestens ##{(HEUTE|TODAY)([+-][0-9]{1,4})([TD]|M|[JY])}</b>
...

Beispiele:

##{HEUTE}

##{HEUTE-14T}

##{TODAY+3M}

Das BO E-Mail-Template bietet die Möglichkeit, Vorlagen für E-Mails zu erstellen, die dann aus Regeln heraus versendet werden können. Ein Administrator hat damit die Möglichkeit, die von Nuclos versendeten E-Mails selbst zu gestalten und kurzfristig zu ändern. Die Templates bieten hierzu viele Möglichkeiten:

• Der Zugriff auf beliebig weit referenzierte Attribute aus einem frei wählbaren Basis-BO (z.B Auftrag), ähnlich wie bei Nuclos-Formularen
• Verschiedene Quellen von Adressen (Attribut, Nucletparameter, Benutzer, Benutzergruppe, ...)
• Verschiedene Quellen von Anhängen (Datei, Formular, ...)
• Verschiedene Sprachen von Betreff, Nachricht und Anhang
• Textbausteine
• E-Mail-Empfänger, die E-Mail-Adresse, Anrede und Sprache der E-Mail bestimmen
• Standardisierte und konfigurierbare Footer und Signaturen
• Vorschau und Test des Templates

Komplexere E-Mail-Bestandteile, wie z.B. eine Tabelle mit allen Auftragspositionen, müssen durch eine Regel unterstützt werden.

Können Bausteine definiert werden, die dann in den E-Mail-Templates zur Verfügung stehen. Möglich sind

Textbaustein

• Reine (ggf. mehrsprachige) Standard-Textbausteine (AGB, Versandinfos, Signatur, ...)
• Bausteine, die einen Footer oder eine Signatur bereitstellen

Regelbaustein

• Komplexe Bausteine, die eine Regelunterstützung benötigen (z.B. Tabelle mit Auftragspositionen)
• Bausteine, die eine oder mehrere E-Mail-Adressen ermitteln (z.B. für Subscribe-Funktionalitäten)
• Bausteine, die eine Sprache definieren

Empfänger

• Bausteine, die den E-Mail-Empfänger (Adresse, Anrede, Sprache) definieren

Anhang

• Bausteine, die einen Anhang generieren

Versandbedingung

• Bausteine, die entscheiden, ob eine E-Mail versendet werden soll oder nicht

Zur Sicherheit lassen sich Bausteine auf bestimmte BO's einschränken, wenn z.B. wenn der Baustein Bearbeiter  für die BO's Rechnung und Auftrag existiert, aber nicht für das BO Artikel 

Zur Erzeugung einer E-Mail aus einem E-Mail-Template muss eine Instanz einer Klasse mit übergeben werden, die das Interface Regelbausteine  implementiert.

Das Nuclet bringt eine Implementierung mit, die einige Beispiele enthält. Wenn Sie eigene Regelbausteine benötigen, sollten Sie sich eine eigene Implementierung in Ihrem Nuclet anlegen, damit diese nicht überschrieben wird, wenn das E-Mail-Nuclet mal aktualisiert wird.

In der Methode EMailUtils.getRegelBausteine() dann einfach diese Implementierung erzeugen.

Nach dem Nucletimport muss einmal der Job Initialisiere Nuclet Emailversand ausgeführt werden

Der Job legt u.a. einige Standard-E-Mail-Bausteine an, so dass Sie gleich ein Template bauen können.

public String getValue(final String name, final Modifiable<Long> bo, EMailTemplateSprache language, TemplateParameters parameters, RuleContext context) throws BusinessException {
    if (SIGNATUR.equals(name)) {
        return EMailHelper.getSignature();
    } else if (RECHNUNGSPOSITIONEN.equals(name)) {
        return EMailHelper.getRechnungspositionen(bo, parameters, name);
    } 

    throw new BusinessException("Unbekannter Name für einen Regelbaustein: \"" + name + "\"");
}

@Override
public TemplateRecipient getRecipient(String name, Modifiable<Long> bo, EMailTemplateSprache language, TemplateParameters parameters) throws BusinessException {

   if (ANSPRECHPARTNER.equals(name)) {
      return EMailHelper.getTemplateRecipient(EMailHelper.getAnsprechpartner(bo, parameters, name));
   } else if (BEARBEITER.equals(name)) {
      return EMailHelper.getTemplateRecipient(EMailHelper.getBearbeiter(bo, name));

   throw new BusinessException("Unbekannter Name für einen Empfänger: \"" + name + "\"");
}

EMailTemplate template = EMailUtils.getEMailTemplate(Konstanten.EMailTemplate.RECHNUNG);
if (template.getAktiv()) {
    EMailVersand.sendMail(new EMailContext(template, EMailUtils.getRegelBausteine(), rechnung, context));
}

Die Klasse EMailTemplateKonfiguration stellt Datenstrukturen und Methoden bereit, um Sprachen, Bausteine und Templates durch Regeln zu erstellen.

Dies kann besonders bei der Nucletentwicklung hilfreich sein, um solche Objekte auf anderen Instanzen neu zu erstellen.

• Sprache
• Baustein
• Template
• Restriction
• Adresse
• Statuswechsel
• Anhang
• BausteinTranslation
• AnhangTranslation
• SubjectTranslation
• MessageTranslation

• EMailTemplate createTemplate(Template template, final JobContext context)
• void createSprache(Sprache sprache, final JobContext context)
• void insertBausteinTranslation(EMailTemplateBaustein baustein, BausteinTranslation translation)
• void insertBausteinRestriction(EMailTemplateBaustein baustein, Restriction restriction)
• EMailTemplateAnhang insertAnhang(EMailTemplate template, Anhang anhang)
• void insertStatuswechsel(EMailTemplate template, Statuswechsel statuswechsel)
• void insertAnhangTranslation(EMailTemplateAnhang anhang, AnhangTranslation translation)
• void insertBetreffTranslation(EMailTemplate template, SubjectTranslation translation)
• void insertNachrichtTranslation(EMailTemplate template, MessageTranslation translation)
• void insertAdresse(EMailTemplate template, Adresse adresse)
• EMailTemplateBaustein createBaustein(Baustein baustein, final JobContext context)

public static final EMailTemplateKonfiguration.Baustein FOOTER_INTERN = new EMailTemplateKonfiguration.Baustein() {{
   setName(RegelBausteineImpl.Footer.FOOTER_INTERN);
   setText("<br>\n<br>Vielen Dank und freundliche Grüße,\n<br>\n<br>##{" + RegelBausteineImpl.Standard.AKTUELLER_BENUTZER + "}");
   setFooter(true);
}};

public static final EMailTemplateKonfiguration.Template TEMPLATE_PROJEKT = new EMailTemplateKonfiguration.Template() {{
   setName("Projekt aktiv");
   setNuclet("org.nuclet.firma");
   setAktiv(false);
   setTable("Projekt");
   setTestID(1234567);
   setSpracheStatisch(EMailUtils.DEUTSCH);
   setSubject("Neues Projekt");
   setMessage("##{" + RegelBausteineImpl.Standard.ALLGEMEINE_ANREDE + "}" +
         "\n<br>" +
         "\n<br>das Projekt #{@Nummer} wurde soeben angelegt.");
   setFooter(RegelBausteineImpl.Footer.FOOTER_INTERN);
   setSignature(RegelBausteineImpl.Signature.SIGNATUR);
   addAddress(new EMailTemplateKonfiguration.Adresse() {{
      setAttribute("Beauftragtdurch");
      setAttributeRef("Emailbenutzer");
      setPflichtfeld(true);
   }});
}};

EMailTemplateKonfiguration.createBaustein(FOOTER_INTERN, jobContext);
EMailTemplateKonfiguration.createTemplate(TEMPLATE_PROJEKT, jobContext);

Für den Testbetrieb kann die E-Mail Umleitung aktiviert werden. Dabei werden alle ausgehenden E-Mails auf eine festgelegte Adresse umgeleitet.

In der E-Mail steht zusätzlich, an wen diese eigentlich gegangen wäre.

Für den E-Mail-Versand gibt es zwei verschiedene Möglichkeiten:

Sofort versenden

Die E-Mail wird sofort versendet. Ist der Versand von einem Benutzer angestoßen (z.B. durch einen Statuswechsel, der einen E-Mail-Versand auslöst), so muss er warten, bis dieser Vorgang abgeschlossen ist, bevor er weiter arbeiten kann. Kommt es beim E-Mail-Versand zu einem Fehler, so wird die gesamte Aktion (z.B. Statuswechsel) des Benutzers rückgängig gemacht.

Versand über Email Queue

Die E-Mail wird erst im E-Mail-Protokoll als nicht versendete E-Mail gespeichert und erst durch einen regelmäßig laufenden Job versendet (Administration > Jobsteuerung > Versende Emails). Dieser muss natürlich aktiviert sein. Der Benutzer wird dadurch bei seiner Bearbeitung nicht unnötig lange aufgehalten und ein fehlerhafter E-Mail-Versand führt nicht zum Abbruch seiner Aktion.

Der Job EMailEmpfang erzeugt für neue E-Mails auf dem in den IMAP-Systemparametern angegebenen Server einen Eintrag im E-Mail-Protokoll mit den Flags Versendet = false, Empfangen = true, Verarbeitet = false.
Das Flag Verarbeitet kann nach der erfolgreichen Weiterverarbeitung der Mail auf true gesetzt werden.

static void sendMail(EMailContext context)

static void sendMailNow(EMailContext context)

void addRecipient(String address, int type)

void addRecipient(String address)

void addRecipients(List<String> lRecipients, int type) 

void addRecipients(List<String> lRecipients)

void addAttachment(NuclosFile file) 

void addAttachments(List<NuclosFile> lAttachments)

void setReplyTo(String replyTo)

void setMessage(String message)

void setSubject(String subject)

void setReference(String reference)

void resetAttachments()

void resetRecipients()

EMailContext context = new EMailContext();
context.addRecipient(auftrag.getKundeBO.getEmailadresse());
context.addRecipient("chef@firma.de", EMailContext.BCC);
context.addAttachment(auftrag.getRechnung());
context.setSubject("Rechnung für Auftrag " + auftrag.getAuftragsnr());
context.setMessage("...");
context.setReplyTo("kundenservice@firma.de");
context.setReference(auftrag.getKundeBO().getKundennr());
EMailVersand.sendMail(context);

Query<EMailProtokoll> query = QueryProvider.create(EMailProtokoll.class);
query.where(EMailProtokoll.Empfangen.eq(Boolean.TRUE));
query.where(EMailProtokoll.Empfangeneemailverarbeitet.eq(Boolean.FALSE));
for (EMailProtokoll email : QueryProvider.execute(query)) {
    process(email, context);
    email.setEmpfangeneemailverarbeitet(Boolean.TRUE);
    email.save();
}