Rules Developer Guide

exports.handler=(batch,context,callback)=>{
    //Do something with batch
    callback(null, batch); // or callback(null, null); to drop the batch completely
}

exports.handler=(batch,context,callback)=>{
/* 
A support feed contains batches from internal and external users. 
We can create a rule to drop batches from internal users.
*/    
    if(batch.user_attributes.internal) {
        callback(null, null);
    }
    else{
        callback(null, batch);
    }
};

exports.handler=(batch,context,callback)=>{
/* 
An input has firstname and lastname attributes for a user.
Our output platform expects a full name, so we can use a rule to create one.
*/    
    if(batch.user_attributes.$firstname && batch.user_attributes.$lastname) {
        var firstname = batch.user_attributes.$firstname;
        var lastname = batch.user_attributes.$lastname;
        batch.user_attributes.name = `${firstname} ${lastname}`;
    }
    callback(null, batch);

};

// User attribute added to user_attributes
batch.user_attributes["foo"] = "this is the new value";

// UAC event added to events 
batch.events.push(
{
   "data":{
      "user_attribute_name":"foo",
      "new":"this is the new value",
      "old":"this is an old value", //this is optional
      "deleted":false,
      "is_new_attribute":true
   },
   "event_type":"user_attribute_change"
}
);

exports.handler=(batch,context,callback)=>{
/* 
An input sends events with the event name 'Signup'. 
We can create a rule to change it to 'subscribe', to tailor it to a specific Output service.
*/
    function event_handler(event) {
        if (event.data.event_name === 'Signup') {
            event.data.event_name = 'subscribe';
        }
     	return event;
    }
    
    var events = batch.events;
    var newEvents = [];
    
    events.forEach(function(currentEvent){
    	try { 
    	    newEvents.push(event_handler(currentEvent));
    	}
    	catch(err){ }
    });
    
    batch.events = newEvents;
    
    callback(null, batch);
};

/* 
If applied to an event that is not a Commerce event, 
this condition will cause an error and prevent 
the entire batch from being processed.
*/
if (event.data.product_action.action === "add_to_cart") {
    //do something
}

/* 
You can add a condition to only apply this part of 
the rule to Commerce events.
*/
if (event.event_type === "commerce_event") {
    if (event.data.product_action.action === "add_to_cart") {
        //do something
    }
}

/* 
The above rule will still fail if the commerce event does 
not contain a product action. To be safer, check each nested key.
*/
if (event.event_type === "commerce_event") {
    if (event.data && event.data.product_action && event.data.product_action.action === "add_to_cart") {
        //do something
    }
}

/* 
This event handler function has two parts to deal with commerce events and custom events. 
By using try...catch, we ensure that, if one part of the rule causes an unforseen error, 
the other part can still be applied.
*/
function event_handler(event) {
    try {
        if (event.event_type === "commerce_event") {
            if (event.data && event.data.product_action && event.data.product_action.action === "add_to_cart") {
                //do something
            }
        }  
    }
    catch (error) {
        // handle error
    }

    try {
        if (event.event_type === "custom_event") {
            if (event.data && event.data.event_name && event.data.event_name === "level_up") {
                event.data.event_name = "increase_level";
            }
        }  
    }
    catch (error) {
        // handle error
    }
    return event;
}

exports.handler = (batch, context, callback) => {   
    // Define mapping of legacy names to new names
    const mappings = {
        "legacy_name1": "new_name1",
        "legacy_name2": "new_name2",
        "legacy_name3": "new_name3"
    };

    // If the event name is in mappings, update it to the new name
    function rename_test_events(eventItem, mappings) {
        const keys = Object.keys(mappings);
        if (keys.indexOf(eventItem.data.event_name) != -1) {
            eventItem.data.event_name = mappings[eventItem.data.event_name];
        }
    }

    // Create updated events array
    const newEvents = []
    batch.events.forEach(item => {
        try {
            rename_test_events(item, mappings);
            newEvents.push(item)
        }
        catch (err) { } // if an error occurs, exclude the event from the updated events array
    });

    // Replace original events with updated events
    batch.events = newEvents;
    callback(null, batch);
};

exports.handler = (batch, context, callback) => {
    // Change "United States" to "USA"
    function changeCountryName(data) {
        if (!data.user_attributes || !data.user_attributes.$Country) {
            return;
        }

        const countryLower = data.user_attributes.$Country.toLowerCase();

        if (countryLower === 'united states' || countryLower === 'united states of america') {
            data.user_attributes.$Country = 'USA';
        }
    }

    // If an event name is received as "Play Video", change it to "Viewed Video"
    function rename_test_events(eventItem) {
        if (eventItem.data.event_name === 'Play Video') {
            eventItem.data.event_name = 'Viewed Video';
        }
    }

    // Create an attribute to record speed in seconds based on an existing "timing" attribute
    function create_speed_attribute(eventItem) {
        if (eventItem.data.custom_attributes && eventItem.data.custom_attributes.timing) {
            eventItem.data.custom_attributes.speed = eventItem.data.custom_attributes.timing / 1000;
        }
    }

    // Update events
    newEvents = [];
    batch.events.forEach(item => {
        // Basic error handling is included here, to avoid dropping or passing through
        // a whole batch due to errors processing one event.
        try {
            rename_test_events(item);
            create_speed_attribute(item);
            newEvents.push(item);
        }
        catch (err) { }
    });
    batch.events = newEvents;

    // Update batch
    changeCountryName(batch);

    callback(null, batch);
};