process.js

import("Binary_lib");
import("system.vars");
import("system.util");
import("system.datetime");
import("system.text");
import("system.neon");
import("system.db");
import("system.translate");
import("system.eMath");
import("Util_lib");
import("Sql_lib");
import("Keyword_lib");
import("KeywordRegistry_basic");
import("Product_lib");
import("Report_lib");
import("Context_lib");

/**
 * Methods used by for activities (former history).
 * Do not create an instance of this!
 * 
 * @class
 */
function ActivityUtils() {}

/**
 * Create a new activity within the database-scope.
 * This funciton will insert a complete new activity into the Database
 * 
 * @param {Object} [pDataPreset={}] an object that contains the data for the activity, you do not need to specify any preset data at all,
 *                                  but you CAN define the following properties: 
 *                                  <ul>
 *                                  <li>activityId</li>
 *                                  <li>responsibleContactId</li>
 *                                  <li>categoryKeywordId</li>
 *                                  <li>directionKeywordId</li>
 *                                  <li>subject</li>
 *                                  <li>content</li>
 *                                  </ul>
 * @param {Array} [pActivityLinks] 2D array where each element is an array of Contextname and objectid, for example:
 *                                 <pre>[["Organisation", "2d1e505c-a75a-4fa6-826b-7224a97d5b51"]]</pre>
  * @param {Array} [pDocuments] 2D array where each element is an array of:
   *                                <ul>
 *                                  <li>document-name</li>
 *                                  <li>document-content(base64-string)</li>
 *                                  <li>true/false if it's mainDocument or not</li>
 *                                  </ul>
 *                                  for example:
 *                                  <pre>[["number.txt", "MDExOCA5OTkgODgxIDk5OSAxMTkgNzI1IDM", true]]</pre>
 * @param {String} [pDbAlias=current db alias] database alias where the activity shall be inserted
 * 
 * @return {Object} js object where the following are filled:
 *                                  <ul>
 *                                  <li>activityId</li>
 *                                  </ul>
 */
ActivityUtils.insertNewActivity = function(pDataPreset, pActivityLinks, pDocuments, pDbAlias)
{
    var dataPreset = pDataPreset || {};
    var dbAlias = pDbAlias || db.getCurrentAlias();
    var insertStatements = [];
    
    var creationUser = vars.get("$sys.user");
    var creationDate = datetime.date();
    
    var activityId = dataPreset.activityId || util.getNewUUID();
    var entrydate = pDataPreset.entrydate || creationDate;

    var activityColumns = ["ACTIVITYID", "DATE_NEW", "USER_NEW", "ENTRYDATE"];
    var activityValues = [activityId, creationDate, creationUser, entrydate];
    
    _addActivityCol("CATEGORY", dataPreset.categoryKeywordId);
    _addActivityCol("DIRECTION", dataPreset.directionKeywordId);
    _addActivityCol("INFO", dataPreset.content);
    _addActivityCol("RESPONSIBLE", dataPreset.responsibleContactId);
    _addActivityCol("SUBJECT", dataPreset.subject);
    
    insertStatements.push(["ACTIVITY", activityColumns, db.getColumnTypes("ACTIVITY", activityColumns, dbAlias), activityValues]);

    if (pActivityLinks)
    {
        var activityLinkColumns = ["ACTIVITYLINKID", "ACTIVITY_ID", "DATE_NEW", "USER_NEW", "OBJECT_TYPE", "OBJECT_ROWID"];
        var activityLinkColumnTypes = db.getColumnTypes("ACTIVITYLINK", activityLinkColumns, dbAlias);
        var activityLinkValues;
        for (var i = 0, l = pActivityLinks.length; i < l; i++)
        {
            activityLinkValues = [util.getNewUUID(), activityId, creationDate, creationUser, pActivityLinks[i][0], pActivityLinks[i][1]];
            insertStatements.push(["ACTIVITYLINK", activityLinkColumns, activityLinkColumnTypes, activityLinkValues]);
        }
    }
    
    db.inserts(insertStatements, dbAlias);
    
    if (pDocuments)
        ActivityUtils.insertDocuments(activityId, pDocuments);

    return {
        activityId: activityId
    };

    function _addActivityCol(pColumn, pValue, pDefaultValue)
    {
        if (pValue || pDefaultValue)
        {
            activityColumns.push(pColumn);
            activityValues.push(pValue || pDefaultValue);
        }
    }
};

/**
 * inserts documents for an activity
 * 
 * @param {String} pActivityId activity id
 * @param {Array} pDocuments 2D array where each element is an array of:
 *                                  <ul>
 *                                  <li>document-name</li>
 *                                  <li>document-content(base64-string)</li>
 *                                  <li>true/false if it's mainDocument or not</li>
 *                                  </ul>
 *                                  for example:
 *                                  <pre>[["number.txt", "MDExOCA5OTkgODgxIDk5OSAxMTkgNzI1IDM", true]]</pre>
 */
