Client-Side Cookie Management

This is the OneTrust recommended method to allow/disallow cookies based on user choices when the cookie script is in the source code. As the name of the method suggests, this method focuses on the type attribute of script tags. This method is the most appropriate when blocking cookie scripts where the HTML script tag has a defined type.

Below are a couple examples in which this method would be applicable.

In-Line Scripting Example:

<script type=’text/javascript’>
document.cookie = “targeting-cookie”+”=”+”1234”
</script>

JavaScript File Example:

<script type=’text/javascript’ src=’/path/cookie.js’></script>

How to Implement

Normal script tags appear as follows:

<script type="text/javascript">
code
</script>

Using script type re-writing, you must change the type attribute’s value and add class to modify the script tag to be implemented only when consent is provided to the relevant category:

<script type="text/plain" class="optanon-category-C0002">
code
</script>

The ID in the class identifier (C0002 above) corresponds to the cookie group ID for the cookies the script loads (in this example, Performance Cookies). For more information on how to find category IDs, see Finding the Cookie Group IDs.

How it Works

The in-line scripting example (above) would appear as follows:

<script type=’text/plain’ class=’optanon-category-C0004’>
document.cookie = “targeting-cookie”+”=”+”1234”
</script>

After re-writing this tag, the script would only fire on the site when a user consents to the C0004 category (Targeting Cookies). The class attribute is responsible for updating the type. When consent is withdrawn/withheld for the assigned category, the type will be text/plain; when consent is given, it will be text/javascript.

In this example, when a user does not consent to Targeting cookies (C0004) , the script tag would appear as follows:

When a user consents to Targeting cookies (C0004), the type will appear as follows:

<script type="text/plain" class="optanon-category-C0002-C0003-C0004">
code
</script>

The Optanon Wrapper is provided in the main script tag and appears as follows:

<script type="text/javascript">
function OptanonWrapper() {
}
</script>

It functions as a holder for the helper methods, which are used to block or control any script or HTML tags that cause cookies to be set. The wrapper is executed on each page load, or whenever the user modifies their consent for any cookie categories in the Preference Center.

When cookie groups are switched from Inactive to Active, the relevant helper methods are executed, and the related JavaScript/HTML will be inserted in the page.

The helper method scripts do not have to be placed inside the wrapper control. However, if they are not, they are only executed on first page load. If you want any opt-in action (Inactive to Active) to be reflected immediately in the user experience, then you should use the wrapper.

Changes in the user experience as the result of an opt-out action (Active to Inactive) will only be reflected on page refresh or navigating to a new page.

Below is an example function called through OptanonWrapper():

Example function:

toConsole() {
    console.log(“SUCCESS”)
}
function OptanonWrapper{
  if(OnetrustActiveGroups.includes("C0002")){
    toConsole()
  }
}

OnetrustActiveGroups plays a critical role in the Optanon Wrapper Control method. OnetrustActiveGroups is a data layer variable that gets updated every time a user modifies their choices with the latest category IDs. For more details on this variable, see OnetrustActiveGroups - Using the Data Layer Object.

In the above instance, toConsole() is an example function that is writing a message on the console when the if condition is executed. In this example, the if condition is checking for the OnetrustActiveGroups data layer variable and if it includes the C0002 category, meaning when Performance cookies are active. Whenever this condition is satisfied, the toConsole() function is executed. The toConsole() function will be called every time the OptanonWrapper() fires and when a user consents to Performance cookies (C0002).

When the function is executed based on consent for Performance category, it appears as follows:

Third-party tools often have public methods that can be called to indicate to the tool that a user has granted or revoked consent. These will often result in the technology being set to “strict” or “restricted” mode so that a restricted amount of data is processed to respect a user’s choices. If the technology you want to control has these methods, you can implement them through the OptanonWrapper control. See the following example:

function OptanonWrapper(){
	if(OnetrustActiveGroups.includes(“C0002”)){
		myAnalyticsTool.setUnrestrictedMode () //consent given, operate regularly
	}else{
		myAnalyticsTool.setRestrictedMode() //consent not given, operate in restricted mode
	}
}

Events

The OneTrust JavaScript SDK raises several events that can be used to trigger consent-related actions. The two most relevant events are OneTrustGroupsUpdated, which fires when consent becomes available on page load and whenever consent is changed, and OTConsentApplied, which only fires when an explicit consent action has been taken.

