process.js

import("system.util");
import("Contact_lib");
import("system.datetime");
import("system.neon");
import("Employee_lib");
import("system.vars");
import("KeywordRegistry_basic");
import("Sql_lib");
import("system.db");
import("DocumentTemplate_lib");
import("Communication_lib");
import("Email_lib");
import("system.process");
import("system.notification");

/**
 * functions for bulk mails
 */
function BulkMailUtils () {}

/**
 * Executes a process to send bulk mails on the server and creates a notification when finished.
 * 
 * @param {String} pBulkMailId id of the bulk mail
 * @param {String} [pUser=currentUser] User that will get the notification, if null (not undefined!), no notification
 *                                      will be created.
 */
BulkMailUtils.sendBulkMailOnServer = function (pBulkMailId, pUser)
{
    if (pUser === undefined)
        pUser = EmployeeUtils.getCurrentUserId();
    process.execute("sendBulkMail_serverProcess", 
        {
            bulkMailId : pBulkMailId,
            user : pUser || ""
        }
    );
}

/**
 * Sends a bulk mail. You should only call this function on the server because it
 * can take some time to execute, use BulkMailUtils.sendBulkMailOnServer instead.
 * 
 * @param {String} pBulkMailId id of the bulk mail 
 * 
 * @return {Object} count of sucessful and failed mails 
 */
BulkMailUtils.sendBulkMail = function (pBulkMailId)
{
    var [templateId, subject, emailSender] = db.array(db.ROW, SqlCondition.begin()
        .andPrepare("BULKMAIL.BULKMAILID", pBulkMailId)
        .buildSql("select DOCUMENTTEMPLATE_ID, SUBJECT, SENDER from BULKMAIL", "1=2")
    );
    var template = BulkMailUtils.getBulkMailTemplate(pBulkMailId, templateId);
    
    var sql = SqlBuilder.begin()
        .select("BULKMAILRECIPIENTID, BULKMAILRECIPIENT.CONTACT_ID, (" + CommUtil.getStandardSubSqlMail() + ")")
        .from("BULKMAILRECIPIENT")
        .join("CONTACT", "BULKMAILRECIPIENT.CONTACT_ID = CONTACT.CONTACTID")
        .where(SqlCondition.begin()
            .andPrepare("BULKMAILRECIPIENT.BULKMAIL_ID", pBulkMailId)
            .andPrepare("BULKMAILRECIPIENT.STATUS", $KeywordRegistry.bulkMailRecipientStatus$sent(), "# != ?")
            .andSqlCondition(ContactUtils.getCommRestrictionCondition($KeywordRegistry.communicationMediumCampaign$mail(), true)))
        .build();
        
    var recipientData = db.table(sql);
    var contactIds = recipientData.map(function (e) {return e[1];});
    var successIds = [];
    var failedIds = [];
    var sentDate = vars.get("$sys.date");
    var mails = template.getReplacedEmailsByContactIds(contactIds);
    
    var subjectTemplate = new DocumentTemplate(subject, DocumentTemplate.types.PLAIN);
    var subjects = subjectTemplate.getReplacedContentByContactIds(contactIds);
    
    for (let i = 0, l = recipientData.length; i < l; i++)
    {
        let isSuccess = false;
        let contactId = recipientData[i][1];
        let email = mails[contactId];
        if (email !== undefined && recipientData[i][2])
        {
            email.toRecipients = [recipientData[i][2]];
            email.sender = emailSender;
            email.subject = subjects[contactId];

            isSuccess = email.send();
        }
        if (isSuccess)
            successIds.push(recipientData[i][0]); //set the recipient status to 'sent'
        else
            failedIds.push(recipientData[i][0]); //set the recipient status to 'failed'
    }
    db.updateData("BULKMAILRECIPIENT", ["STATUS", "SENTDATE"], null, [$KeywordRegistry.bulkMailRecipientStatus$sent(), sentDate], 
        SqlCondition.begin()
            .andIn("BULKMAILRECIPIENT.BULKMAILRECIPIENTID", successIds)
            .build("1=2")
    );
    db.updateData("BULKMAILRECIPIENT", ["STATUS", "SENTDATE"], null, [$KeywordRegistry.bulkMailRecipientStatus$failed(), sentDate], 
        SqlCondition.begin()
            .andIn("BULKMAILRECIPIENT.BULKMAILRECIPIENTID", failedIds)
            .build("1=2")
    );
        
    db.updateData("BULKMAIL", ["STATUS"], null, [$KeywordRegistry.bulkMailStatus$sent()], 
        SqlCondition.equals("BULKMAIL.BULKMAILID", pBulkMailId, "1=2"));
        
    return {
        sucessful : successIds.length,
        failed : failedIds.length
    };
}


BulkMailUtils.openAddRecipientView = function (pContactIds)
{
    var params = {
        "ContactIds_param" : pContactIds
    };
    neon.openContext("BulkMailAddRecipients", "BulkMailAddRecipientsEdit_view", null, neon.OPERATINGSTATE_NEW, params);
}

/**
 * deletes all bulk mail recipients that have a commrestriction for emails
 * 
 * @param {String} pBulkMailId
 */
