Mail Util d365fo x++

Mail Util d365fo x++

Code:

public class DSPMMailUtil
{
    str                     emailBody, emailSubject;
    List                    emailToList;
    List                    emailCCList;
    System.IO.Stream        fileStream;
    Filename                fileName;
    SysMailerMessageBuilder messageBuilder;
    str                     message;
    str                     template;
    boolean                 sendInteractive = false;
    str                     emailFrom = SysEmailParameters::find().SMTPUserName;
    Common                  common;

    public static DSPMMailUtil construct()
    {
        return new DSPMMailUtil();
    }

    public str parmTemplate(str _template = template)
    {
        template = _template;
        return template;
    }

    public Common parmCommon(Common _common = common)
    {
        common = _common;
        return common;
    }

    public str parmMessage(str _message = message)
    {
        message = _message;
        return Message;
    }

    public str parmEmailBody(str _emailBody = emailBody)
    {
        emailBody = _emailBody;
        return emailBody;
    }

    public str parmEmailSubject(str _emailSubject = emailSubject)
    {
        emailSubject = _emailSubject;
        return emailSubject;
    }

    public Filename parmFilename(Filename _Filename = Filename)
    {
        Filename = _Filename;
        return Filename;
    }

    public System.IO.Stream parmFileStream(System.IO.Stream _fileStream = fileStream)
    {
        fileStream = _fileStream;
        return fileStream;
    }

    public List parmEmailList(List _emailToList = emailToList)
    {
        emailToList = _emailToList;
        return emailToList;
    }

    public List parmEmailCCList(List _emailCCList = emailCCList)
    {
        emailCCList = _emailCCList;
        return emailCCList;
    }

    public void addEmailTo(Email _emailTo)
    {
        if(!emailToList)
            emailToList = new List(Types::String);

        emailToList.addEnd(_emailTo);
    }

    public void addEmailCC(Email _emailCC)
    {
        if(!emailCCList)
            emailCCList = new List(Types::String);

        emailCCList.addEnd(_emailCC);
    }

    public void addWorkerTo(HcmPersonnelNumberId _employeeId)
    {
        this.addEmailTo(HcmWorker::findByPersonnelNumber(_employeeId).email());
    }

    public void addWorkerCC(HcmPersonnelNumberId _employeeId)
    {
        this.addEmailCC(HcmWorker::findByPersonnelNumber(_employeeId).email());
    }

    public boolean parmSendInteractive(boolean _sendInteractive = sendInteractive)
    {
        sendInteractive = _sendInteractive;
        return sendInteractive;
    }

    public boolean send()
    {
        boolean         ret;
        ListEnumerator  emailListEnumerator;
        ListEnumerator  ccListEnumerator;
        System.Exception exception;

        if(this.validateParms())
        {
            try
            {
                messageBuilder = new SysMailerMessageBuilder();
                messageBuilder.setFrom(emailFrom);
                messageBuilder.setSubject(emailSubject);
                
                if(template)
                {
                    messageBuilder.setBody(this.generateMapping(), true);
                }
                else
                {
                    messageBuilder.setBody(emailBody, false);
                }


                emailListEnumerator = emailToList.getEnumerator();
                
                if(emailCCList)
                {
                    ccListEnumerator    = emailCCList.getEnumerator();

                    while(ccListEnumerator.moveNext())
                    {
                        messageBuilder.addCc(any2Str(ccListEnumerator.current()));
                    }
                }
                

                while(emailListEnumerator.moveNext())
                {
                    messageBuilder.addTo(any2Str(emailListEnumerator.current()));
                }

                if(fileStream)
                {
                    messageBuilder.addAttachment(fileStream,fileName);
                }

                ret     = this.sendEmail(messageBuilder.getMessage(),sendInteractive);
                Message = 'Email Sent Successfully.';
            }
            catch (Exception::Error)
            {
                ret     = false;
                Message = 'Error in sending Email';
                error(Message);
            }
            catch (exception)
            {
                ret     = false;
                Message = strFmt('Error in sending Email- %1-%2', emailSubject, exception.Message);
                error(Message);
            }
            catch
            {
                ret     = false;
                Message = strFmt('Error in sending Email- %1', emailSubject);
                error(Message);
            }
        }
        return ret;
    }

    private boolean validateParms()
    {
        boolean ret;
        ;

        ret = true;

        if(!emailToList)
        {
            Message = 'Email List is Empty';
            error(Message);
            ret = false;
        }
        else if(!emailFrom)
        {
            Message = 'SMTP Username must be filled in';
            error(Message);
            ret = false;
        }
        else
        {
            Email toEmail;
            ListEnumerator  emailListEnumerator;
            emailListEnumerator = emailToList.getEnumerator();

            while(emailListEnumerator.moveNext())
            {
                toEmail = any2Str(emailListEnumerator.current());
                
                if(toEmail && toEmail != '')
                {
                    ret = true;
                    break;
                }
                else
                {
                    ret = false;
                }
            }

            DSPMUtil::showWarning(!ret, 'Email is empty');
        }
        return ret;
    }

    private boolean sendEmail(System.Net.Mail.MailMessage _mailMessage, boolean _intractive)
    {
        boolean                     messageSent;
        SysIMailerNonInteractive    nonInteractiveMailer;
        SysIMailerInteractive       interactiveMailer;
        
        
        if(_intractive)
        {
            messageSent = SysMailerFactory::sendInteractive(_mailMessage);
        }
        else
        {
            messageSent = SysMailerFactory::sendNonInteractive(_mailMessage);
        }
        

        return messageSent;
    }

    public Notes generateMapping()
    {
        SYSTABLEFIELDIDVIEW     SYSTABLEFIELDIDVIEW;
        Map                     map = new Map(Types::String,Types::String);

        SysDictTable    dictTable = new SysDictTable(common.TableId);
        SysDictField    dictField;
        FieldId         fieldId = dictTable.fieldNext(0);

        while (fieldId && !isSysId(fieldId))
        {
            select SYSTABLEFIELDIDVIEW  where SYSTABLEFIELDIDVIEW.ID == common.TableId && SYSTABLEFIELDIDVIEW.FIELDID == fieldId;
            map.insert(SYSTABLEFIELDIDVIEW.name, strFmt("%1", common.(fieldId)));
            fieldId = dictTable.fieldNext(fieldId);
        }
        
        message      = SysEmailMessageTable::find(template, companyinfo::languageId()).Mail;
        emailSubject = SysEmailMessageTable::find(template, companyinfo::languageId()).Subject;
        Notes result = SysEmailMessage::stringExpand(message, SysEmailTable::htmlEncodeParameters(map));
        return result;
    }

}