window.addEventListener(“OneTrustGroupsUpdated”, event => {
	if(event.detail.includes(“C0002”)){
		myAnalyticsTool.setUnrestrictedMode();
}else{
	myAnalyticsTool.setRestrictedMode();
}
})

For more information on OneTrust JavaScript events, see Cookie Consent Java Script Events Guide.

Helper methods are alternative mechanisms that can be used to block or control any script or HTML tags that cause cookies to be set.

OneTrust.InsertScript

With this method, the scripts responsible for setting cookies are placed in an external file, and dynamically inserted in the page when the cookie group they are associated with is Active.

The format is as follows:

OneTrust.InsertScript(url, selector, callback, options, groupId)

Example 1. Example

OneTrust.InsertScript('/gaCookies.js', 'head', null, null, 'C0002');OneTrust.InsertScript('/performance-cookies-script.js', 'head', null, null, '2');

 

In the example below, gaCookies.js is an external file that is setting Google Analytics cookies. This JavaScript file will be inserted only when Performance cookies are active. Implementing this using the InsertScript method within the OptanonWrapper() function would appear as follows:

function OptanonWrapper() { 
            OneTrust.InsertScript('path/gaCookies.js','head', null, null, 'C0002');
 }

The Result:

In this example, the gaCookies.js file will get injected before the closing head tag of the HTML when Performance cookies (C0002) are active. The following script will be inserted in the source and will be executed as a regular JavaScript file:

<script type="text/javascript" src="path/gaCookies.js"></script>

If the Performance Cookies group (C0002) is Inactive, the script will not be inserted.

Note

Please note that the gaCookies.js used in the scenario above is strictly an example. This method is applicable to any JavaScript file that is required to be injected in the code based on user consent.

See the table below for an explanation of the different parameters.

Parameter	Datatype	Description	Value	Required
url	String	Absolute or relative URL of JS file		Yes
selector	String	HTML parent element selector where the script tag will be inserted	head body parent id	Yes
callback	Function	A JavaScript function to be called once the script tag has been inserted	function name null	Yes
options	Object	A list of behaviors for when the script tag is inserted	See Options definition below	Yes
groupId	String	Group ID for which the script tag will be inserted	Optanon Group ID	Yes

 

OneTrust.InsertHTML

This method should be used where the code controlling the setting of cookies is either a standard or custom HTML tag.

The format is as follows:

OneTrust.InsertHtml(element, selector, callback, options, groupId)

Example 2. Example:

OneTrust.InsertHtml('<iframe type="text/html" width="640" height="360" frameborder="no" src="https://www.youtube.com/embed/v=GEH-usLSwqE"></iframe>','123', null, null, 'C0003');OneTrust.InsertHtml('<customElement customAttribute="value">some content</customElement>', 'parent_element_id', null, null, '3');

 

In this example, the iFrame is the standard HTML element to be injected in a section that has ID 123. The first null value specifies that there is not a callback function and the second null value specifies that there is no options parameter added. The group ID (C0003) will allow the element to be inserted when consent is granted for Functional-category cookies.

The Result:

Note

Please note that this method will automatically add an enclosing div around the element that is getting inserted.

<customElement customAttribute="value">some content</customElement>

If the Functionality Cookies group is Inactive, the script will not be inserted.

See the table below for an explanation of the different parameters.

Parameter	Datatype	Description	Value	Required
element	String	HTML tag to be inserted		Yes
selector	String	HTML parent element id where the element will be inserted	parent ID	Yes
callback	Function	A JavaScript function to be called once the element has been inserted	function name null	Yes
options	Object	A list of behaviors for when the element is inserted	See Options definition below null	Yes
groupId	Number	Group ID for which the element will be inserted	Optanon Group ID	Yes

Note

Some third-party components that set cookies use both JavaScript and HTML elements that are interdependent. In most cases, you will then need to use both the HTML and JavaScript helper methods as a pair to avoid any problems of one element being present without the other.

 

{
deleteSelectorContent: <bool>,
makeSelectorVisible: <bool>,
makeElementsVisible: [‘<id>’, ‘<id>’, ‘<id>’, ...],
deleteElements: [‘<id>’, ‘<id>’, ‘<id>’, ...]
}