Send Email With Attachment using sysoutgoing email table in D365fo X++

 Send Email With Attachment using sysoutgoing email table in D365fo X++

Code:

class DSASendReportAsEmailAttachmentServiceclass extends SysOperationServiceBase
{
    
    Map           mappings = new Map(Types::String,Types::String);
    //Args          _args;


    public void process()
    {
        custTable     custTable;

        while select custTable  
        where custTable.AccountNum == '10-30001'
        {
            this.generateAndSendCustStatementReport(custTable.AccountNum);
        }
    }

    public void generateAndSendCustStatementReport(CustAccount  _custAccount)
    {
        //Set  variables
        custTable                       custTable;
        Array                           arrayFiles;
        SRSProxy                        srsProxy;
        Map                             reportParametersMap;
        SRSPrintDestinationSettings     settings;
        SrsReportRunController          formLetterController = ZACustStatementReportController::construct();
        ZACustStatementReportController      controller = formLetterController;
        ZACustStatementReportContract   contract = new ZACustStatementReportContract();
        System.Byte[]                   reportBytes = new System.Byte[0]();
        SRSReportRunService             srsReportRunService = new SrsReportRunService();
        SRSReportExecutionInfo          executionInfo = new SRSReportExecutionInfo();
        TransDate                       _fromDate, _toDate;
        SysEmailRecipients              recipientEmailAddr;

        Microsoft.Dynamics.AX.Framework.Reporting.Shared.ReportingService.ParameterValue[] parameterValueArray;
        
        
        Filename    fileName  =  _custAccount + '.pdf';

        ////Get FromDate & ToDate
        _fromDate = this.templatePeriod();
        _toDate =  today();

        //set the report contract parameters
        contract.parmFromDate(_fromDate);
        contract.parmToDate(_toDate);
        contract.parmCustAccount(_custAccount);


        //set the report controller parameters & set report name and design name
        //controller.parmArgs(_args);
        controller.parmReportName(ssrsReportStr(ZACustStatementReport, Report));
        controller.parmShowDialog(false);
        controller.parmLoadFromSysLastValue(false);
        controller.parmReportContract().parmRdpContract(contract);

        // Provide printer settings
        settings = controller.parmReportContract().parmPrintSettings();
        settings.printMediumType(SRSPrintMediumType::File);
        settings.fileName(fileName);
        settings.fileFormat(SRSReportFileFormat::PDF);

        // Below is a part of code responsible for rendering the report
        controller.parmReportContract().parmReportServerConfig(SRSConfiguration::getDefaultServerConfiguration());
        controller.parmReportContract().parmReportExecutionInfo(executionInfo);
        srsReportRunService.getReportDataContract(controller.parmreportcontract().parmReportName());
        srsReportRunService.preRunReport(controller.parmreportcontract());
        reportParametersMap = srsReportRunService.createParamMapFromContract(controller.parmReportContract());
        parameterValueArray = SrsReportRunUtil::getParameterValueArray(reportParametersMap);
        srsProxy = SRSProxy::constructWithConfiguration(controller.parmReportContract().parmReportServerConfig());

        // Actual rendering to byte array
        reportBytes = srsproxy.renderReportToByteArray(controller.parmreportcontract().parmreportpath(),
                                                        parameterValueArray,
                                                        settings.fileFormat(),
                                                        settings.deviceinfo());

        // You can also convert the report Bytes into an xpp BinData object if needed
        container binData;
        Binary binaryData;
        System.IO.MemoryStream mstream = new System.IO.MemoryStream(reportBytes);
        binaryData = Binary::constructFromMemoryStream(mstream);

        if (binaryData)
        {
            binData = binaryData.getContainer();
        }

        

        Email mail = this.getEmail(_custAccount);

        if(mail)
        {
            //Getting recipient Email Address
            recipientEmailAddr = mail;

            //Inserting Data into Map
            this.populateEmailMessageMap(_custAccount);

            //Send email using sysoutgoing email
            this.sendEmailWithAttachment(binData, fileName, recipientEmailAddr);
        }
        else
        {
            throw error("Mail Not Found!");
        }
        
    }

