def get_key_id_by_name(name):
"""
Gets a targeting key by key name.
Args:
name (str): the name of the targeting key
Returns:
an integer, or None
"""
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())
key_id = None
if 'results' in response and len(response['results']) > 0:
key_id = response['results'][0]['id']
return key_id
def archive_li(
self,
filter_query,
):
statement = dfp.FilterStatement(filter_query, )
return self.li_service.performLineItemAction(
{'xsi_type': 'ArchiveLineItems'}, statement.ToStatement())
def get_all_orders(print_orders=False):
"""
Logs all orders in DFP.
Returns:
None
"""
dfp_client = get_client()
# Initialize appropriate service.
order_service = dfp_client.GetService('OrderService', version='v201811')
# Create a statement to select orders.
statement = ad_manager.FilterStatement()
print('Getting all orders...')
# Retrieve a small amount of orders at a time, paging
# through until all orders have been retrieved.
while True:
response = order_service.getOrdersByStatement(statement.ToStatement())
if 'results' in response and len(response['results']) > 0:
for order in response['results']:
msg = u'Found an order with name "{name}".'.format(
name=order['name'])
if print_orders:
print(msg)
statement.offset += ad_manager.SUGGESTED_PAGE_LIMIT
else:
print('No additional orders found.')
break
def __filter_item(self, filter_fn, filter_query, filter_values):
statement = dfp.FilterStatement(filter_query, filter_values)
# print(statement.ToStatement())
response = filter_fn(statement.ToStatement())
if response.totalResultSetSize > 0:
return response.results
else:
return None
def get_advertiser_id_by_name(name):
"""
Returns a DFP company ID from company name.
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')
# Filter by name.
query = 'WHERE name = :name'
values = [
{
'key': 'name',
'value': {
'xsi_type': 'TextValue',
'value': name
}
},
]
statement = ad_manager.FilterStatement(query, values)
response = company_service.getCompaniesByStatement(statement.ToStatement())
# A company is required.
no_company_found = False
try:
no_company_found = True if len(response['results']) < 1 else False
except (AttributeError, KeyError):
no_company_found = True
if no_company_found:
if getattr(settings, 'DFP_CREATE_ADVERTISER_IF_DOES_NOT_EXIST', False):
advertiser = create_advertiser(name)
else:
raise DFPObjectNotFound(
'No advertiser found with name {0}'.format(name))
elif len(response['results']) > 1:
raise BadSettingException(
'Multiple advertisers found with name {0}'.format(name))
else:
advertiser = response['results'][0]
logger.info(u'Using existing advertiser with name "{name}" and '
'type "{type}".'.format(name=advertiser['name'],
type=advertiser['type']))
return advertiser['id']
def get_user_id_by_email(email_address):
"""
Returns a DFP user ID from email address.
Args:
email (str): the email of the DFP user
Returns:
an integer: the user's DFP ID
"""
dfp_client = get_client()
user_service = dfp_client.GetService('UserService', version='v202008')
# Filter by email address.
query = 'WHERE email = :email'
values = [
{
'key': 'email',
'value': {
'xsi_type': 'TextValue',
'value': email_address
}
},
]
statement = ad_manager.FilterStatement(query, values)
response = user_service.getUsersByStatement(statement.ToStatement())
# A user is required.
no_user_found = False
try:
no_user_found = True if len(response['results']) < 1 else False
except (AttributeError, KeyError):
no_user_found = True
if no_user_found:
raise DFPObjectNotFound('No DFP user found with given email address.')
# Only get the first user in case there are multiple matches.
user = response['results'][0]
logger.info(u'Found user with the given email address.')
return user['id']
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
"""
dfp_client = get_client()
placement_service = dfp_client.GetService('PlacementService',
version='v201908')
query = 'WHERE name = :name'
values = [
{
'key': 'name',
'value': {
'xsi_type': 'TextValue',
'value': placement_name
}
},
]
statement = ad_manager.FilterStatement(query, values)
response = placement_service.getPlacementsByStatement(
statement.ToStatement())
no_placement_found = False
try:
no_placement_found = True if len(response['results']) < 1 else False
except (AttributeError, KeyError):
no_placement_found = True
if no_placement_found:
raise DFPObjectNotFound(
'No DFP placement found with name {0}'.format(placement_name))
else:
placement = response['results'][0]
logger.info(u'Found placement with name "{name}".'.format(
name=placement['name']))
return placement
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='v201811')
# 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_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 get(self, method):
"""Delegate GET request calls to the DFP API."""
method = method.lower()
user_ndb = InitUser()
api_handler = APIHandler(_CLIENT_ID, _CLIENT_SECRET, user_ndb,
_APPLICATION_NAME)
network_code = self.request.get('network_code')
# parse parameters
try:
limit = int(self.request.get('limit', api_handler.page_limit))
except ValueError:
self.response.status = 400
return self.response.write('Limit must be an integer')
try:
offset = int(self.request.get('offset', 0))
except ValueError:
self.response.status = 400
return self.response.write('Offset must be an integer')
if method == 'networks':
return_obj = api_handler.GetAllNetworks()
else:
# construct PQL statement
where_clause = self.request.get('where', '')
statement = ad_manager.FilterStatement(where_clause,
limit=limit,
offset=offset)
try:
# throws KeyError if method not found
api_handler_func = getattr(api_handler,
self.api_handler_method_map[method])
except KeyError:
self.response.status = 400
self.response.write('API method not supported (%s).' % method)
# retrieve return_obj from api_handler and modify it
return_obj = api_handler_func(network_code, statement)
# process return_obj
if 'columns' in return_obj:
# special case: return_obj is from PQL Service
cols = return_obj['columns']
return_obj['results'] = [
unpack_row(row, cols) for row in return_obj['results']
]
else:
# regular case
return_obj['results'] = [
serialize_object(obj) for obj in return_obj['results']
]
if self.request.get('limit'):
return_obj['limit'] = limit
else:
try:
return_obj['limit'] = return_obj['totalResultSetSize']
except KeyError:
return_obj['limit'] = api_handler.page_limit
return_obj['offset'] = offset
# construct response headers
self.response.headers['Content-Type'] = 'application/json'
self.response.write(json.dumps(return_obj))
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