ActivityUtils.insertDocuments = function (pActivityId, pDocuments)
{
    pDocuments.forEach(function (document)
    {
        var filename, b64Content, isMainDocument;
        [filename, b64Content, isMainDocument] = document;
        if (isMainDocument)
            SingleBinaryUtils.insertMainDocument("ACTIVITY", "DOCUMENT", pActivityId, b64Content, filename);
        else
            SingleBinaryUtils.insert("ACTIVITY", "DOCUMENT", pActivityId, b64Content, filename);
    });
}

/**
 * Create a new activity
 */
ActivityUtils.createNewActivity = function(pRowId, pAdditionalLinks, pParentContext, pParentId, pSubject, pInfo, pDirection, pDocuments)
{
    var params = {};
    if (pDocuments)
        params["PresetDocuments_param"] = JSON.stringify(pDocuments);
    if (pSubject)
        params["Subject_param"] = pSubject;
    if (pInfo)
        params["Info_param"] = text.text2html(pInfo.trim(), false);
    if (pDirection)
        params["Direction_param"] = pDirection;
    
    _ActivityTaskUtils._createNew("Activity", pRowId, pAdditionalLinks, pParentContext, pParentId, params)
}

/*
 * Gets the date of the last activity
 * 
 * @param {String} pRowId the rowid of the dataset
 * 
 * @return {number|null} the date of the last actvity as long
 */
ActivityUtils.getLastActivityDate = function(pRowId)
{
    var context = ContextUtils.getCurrentContextId();
    var sqlUtil = new SqlMaskingUtils();
    var activitySql = "select " + sqlUtil.max("ENTRYDATE") + " from ACTIVITY "
        + " join ACTIVITYLINK on ACTIVITY.ACTIVITYID = ACTIVITYLINK.ACTIVITY_ID";
    activitySql = SqlCondition.begin()
        .andPrepare("ACTIVITYLINK.OBJECT_TYPE", context)
        .andPrepare("ACTIVITYLINK.OBJECT_ROWID", pRowId)
        .buildSql(activitySql);
    
    var entryDate = db.cell(activitySql);
    if (entryDate != "")
        return parseInt(entryDate);
    return null;
}

/**
 * add the links to the link-table in new mode
 * 
 * @return {String} pObjectIdField jdito Field for the objectId
 * @return {String} pRowIdField jdito Field for the rowId
 * @return {String} pAdditionalLinksField jdito Field for additional links
 */
ActivityUtils.addLinkRecords= function(pObjectIdField, pRowIdField, pAdditionalLinksField, pParentContextField, pParentIdField)
{
    _ActivityTaskUtils._addLinkRecords(pObjectIdField, pRowIdField, pAdditionalLinksField, pParentContextField, pParentIdField, "Links");
}

ActivityUtils.hasActivities = function (pRowId, pObjectType)
{
    if (pRowId && pObjectType)
    {
        var cond = SqlCondition.begin().andPrepare("ACTIVITYLINK.OBJECT_TYPE", pObjectType)
                                       .andPrepare("ACTIVITYLINK.OBJECT_ROWID", pRowId);
        var taskCount = db.cell(cond.buildSql("select count(*) from ACTIVITYLINK"));
        if (taskCount != "0")
            return true;
        return false;
    }
    return true;
}

/**
 * creates links for an activity
 */
ActivityUtils.insertLink = function (pActivityId, pObjectType, pRowId)
{
    var linkCols = [
        "ACTIVITYLINKID",
        "ACTIVITY_ID",
        "OBJECT_ROWID",
        "OBJECT_TYPE",
        "USER_NEW",
        "DATE_NEW"
    ];
    var linkVals = [
        util.getNewUUID(),
        pActivityId,
        pRowId,
        pObjectType,
        vars.get("$sys.user"),
        vars.get("$sys.date")
    ];
    db.insertData("ACTIVITYLINK", linkCols, null, linkVals);
}

/**
 * Methods used by for tasks.
 * Do not create an instance of this!
 * 
 * @class
 */
function TaskUtils () {}
   

/**
 * Create a new task
 */
TaskUtils.createNewTask = function(pRowId, pAdditionalLinks, pParentContext, pParentId, pParams, pDocuments)
{
    _ActivityTaskUtils._createNew("Task", pRowId, pAdditionalLinks, pParentContext, pParentId, pParams, pDocuments)
}

/**
 * Create a new task
 */
TaskUtils.hasTasks = function(pRowId, pObjectType)
{
    if (pRowId != "" && pObjectType != "")
    {
        var cond = SqlCondition.begin().andPrepare("TASKLINK.OBJECT_TYPE", pObjectType)
                                       .andPrepare("TASKLINK.OBJECT_ROWID", pRowId);
        var taskCount = db.cell(cond.buildSql("select count(*) from TASKLINK"));
        if (taskCount != "0")
            return true;
        else 
            return false;
    }
    else
        return true;
}

