def create_targeting_value(name, key_id, match_type='EXACT'):
"""
Creates a custom targeting value for a specific key in DFP.
Args:
name (str): the name of value
key_id (int): the ID of the associated DFP key
Returns:
None
"""
dfp_client = get_client()
custom_targeting_service = dfp_client.GetService('CustomTargetingService',
version='v202102')
values_config = [{
'customTargetingKeyId': key_id,
'displayName': str(name),
'name': str(name),
'matchType': match_type
}]
# Add custom targeting values.
if len(values_config) > 0:
values = custom_targeting_service.createCustomTargetingValues(
values_config)
# Display results.
if values:
created_value = values[0]
logger.info(u'Created a custom targeting value with name "{name}" '
'and display name "{display_name}".'.format(
name=created_value['name'],
display_name=created_value['displayName']))
return created_value['id']
def get_line_item_by_name(line_item_name):
"""
Gets an line_item by name from DFP.
Args:
line_item_name (str): the name of the DFP line item
Returns:
a DFP line item, or None
"""
dfp_client = get_client()
line_item_service = dfp_client.GetService('LineItemService', version='v201811')
# Filter by name.
query = 'WHERE name = :name'
values = [{
'key': 'name',
'value': {
'xsi_type': 'TextValue',
'value': line_item_name
}
}]
statement = ad_manager.FilterStatement(query, values)
response = line_item_service.getLineItemsByStatement(statement.ToStatement())
no_line_item_found = False
try:
no_line_item_found = True if len(response['results']) < 1 else False
except (AttributeError, KeyError):
no_line_item_found = True
if no_line_item_found:
return None
else:
line_item = response['results'][0]
logger.info(u'Found a line_item with name "{name}".'.format(name=line_item['name']))
return line_item
def create_targeting_key(name, display_name=None, key_type='FREEFORM'):
"""
Creates a custom targeting key in DFP.
Args:
name (str): the name of the targeting key
display_name (str)
type (str): either 'FREEFORM' or 'PREDEFINED'
Returns:
an integer: the ID of the created key
"""
dfp_client = get_client()
custom_targeting_service = dfp_client.GetService('CustomTargetingService',
version='v201802')
if display_name is None:
display_name = name
# Create custom targeting key objects.
keys = [
{
'displayName': display_name,
'name': name,
'type': key_type
}
]
# Add custom targeting keys.
keys = custom_targeting_service.createCustomTargetingKeys(keys)
key = keys[0]
logger.info(u'Created a custom targeting key with id "{id}", name "{name}", '
'and display name "{display_name}".'.format(id=key['id'],
name=key['name'], display_name=key['displayName']))
return key['id']
def get_order_by_name(order_name):
"""
Gets an order by name from DFP.
Args:
order_name (str): the name of the DFP order
Returns:
a DFP order, or None
"""
dfp_client = get_client()
order_service = dfp_client.GetService('OrderService', version='v202008')
# Filter by name.
query = 'WHERE name = :name'
values = [{
'key': 'name',
'value': {
'xsi_type': 'TextValue',
'value': order_name
}
}]
statement = ad_manager.FilterStatement(query, values)
response = order_service.getOrdersByStatement(statement.ToStatement())
no_order_found = False
try:
no_order_found = True if len(response['results']) < 1 else False
except (AttributeError, KeyError):
no_order_found = True
if no_order_found:
return None
else:
order = response['results'][0]
logger.info(u'Found an order with name "{name}".'.format(name=order['name']))
return order
def get_placement_by_name(placement_name):
"""
Gets a placement by name from DFP.
Args:
placement_name (str): the name of the DFP placement
Returns:
a DFP placement object
"""
client = get_client()
placement_service = client.GetService('PlacementService',
version='v202008')
statement = (
ad_manager.StatementBuilder().Where('name = :name').WithBindVariable(
'name', placement_name))
response = placement_service.getPlacementsByStatement(
statement.ToStatement())
if 'results' in response and len(response['results']) > 0:
return response['results'][0]
else:
return None
def create_advertiser(name):
"""
Creates a DFP advertiser with name `name` and returns its ID.
Args:
name (str): the name of the DFP advertiser
Returns:
an integer: the advertiser's DFP ID
"""
dfp_client = get_client()
company_service = dfp_client.GetService('CompanyService',
version='v202008')
advertisers_config = [{'name': name, 'type': 'AD_NETWORK'}]
advertisers = company_service.createCompanies(advertisers_config)
advertiser = advertisers[0]
# Display results.
for advertiser in advertisers:
logger.info(u'Created an advertiser with name "{name}" and '
'type "{type}".'.format(name=advertiser['name'],
type=advertiser['type']))
return advertiser
def get_key_by_name(key_name):
"""
Gets a targeting key by key name.
Args:
name (str): the name of the targeting key
Returns:
the key object
"""
client = get_client()
custom_targeting_service = client.GetService('CustomTargetingService',
version='v201811')
statement = (ad_manager.StatementBuilder()
.Where('name = :name')
.WithBindVariable('name', key_name))
response = custom_targeting_service.getCustomTargetingKeysByStatement(
statement.ToStatement())
if 'results' in response and len(response['results']) > 0:
return response['results'][0]
else:
return None
def create_creatives(creative_configs):
"""
Creates creatives in DFP if it doesn't exist.
Args:
creative_configs (arr): an array of objects, each a creative configuration
Returns:
an array: an array of created creative IDs
"""
advertiser_id = creative_configs[0]['advertiserId']
dfp_client = get_client()
creative_service = dfp_client.GetService('CreativeService',
version='v201802')
# All existing creatives
existing_creatives = dfp.get_creatives.get_creatives_by_advertiser_id(
advertiser_id)
existing_creative_names = map(lambda c: c['name'], existing_creatives)
# Return IDs of existing/created creatives
creative_ids = []
for creative_config in creative_configs:
if creative_config['name'] in existing_creative_names:
creative_ids.append(
find(lambda c: c.name == creative_config['name'],
existing_creatives)['id'])
creative_configs.remove(creative_config)
# Submit request to create the outstanding configs that don't already exist
creatives = creative_service.createCreatives(creative_configs)
for creative in creatives:
creative_ids.append(creative['id'])
logger.info(u'Created creative with ID "{0}" and name "{1}".'.format(
creative['id'], creative['name']))
return creative_ids
def get_targeting_by_key_name(name):
"""
Gets a set of custom targeting values by key name
Args:
name (str): the name of the targeting key
Returns:
an array, or None: if the key exists, return an array of objects, where
each object is info about a custom targeting value
"""
dfp_client = get_client()
custom_targeting_service = dfp_client.GetService('CustomTargetingService',
version='v201811')
# Get a key by name.
query = ('WHERE name = :name')
values = [{
'key': 'name',
'value': {
'xsi_type': 'TextValue',
'value': name
}
}]
targeting_key_statement = ad_manager.FilterStatement(query, values)
response = custom_targeting_service.getCustomTargetingKeysByStatement(
targeting_key_statement.ToStatement())
# If the key exists, get predefined values.
key_values = None
if 'results' in response and len(response['results']) > 0:
key = response['results'][0]
key_values = []
query = "WHERE status = 'ACTIVE' AND customTargetingKeyId IN (%s)" % str(
key['id'])
statement = ad_manager.FilterStatement(query)
response = custom_targeting_service.getCustomTargetingValuesByStatement(
statement.ToStatement())
while 'results' in response and len(response['results']) > 0:
for custom_val in response['results']:
key_values.append({
'id':
custom_val['id'],
'name':
custom_val['name'],
'displayName':
custom_val['displayName'],
'customTargetingKeyId':
custom_val['customTargetingKeyId']
})
statement.offset += ad_manager.SUGGESTED_PAGE_LIMIT
response = custom_targeting_service.getCustomTargetingValuesByStatement(
statement.ToStatement())
if key_values is None:
logger.info(
u'Key "{key_name}"" does not exist in DFP.'.format(key_name=name))
elif len(key_values) < 1:
logger.info(
u'Key "{key_name}" exists but has no existing values.'.format(
key_name=name))
else:
logger.info(
u'Key "{key_name}" exists and has {num} existing values.'.format(
key_name=name, num=len(key_values)))
return key_values
def make_licas(line_item_ids, creative_ids, size_overrides=[]):
"""
Attaches creatives to line items in DFP.
Args:
line_item_ids (arr): an array of line item IDs
creative_ids (arr): an array of creative IDs
Returns:
None
"""
dfp_client = get_client()
lica_service = dfp_client.GetService('LineItemCreativeAssociationService',
version='v201802')
sizes = []
for size_override in size_overrides:
sizes.append(size_override)
licas = []
for line_item_id in line_item_ids:
for creative_id in creative_ids:
licas.append({
'creativeId': creative_id,
'lineItemId': line_item_id,
# "Overrides the value set for Creative.size, which allows the
# creative to be served to ad units that would otherwise not be
# compatible for its actual size."
# https://developers.google.com/doubleclick-publishers/docs/reference/v201802/LineItemCreativeAssociationService.LineItemCreativeAssociation
#
# This is equivalent to selecting "Size overrides" in the DFP creative
# settings, as recommended: http://prebid.org/adops/step-by-step.html
'sizes': sizes
})
associations_batch = getattr(settings, 'DFP_ASSOCIATIONS_BATCH', None)
if not associations_batch is None:
while licas:
batch = []
for b in range(0, associations_batch):
if licas:
batch.append(licas.pop(0))
try:
time.sleep(1)
batch = lica_service.createLineItemCreativeAssociations(batch)
except suds.WebFault as err:
logger.info(
u'A common error was raised (it can happen). Waiting 30 seconds and retrying...'
)
time.sleep(30)
try:
batch = lica_service.createLineItemCreativeAssociations(
batch)
except suds.WebFault as err:
logger.info(
u'A common error was raised (it can happen). Waiting 30 seconds and retrying...'
)
time.sleep(30)
batch = lica_service.createLineItemCreativeAssociations(
batch)
if batch:
logger.info(
u'Created {0} line item <> creative associations.'.format(
len(batch)))
else:
logger.info(u'No line item <> creative associations created.')
else:
licas = lica_service.createLineItemCreativeAssociations(licas)
if licas:
logger.info(
u'Created {0} line item <> creative associations.'.format(
len(licas)))
else:
logger.info(u'No line item <> creative associations created.')
def get_dfp_network():
dfp_client = get_client()
network_service = dfp_client.GetService('NetworkService',
version='v202102')
current_network = network_service.getCurrentNetwork()
return current_network