    /// <summary>
    /// sendEmailWithAttachment using sysoutgoing email table
    /// </summary>
    /// <param name = "_binData">container</param>
    /// <param name = "_fileName">str</param>
    /// <param name = "_recipientEmailAddr">SysEmailRecipients</param>
    public void sendEmailWithAttachment(container _binData, str _fileName, SysEmailRecipients _recipientEmailAddr)
    {
        DSNotificationEmailTemplate     DSNotificationEmailTemplate;
        SysEmailItemId                  nextEmailItemId;
        SysEmailContents                sysEmailContents;
        SysOutgoingEmailTable           outgoingEmailTable;
        SysOutgoingEmailData            outgoingEmailData;
        str                             subject;
        Filename                        fileExtension = ".pdf";

        
        [DSNotificationEmailTemplate, subject, sysEmailContents] = this.getEmailTemplateDetails();

        if (DSNotificationEmailTemplate.RecId > 0)
        {
            nextEmailItemId  = EventInbox::nextEventId();
      
     
            outgoingEmailTable.clear();
            outgoingEmailTable.Origin                       = DSNotificationEmailTemplate.TemplateId;
            outgoingEmailTable.EmailItemId                  = nextEmailItemId;
            outgoingEmailTable.IsSystemEmail                = NoYes::Yes;
            outgoingEmailTable.Sender                       = SysUserInfo::find(curUserId()).Email;
            outgoingEmailTable.SenderName                   = SysUserInfo::find(curUserId()).Id;
            outgoingEmailTable.Recipient                    = _recipientEmailAddr;
            outgoingEmailTable.Subject                      = subject;
            outgoingEmailTable.Priority                     = eMailPriority::High;
            outgoingEmailTable.WithRetries                  = NoYes::No;
            outgoingEmailTable.RetryNum                     = 0;
            outgoingEmailTable.UserId                       = curUserId();
            outgoingEmailTable.Status                       = SysEmailStatus::Unsent;
            outgoingEmailTable.Message                      =  sysEmailContents;
            outgoingEmailTable.LatestStatusChangeDateTime   = DateTimeUtil::getSystemDateTime();
            outgoingEmailTable.TemplateId                   = DSNotificationEmailTemplate.TemplateId;
            outgoingEmailTable.insert();

            if (conLen(_binData) > 0)
            {
                outgoingEmailData.clear();
                outgoingEmailData.EmailItemId               = nextEmailItemId;
                outgoingEmailData.DataId                    = 1;
                outgoingEmailData.EmailDataType             = SysEmailDataType::Attachment;
                outgoingEmailData.Data                      = _binData;
                outgoingEmailData.FileName                  = _filename;
                outgoingEmailData.FileExtension             = fileExtension;
                outgoingEmailData.insert();
            }
        }
        
    }

    /// <summary>
    /// getEmailTemplateDetails
    /// </summary>
    /// <returns>container</returns>
    private container getEmailTemplateDetails()
    {
        DSNotificationSendingTemplate   DSNotificationSendingTemplate;
        DSNotificationEmailTemplate     DSNotificationEmailTemplate;
        DSNotifications                 DSNotifications;
        DSHRGroup                       DSHRGroup;
        DSHRGroupWorkers                DSHRGroupWorkers;
        SysEmailContents                sysEmailContents;
        str                             subject;

        

        select DSNotifications

            join DSNotificationSendingTemplate
            where DSNotificationSendingTemplate.NotificationType == DSNotifications.NotificationType
            && DSNotificationSendingTemplate.NotificationType == DSNotificationType::ZACustStatementReport

            join DSNotificationEmailTemplate
            where DSNotificationSendingTemplate.TemplateId == DSNotificationEmailTemplate.TEMPLATEID

            join DSHRGroup
            where DSNotificationSendingTemplate.NotificationWorkerGroup == DSHRGroup.RecId

            join DSHRGroupWorkers
            where DSHRGroupWorkers.RefRecId == DSHRGroup.RecId;

        subject = SysEmailMessage::stringExpand(DSNotificationEmailTemplate.mailSubject, mappings);
        sysEmailContents =  SysEmailMessage::stringExpand(DSNotificationEmailTemplate.mailBody, mappings);

        return [DSNotificationEmailTemplate, subject, sysEmailContents];
    }

    private LogisticsElectronicAddressLocator getEmail(CustAccount  _custAccount)
    {
        LogisticsElectronicAddress  logisticsElectronicAddress;
        HcmWorker                   hcmWorker;
        DirPerson                   dirPerson;
        DirPartyTable               dirPartyTable;

        CustTable custTable = custTable::find(_custAccount);

        select hcmWorker
        where hcmWorker.RecId == custTable.MainContactWorker
        join dirPerson
        where dirPerson.RecId == hcmWorker.Person
        join dirPartyTable
        where dirPartyTable.RecId == dirPerson.RecId
        join logisticsElectronicAddress
        where dirPartyTable.PrimaryContactEmail == logisticsElectronicAddress.RecId;

        return logisticsElectronicAddress.Locator;
    }

    private Email getCustResMail(CustAccount  _custAccount)
    {
        CustTable custTable = custTable::find(_custAccount);
        Email mail = HcmWorker::findByPerson(custTable.MainContactWorker).email();

        return mail;
    }

    private TransDate templatePeriod()
    {
        DSNotifications DSNotifications;
        TransDate       TransDate;

        select DSNotifications
            where DSNotifications.NotificationType == DSNotificationType::ZACustStatementReport;

        if(DSNotifications.DSATimePeriodEnum == DSATimePeriodEnum::LastWeek)
        {
            TransDate = systemDateGet() -7;
        }
        else if(DSNotifications.DSATimePeriodEnum == DSATimePeriodEnum::LastMonth)
        {
            TransDate = prevMth(systemDateGet());
        }

        return TransDate;

    }

    /// <summary>
    /// populate map for email place holders
    /// </summary>
    private void populateEmailMessageMap(CustAccount  _custAccount )
    {
        custTable   custTable = CustTable::find(_custAccount);

        while select custTable
        {
            mappings.insert("custAccount", strFmt("%1", custTable.AccountNum));
            mappings.insert("Customer", strFmt("%1", custTable.name()));

        }
    }

}