",
"name": "Testing",
"purpose": "Collecting navigation events to perform R&D tests ONLY. Test Update.",
"legal_basis": "CONSENT",
"technical_name": "me-testing-delete-processing",
"token": "me-testing-delete-processing"
}
```
## Delete a processing
`DELETE` `https://api.mediarithmics.com/v1/processings/:processingId?community_id=:communityId`
#### Path Parameters
| Name | Type | Description |
| ------------ | ------- | ---------------------------------- |
| communityId | integer | The ID of the community |
| processingId | integer | The ID of the processing to update |
{% tabs %}
{% tab title="200 " %}
```
```
{% endtab %}
{% endtabs %}
## User choices
User choices represent the choices a user makes for each of your processing activities.
Each time a user makes a choice, you send it to the platform as [user event](https://developer.mediarithmics.io/user-points/user-activities) with the `$set_user_choice` name and a set of metadata. It will then be computed and stored. You can also create choices via API.
Here are the fields of a user choice object :
```javascript
{
"$processing_id": “1004",
"$choice_ts": 1561622248000,
"$choice_acceptance_value": true,
"$creation_ts": 1561622248000,
"$channel_id": "1234",
"$choice_source_id": "1001",
"$user_agent_id": "vec:123456789",
"$compartment_id": "1234",
"$user_account_id": "123456789",
"$email_hash": {
"$hash": "a1b2c3d4e5",
"$email": "random@gmail.com"
},
"custom_property_1": "custom_value_1",
"custom_property_2": "custom_value_2"
}
```
| Field | Type | Description |
| -------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| $processing\_id | String | The ID of the associated processing activity.
Mandatory via API. Automatically set with $set\_user\_choice events from the $processing\_token property
|
| $choice\_ts | Timestamp | Timestamp at which the choice has been given by the user.
Mandatory via API. Automatically set with $set\_user\_choice events from the $ts property
|
| $choice\_acceptance\_value | Boolean | Choice acceptance value
Mandatory via API. Automatically set with $set\_user\_choice events from the $choice\_acceptance\_value property
|
| $creation\_ts | Timestamp | System field. Creation timestamp of the user choice
Forbidden modification (via API or event). Automatically defined at the user choice creation.
|
| $channel\_id | String | Channel on which the choice has been collected
Optional via API. Automatically set with $set\_user\_choice events from the activity origin.
|
| $choice\_source\_id | String | Source of the choice
Optional via API. Automatically set with $set\_user\_choice events from the $choice\_source\_token property. Allowing a choice update will depend on the source weight (see below).
|
| $user\_agent\_id
User Identifier
| String | The identifier of the user device as provided by the user id mapping service. ex: vec:89090939434
\\
- If choice defined by a
$set\_user\_choice event (pixel or /user\_activities API): we copy the identifiers from the activity origin (after interpreting those within events if pixel) - If choice defined by
/user\_choices API, we consider those in the request payload. If no identifier is defined in the request payload, we copy those in the URL
|
| $user\_account\_id
User Identifier with $compartment\_id
| String | The user account id of the user.
- If choice defined by a
$set\_user\_choice event (pixel or /user\_activities API): we copy the identifiers from the activity origin (after interpreting those within events if pixel) - If choice defined by
/user\_choices API, we consider those in the request payload. If no identifier is defined in the request payload, we copy those in the URL
|
| $compartment\_id
User Identifier with $user\_account\_id
| Integer | The ID of the compartment associated with this activity.
- If choice defined by a
$set\_user\_choice event (pixel or /user\_activities API): we copy the identifiers from the activity origin (after interpreting those within events if pixel) - If choice defined by
/user\_choices API, we consider those in the request payload. If no identifier is defined in the request payload, we copy those in the URL
|
| $email\_hash
User Identifier
| Email Hash Object (Optional) | The email hash object { “$hash”:…, “$email”:…}.
|
| \[any custom property] | String | Custom properties
Optional via API. Automatically set with $set\_user\_choices events from the events custom properties
|
## Registering user choices
You have different ways to capture user choices, each corresponding to different use cases.
### Via user activities
The platform detects the `$set_user_choice` events and creates a user choice using some fields of the user activity.
You can use the different methods of ingesting user activities to ingest your user choices.
#### With Website tracking
Use the [real-time user tracking](https://developer.mediarithmics.io/data-streams/data-ingestion/real-time-user-tracking) to push a `$set_user_choice` [event](https://developer.mediarithmics.io/user-points/user-activities#user-events-object). No authentication is required.
{% hint style="success" %}
This method is used to capture front-end CMP signals and choices the user may do in their user settings.
Please note that those events will go through the [processing pipeline](https://developer.mediarithmics.io/data-streams/data-ingestion/real-time-user-tracking#the-processing-pipeline) before being stored as a user choice. You must ensure no [activity analyzers](https://developer.mediarithmics.io/data-streams/data-ingestion/real-time-user-tracking/activity-analyzers) is removing them during that process.
{% endhint %}
Here is a sample code to include in your mediarithmics snippet :
```javascript
// Function to be triggered when the user made a choice
// Could be triggered by the front-end CMP
// or in the user settings page
function triggetSetUserChoice(value){
// Include the mediarithmics snippet if not already included
...
mics.init("mycorm");
// Create the consent event metadata
var userConsent = {
// The token of the associated processing activity
$processing_token: "mics-advertising-processing"
// The acceptance value
$choice_acceptance_value: value
// Any custom property
mycustomproperty: "hello there"
}
// Push the event
mics.push("$set_user_choice",userConsent);
}
```
This code will result in a user activity after processing :
```javascript
// Sample result user activity with a $set_user_choice event
{
"$type": "SITE_VISIT",
"$session_status": "CLOSED_SESSION",
"$ttl": 0,
"$user_account_id": null,
"$email_hash": null,
"$user_agent_id": "vec:123456789",
"$origin": null,
"$location": null,
"$unique_key": "bfff1e50-15d0-11ea-bc21-d5761024f5d0",
"$error_analyzer_id": null,
"$ts": 1575379690677,
"$session_duration": 3,
"$topics": {},
"$site_id": "3407“,
...
"$events": [
{
"$ts": 1575379693722,
"$event_name": "$set_user_choice",
"$properties": {
"$processing_token": "mics-advertising-processing",
"$choice_acceptance_value": true,
"mycustomproperty": "hello there",
"$url": "https://www.mediarithmics.com/fr-fr"
}
},
{
"$ts": 1575379690677,
"$event_name": "Page View",
"$properties": {
"$url": "https://www.mediarithmics.com/fr-fr",
"$referrer": "",
"level0": "fr-fr"
}
}
]
}
```
#### With API
Use the [User activity tracking API](https://developer.mediarithmics.io/data-ingestion/real-time-user-tracking/api#set-update-a-user-choice) to create an already well-formatted user activity. The platform will then create a user choice exactly as it did in the website tracking section.
#### With Document import
Use the [document import feature to bulk create user activities](https://developer.mediarithmics.io/data-streams/data-ingestion/bulk-processing/imports/offline-activities) with `$set_user_choice` events from external sources (CRM files, server-side CMPs, ...).
{% hint style="success" %}
This method is used when you want to bulk import user choices from external sources via files.
Please note that those events will not go through the [processing pipeline](https://developer.mediarithmics.io/data-streams/data-ingestion/real-time-user-tracking#the-processing-pipeline) before being stored as a user choice. You must ensure they are already formatted.
{% endhint %}
```javascript
// Sample user activity to add using the document import API
{
"$user_account_id":"",
"$compartment_id":,
"$type":"",
"$session_status":"NO_SESSION",
"$ts":,
"$events": [
{
"$event_name":"$set_user_choice",
"$ts":,
"$properties":{
"$processing_token": "", // Mandatory
"$choice_acceptance_value":, // Mandatory
"" : ""
}
}
]
}
```
### Via UserPoint
Use the [UserPoint tracking API ](https://developer.mediarithmics.io/data-ingestion/real-time-user-tracking/api#set-update-a-user-choice-1)to set directly the user choice, without creating any user activity.
## Privacy walls
User choices can be used to automatically allow or block the processing of personal data for a given user, based on his choices.
They can be created at different levels :
* **On `UPSERT` of user activities of type `SITE_VISIT` and `APP_VISIT`**. To achieve this, you link a list of processing activities to a channel. The upsert of data will be allowed for a user if he has allowed **at least one** of the selected processing activities. User activities of types `TOUCH`, `EMAIL` and `DISPLAY_AD` are not covered yet.
* **On `UPSERT` of user profiles**. This is done by linking a list of processing activities to a [compartment](https://developer.mediarithmics.io/user-points#compartments). The upsert of data will be allowed for a user if he has allowed **at least one** of the selected processing activities.
* **On segments computation**. The linkage is done at the [segment](https://developer.mediarithmics.io/user-points/segments) level by selecting a list of processing activities. The user will be allowed in the segment if he has allowed **all** the selected processing activities.
{% hint style="info" %}
On the navigator, go to the settings of the object you wish to link to a list of processing activities and you'll have an option displayed.
{% endhint %}
**For upserted data** (user activities, user profiles and user segments of type `USER_LIST`), the decision to upsert or drop is taken just before saving it into the datamart. In the case of user activities, the decision takes into account the presence of a `$set_user_choice` event in the activity. **If a user changes his choices, new data upserts will be blocked** but already captured data is kept and follows the standard [cleaning rules](https://developer.mediarithmics.io/advanced-usages/data-privacy-compliance/cleaning-rules).
**For `USER_QUERY` segments**, the segment query is automatically updated with conditions on the user choices to include only users with compatible choices. **If a user changes his choices, the user will exit the segment** as he doesn't match the query anymore?
## UserPoint merge
Like other data, **choices are taken into account** [**when two UserPoint are merging**](https://developer.mediarithmics.io/user-points#user-points-merges). However, user choices updates do not trigger merges.
For a given processing, user choices changelogs are merged like user activities in the timeline. Regarding the active values, **the one with the latest `$creation_ts` is kept active on the UserPoint survivor**, the other one being added to the change log.
## User choices in the schema
{% hint style="warning" %}
User choices and their custom properties should be declared in the [schema](https://developer.mediarithmics.io/schema) for the feature to work.
{% endhint %}
Any property can be indexed and the following four properties should be indexed: `processing_id`, `choice_ts`, `creation_ts` and `choice_acceptance_value`.
As the other properties (standard or custom) are expected to be used mostly to prove the validity of a given choice, it might not be required to index them.
```graphql
# User choices in the schema
type UserPoint @TreeIndexRoot(index:"USER_INDEX") {
id:ID!
…
activity_events:[ActivityEvent!]!
choices:[UserChoice!]!
}
type UserChoice {
id:ID!
processing_id: String! @TreeIndex(index:"USER_INDEX")
choice_acceptance_value:Boolean! @TreeIndex(index:"USER_INDEX")
choice_ts: Timestamp! @TreeIndex(index:"USER_INDEX")
creation_ts: Timestamp! @TreeIndex(index:"USER_INDEX")
channel_id: String
user_agent_id: String
email_hash: String
compartment_id: String
user_account_id: String
custom_field: String @Property(path: "custom_field")
}
```
Here are examples of OTQL queries that can be built :
```sql
// Listing all processings and their available values
SELECT {
processing_id @map {
choice_acceptance_value @map
}
}
FROM UserChoice
// Count the number of users who accepted a processing
SELECT @count {}
FROM UserPoint
WHERE choices {
processing_id = "1001"
AND choice_acceptance_value = true
}
// Choice-based segments
SELECT {id}
FROM UserPoint
WHERE [segment_query_conditions]
AND choices {
processing_id = "1001"
AND choice_acceptance_value = true
}
```
## Choice sources
{% hint style="info" %}
You should ask your mediarithmics contact to activate this feature for you if needed
{% endhint %}
When a new choice comes to overwrite an existing choice on the same processing, it may be needed to establish a priority based on the choice source. For instance:
* User choices in a logged-in environment VS front-end CMP popup
* Direct exercise of rights toward the data processor VS CMP cache on the browser
* ...
Therefore we have added an optional field to the user choice : `$choice_source_id`, relating each choice to a reference table that can be created by mediarithmics for each client.
| id | community\_id | name | token | weight |
| ---- | ------------- | --------------------- | ----------------------- | ------ |
| 1001 | 1426 | CMP | me-cmp\_local | 1 |
| 1002 | 1426 | Website user settings | me-user\_settings | 2 |
| 1003 | 1426 | CRM file | me-member\_crm\_file | 2 |
| 1004 | 1426 | Exercise of rights | me-exercise\_of\_rights | 3 |
To define the choice source :
* via `$set_user_choice` events, use `$choice_source_token` . Il will be translated by the platform in to a `$choice_source_id`
* via datamart `/user_choices` API, use directly the `$choice_source_id`
**Impacts on choice update process**
* A new choice collected via `$set_user_choice` event will overwrite the existing one if and only if it has a choice source with a weight equal or superior to the existing one
* The absence of choice source is equivalent to the lowest weight
* This rule is not applied on a choice updated via Datamart authenticated APIs
* This rule is not applied in the case of a merge
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://developer.mediarithmics.io/advanced-usages/data-privacy-compliance/user-choices.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.