BulkMailUtils.removeCommRestrictionRecipients = function (pBulkMailId)
{
    var recipientIds = db.array(db.COLUMN, SqlBuilder.begin()
        .select("BULKMAILRECIPIENTID")
        .from("BULKMAILRECIPIENT")
        .join("CONTACT", SqlCondition.begin()
            .and("BULKMAILRECIPIENT.CONTACT_ID = CONTACT.CONTACTID")
            .andSqlCondition(ContactUtils.getCommRestrictionCondition($KeywordRegistry.communicationMediumCampaign$mail())))
        .where(SqlCondition.begin()
            .andPrepare("BULKMAILRECIPIENT.BULKMAIL_ID", pBulkMailId))
        .build());

    if (recipientIds.length)
    {
        db.deleteData("BULKMAILRECIPIENT", SqlCondition.begin()
            .andIn("BULKMAILRECIPIENT.BULKMAILRECIPIENTID", recipientIds)
            .build("1=2"));
    }
}

/**
 * adds recipients to a bulkmail
 * 
 * @param {String} pBulkMailId bulk mail id
 * @param {String[]} pContactIds contact ids of the recipients
 */
BulkMailUtils.addRecipients = function (pBulkMailId, pContactIds)
{
    var columns = [
        "BULKMAILRECIPIENTID",
        "BULKMAIL_ID",
        "CONTACT_ID",
        "STATUS"
    ];
    var inserts = [];
    for (let i = 0, l = pContactIds.length; i < l; i++)
    {
        inserts.push(["BULKMAILRECIPIENT", columns, null, [util.getNewUUID(), pBulkMailId, pContactIds[i], $KeywordRegistry.bulkMailRecipientStatus$pending()]]);
    }
    db.inserts(inserts);
}

/**
 * Loads the document template of a bulk mail. If the bulk mail itself has a
 * template, it is preferred over the documentTemplate-id.
 * 
 * @param {String} pBulkMailId bulkmail id
 * @param {String} pDocumentTemplateId documentTemplate id
 * 
 * @return {DocumentTemplate} the document template, null if no content was found.
 */
BulkMailUtils.getBulkMailTemplate = function (pBulkMailId, pDocumentTemplateId)
{
    var template = DocumentTemplate.loadTemplate(pBulkMailId, "BULKMAIL");
    if (!template.type)
        template = DocumentTemplate.loadTemplate(pDocumentTemplateId);
    return template;
}

BulkMailUtils.isRecipient = function (pBulkMailId, pContactId)
{
    return db.cell(SqlCondition.begin()
        .andPrepare("BULKMAILRECIPIENT.CONTACT_ID", pContactId)
        .andPrepare("BULKMAILRECIPIENT.BULKMAIL_ID", pBulkMailId)
        .buildSql("select count(*) from BULKMAILRECIPIENT") //TODO: is there a way exists could be used?
    ) != "0";
}

BulkMailUtils.newBulkMail = function (pRecipients)
{
    var params = {
        "PresetRecipients_param" : JSON.stringify(pRecipients)
    };
    neon.openContext("BulkMail", "BulkMailEdit_view", null, neon.OPERATINGSTATE_NEW, params);
}

BulkMailUtils.filterNewRecipients = function (pBulkMailId, pContactIds)
{
    var existsQuery = "not exists(select BULKMAILRECIPIENTID from BULKMAILRECIPIENT where BULKMAILRECIPIENT.CONTACT_ID = CONTACT.CONTACTID and # = ?)";
    var query = SqlCondition.begin()
        .andIn("CONTACT.CONTACTID", pContactIds)
        .andPrepare("BULKMAILRECIPIENT.BULKMAIL_ID", pBulkMailId, existsQuery) //only add contacts that aren't already recipients
        .andSqlCondition(ContactUtils.getCommRestrictionCondition($KeywordRegistry.communicationMediumCampaign$mail(), true))  //check if there's a commrestriction
        .buildSql("select CONTACTID from CONTACT");

    return db.array(db.COLUMN, query); 
}

function SerialLetterUtils () {}

/**
 * adds recipients to a serial letter
 * 
 * @param {String} pSerialLetterId serial letter id
 * @param {String[]} pContactIds contact ids of the recipients
 */
SerialLetterUtils.addRecipients = function (pSerialLetterId, pContactIds)
{
    var columns = [
        "LETTERRECIPIENTID",
        "SERIALLETTER_ID",
        "CONTACT_ID"
    ];
    var inserts = [];
    for (let i = 0, l = pContactIds.length; i < l; i++)
    {
        inserts.push(["LETTERRECIPIENT", columns, null, [util.getNewUUID(), pSerialLetterId, pContactIds[i]]]);
    }
    db.inserts(inserts);
}


SerialLetterUtils.openAddRecipientView = function (pContactIds)
{
    var params = {
        "ContactIds_param" : pContactIds
    };
    neon.openContext("SerialLetterAddRecipients", "SerialLetterAddRecipientsEdit_view", null, neon.OPERATINGSTATE_NEW, params);
}

/**
 * executes a server process that builds a serial letter
 * 
 * @param {String} pSerialLetterId serial letter id
 * @param {String[]} [pRecipientIds] Letter recipient ids of that should be used.
 *                                    If omitted, all recipients of the letter will be used.
 */
SerialLetterUtils.buildSerialLetter = function (pSerialLetterId, pRecipientIds)
{
    process.execute("buildSerialLetter_serverProcess", {
        "serialLetterId" : pSerialLetterId,
        "recipientIds" : JSON.stringify(pRecipientIds)
    });
}

SerialLetterUtils.isRecipient = function (pSerialLetterId, pContactId)
{
    return db.cell(SqlCondition.begin()
        .andPrepare("LETTERRECIPIENT.CONTACT_ID", pContactId)
        .andPrepare("LETTERRECIPIENT.SERIALLETTER_ID", pSerialLetterId)
        .buildSql("select count(*) from LETTERRECIPIENT") //TODO: is there a way exists could be used?
    ) != "0";
}