TaskUtils.getStatusIcon = function(pStatus)
{
    return KeywordUtils.getAttributeRelation(pStatus, $KeywordRegistry.taskStatus(), "icon", "NEON:STATUS_NOT_STARTED");
}

/**
 * add the links to the link-table in new mode
 * 
 * @return {String} pObjectIdField jdito Field for the objectId
 * @return {String} pRowIdField jdito Field for the rowId
 * @return {String} pAdditionalLinksField jdito Field for additional links
 */
TaskUtils.addLinkRecords= function(pObjectIdField, pRowIdField, pAdditionalLinksField, pParentContextField, pParentIdField)
{
    _ActivityTaskUtils._addLinkRecords(pObjectIdField, pRowIdField, pAdditionalLinksField, pParentContextField, pParentIdField, "Links");
}

TaskUtils.getOpenTaskCount = function(pRowId, pObjectType)
{
    var cond = SqlCondition.begin()
        .andPrepare("TASKLINK.OBJECT_TYPE", pObjectType)
        .andPrepare("TASKLINK.OBJECT_ROWID", pRowId)
        .andPrepare("TASK.STATUS", $KeywordRegistry.taskStatus$ended(), "# != ?")
    var taskCount = db.cell(cond.buildSql("select count(*) from TASKLINK join TASK on TASKLINK.TASK_ID = TASK.TASKID"));
    
    return parseInt(taskCount);
}

/**
 * Methods used by for tasks.
 * Do not create an instance of this!
 * 
 * @ignore
 * @class
 */
function _ActivityTaskUtils() {}
   

/**
 * Create a new task
 * @ignore
 */
_ActivityTaskUtils._createNew = function(pContext, pRowId, pAdditionalLinks, pParentContext, pParentId, pParams)
{
    if (pAdditionalLinks == undefined)
        pAdditionalLinks = [];
       
    var params = {};
    
    if (pParams)
        params = pParams
     
    if (pRowId)
    {
        params["ObjectId_param"] = ContextUtils.getCurrentContextId();
        params["RowId_param"] = pRowId;
    }
        
    params["PresetLinks_param"] = JSON.stringify(pAdditionalLinks);
    
    if (pParentContext && pParentId)
    {
        
        
        params["ParentContext_param"] = pParentContext;
        params["ParentId_param"] = pParentId;
    }
    
    neon.openContext(pContext, null, null, neon.OPERATINGSTATE_NEW, params);
}

/**
 * add the links to the link-table in new mode
 * 
 * @return {String} pObjectIdField jdito Field for the objectId
 * @return {String} pRowIdField jdito Field for the rowId
 * @return {String} pAdditionalLinksField jdito Field for additional links
 * 
 * @ignore
 */
_ActivityTaskUtils._addLinkRecords = function(pObjectIdField, pRowIdField, pAdditionalLinksField, pParentContextField, pParentIdField, pConsumerName)
{
    if (vars.exists(pAdditionalLinksField))
        presetLinks = JSON.parse(vars.getString(pAdditionalLinksField));

    if (!presetLinks)
        presetLinks = [];
    
    if (vars.exists(pRowIdField) && vars.get(pRowIdField)
        && vars.exists(pObjectIdField) && vars.get(pObjectIdField))
        presetLinks.push([vars.get(pObjectIdField), vars.get(pRowIdField)]);

    if (vars.exists(pParentContextField) && vars.exists(pParentIdField))
    {
        switch (vars.get(pParentContextField))
        {
            case "Activity":
                presetLinks = presetLinks.concat(db.table(SqlCondition.begin()
                             .andPrepare("ACTIVITYLINK.ACTIVITY_ID", vars.get(pParentIdField))
                             .buildSql("select OBJECT_TYPE, OBJECT_ROWID from ACTIVITYLINK", "1=2")));
                break;
            case "Task":
                presetLinks = presetLinks.concat(db.table(SqlCondition.begin()
                             .andPrepare("TASKLINK.TASK_ID", vars.get(pParentIdField))
                             .buildSql("select OBJECT_TYPE, OBJECT_ROWID from TASKLINK", "1=2")));
                break;
            case "SupportTicket":
                presetLinks = presetLinks.concat(db.table(SqlCondition.begin()
                             .andPrepare("TICKET.TICKETID", vars.get(pParentIdField))
                             .buildSql("select OBJECT_TYPE, OBJECT_ROWID from TICKET join TASKLINK on TASKLINK.TASK_ID = TICKET.TASK_ID", "1=2")));
                break;
        }
        
    }

    presetLinks.forEach(function(link) {
        neon.addRecord(pConsumerName, {
            "OBJECT_TYPE" : link[0], 
            "OBJECT_ROWID" : link[1]
        });
    });
}