def testSaveCreativeFieldValue(self):
"""Test whether we can save a creative field value"""
if self.__class__.creative_field_id == '0':
self.testSaveCreativeField()
creative_field_value = {
'name': 'FieldValue #%s' % Utils.GetUniqueName(),
'creativeFieldId': self.__class__.creative_field_id,
'id': '-1'
}
creative_field_value = self.__class__.service.SaveCreativeFieldValue(
creative_field_value)
self.__class__.creative_field_value_id = creative_field_value[0]['id']
self.assert_(isinstance(creative_field_value, tuple))
def main():
try:
Utils.GetAuthToken(login_email, password, AUTH_TOKEN_SERVICE, LIB_SIG,
None)
except AuthTokenError, e:
if str(e).find('InvalidSecondFactor') != -1:
print """The user has enabled two factor authentication in this
account. Have the user generate an application-specific password to make
calls against the AdWords API. See
http://adwordsapi.blogspot.com/2011/02/authentication-changes-with-2-step.html
for more details."""
else:
raise e
def main(client, order_id):
# Initialize appropriate service.
line_item_service = client.GetService('LineItemService', version='v201405')
# Create statement object to only select line items with even delivery rates.
values = [{
'key': 'deliveryRateType',
'value': {
'xsi_type': 'TextValue',
'value': 'EVENLY'
}
}, {
'key': 'orderId',
'value': {
'xsi_type': 'NumberValue',
'value': order_id
}
}]
query = 'WHERE deliveryRateType = :deliveryRateType and orderId = :orderId'
statement = DfpUtils.FilterStatement(query, values, 500)
# Get line items by statement.
response = line_item_service.GetLineItemsByStatement(
statement.ToStatement())[0]
line_items = response.get('results')
if line_items:
# Update each local line item by changing its delivery rate type.
updated_line_items = []
for line_item in line_items:
if not Utils.BoolTypeConvert(line_item['isArchived']):
line_item['deliveryRateType'] = 'AS_FAST_AS_POSSIBLE'
updated_line_items.append(line_item)
# Update line items remotely.
line_items = line_item_service.UpdateLineItems(updated_line_items)
# Display results.
if line_items:
for line_item in line_items:
print(
'Line item with id \'%s\', belonging to order id \'%s\', named '
'\'%s\', and delivery rate \'%s\' was updated.' %
(line_item['id'], line_item['orderId'], line_item['name'],
line_item['deliveryRateType']))
else:
print 'No line items were updated.'
else:
print 'No line items found to update.'
def _RestoreListTypesForResponse(response, xsi_type, service_type_map):
"""Restores list types for an individual response object.
Args:
response: obj An individual object returned by the webservice. May be a
dictionary, list, or string depending on what it represents.
xsi_type: str The WSDL-defined type of this response.
service_type_map: dict Information on WSDL-defined types in one service.
Returns:
obj The response in its proper format. May be a dictionary, list, or string
depending on what was input. Not guaranteed to output the same data type
that was input - may output a list instead.
"""
if isinstance(response, dict):
if not response: return response
for param, param_type in Utils.GenParamOrder(service_type_map,
xsi_type):
if not param in response or Utils.IsXsdOrSoapenc(param_type):
continue
value = response[param]
if (service_type_map[param_type]['soap_type'] == 'array'
and not isinstance(response[param], list)):
value = [value]
response[param] = _RestoreListTypesForResponse(
value, param_type, service_type_map)
return response
elif isinstance(response, list):
lst = []
for item in response:
if item is None: continue
lst.append(
_RestoreListTypesForResponse(
item, service_type_map[xsi_type]['base_type'],
service_type_map))
return lst
else:
return response
def main(client):
# Initialize appropriate service.
company_service = client.GetService('CompanyService', version='v201206')
# Create company objects.
companies = [
{
'name': 'Advertiser #%s' % Utils.GetUniqueName(),
'type': 'ADVERTISER'
},
{
'name': 'Agency #%s' % Utils.GetUniqueName(),
'type': 'AGENCY'
}
]
# Add companies.
companies = company_service.CreateCompanies(companies)
# Display results.
for company in companies:
print ('Company with ID \'%s\', name \'%s\', and type \'%s\' was created.'
% (company['id'], company['name'], company['type']))
def testAddRemarketingUserList(self):
"""Test whether we can add a remarketing user list."""
operations = [{
'operator': 'ADD',
'operand': {
'xsi_type':
'RemarketingUserList',
'name':
'Mars cruise customers #%s' % Utils.GetUniqueName(),
'description':
'A list of mars cruise customers in the last '
'year.',
'membershipLifeSpan':
'365',
'conversionTypes': [{
'name':
('Mars cruise customers #%s' % Utils.GetUniqueName())
}]
}
}]
user_lists = self.__class__.service.Mutate(operations)
self.__class__.user_list = user_lists[0]['value'][0]
self.assert_(isinstance(user_lists, tuple))
def testSaveSpotlightConfiguration(self):
"""Test whether we can save a spotlight configuration."""
spotlight_configuration = {
'name': 'SpotlightConfiguration #%s' % Utils.GetUniqueName(),
'id': self.__class__.advertiser_id,
'firstDayOfWeek': '1',
'motifEventsDays': '30',
'clickDays': '30',
'impressionDays': '30'
}
spotlight_configuration = self.__class__.service.SaveSpotlightConfiguration(
spotlight_configuration)
self.__class__.configuration_id = spotlight_configuration[0]['id']
self.assert_(isinstance(spotlight_configuration, tuple))
def testCreateAdUnit(self):
"""Test whether we can create an ad unit."""
ad_unit = {
'name': 'Ad_Unit_%s' % Utils.GetUniqueName(),
'parentId': self.__class__.root_ad_unit_id,
'sizes': [{
'width': '300',
'height': '250'
}],
'description': 'Ad unit description.',
'targetWindow': 'BLANK'
}
self.assert_(
isinstance(self.__class__.service.CreateAdUnit(ad_unit), tuple))
def sign(self, soap_writer):
"""Sign signature handler.
Args:
soap_writer: SoapWriter instance.
"""
keys = []
for key in self.__headers:
keys.append((key, self.__headers[key]))
keys = tuple(keys)
header = soap_writer._header
body = soap_writer.body
# Set RequestHeader element, if appropriate.
if 'ns_target' in self.__config:
name_space, target = self.__config['ns_target']
header = header.createAppendElement('', target)
header.setNamespaceAttribute('', name_space)
# Explicitly set namespace at the request method's level. For services
# with multiple namespaces, this has to be done prior to checking where
# RequestHeader elements point.
if body._getElements():
body._getElements()[0].setAttributeNS('', 'xmlns:ns1',
name_space)
# Make sure that the namespace for RequestHeader elements is pointing
# at default namespace, if present.
if (self.__group and self.__group
not in Utils.GetPathFromUrl(name_space).split('/')):
parts = name_space.split('/')
parts[-2] = self.__group
name_space = '/'.join(parts)
else:
name_space = ''
for key, value in keys:
if value:
if isinstance(value, dict):
if 'auth_type' not in self.__config:
self.__config['auth_type'] = ''
obj = header.createAppendElement(name_space, key)
obj.node.setAttribute('xsi:type',
self.__config['auth_type'])
for sub_key in value:
obj.createAppendElement(name_space,
sub_key).createAppendTextNode(
value[sub_key])
else:
header.createAppendElement(name_space,
key).createAppendTextNode(value)
def SoappySanityCheck(soappy_service, obj, ns, obj_type, max_occurs='1'):
"""Validates any given object against its WSDL definition.
This method considers None and the empty string to be a valid representation
of any type.
Args:
soappy_service: SOAPpy.WSDL.Proxy An object encapsulating a SOAP service.
obj: Object to be validated. Depending on the WSDL-defined type this object
represents, the data type will vary. It should always be either a
dictionary, list, or string no matter what WSDL-defined type it is.
ns: string The namespace the given type belongs to.
obj_type: A string specifying the type name defined in the WSDL.
max_occurs: string The maxOccurs attribute for this object.
Raises:
ValidationError: The given type has no definition in the WSDL or the given
object is not a valid representation of the type defined in
the WSDL.
"""
if obj in (None, ''):
return
elif Utils.IsBaseSoapType(obj_type):
try:
ValidateTypes(((obj, (str, unicode)), ))
except ValidationError:
raise ValidationError(
'Objects of type \'%s\' should be a string but '
'value \'%s\' is a \'%s\' instead.' %
(obj_type, obj, type(obj)))
else:
try:
soap_type = soappy_service.wsdl.types[ns].types[obj_type].tag
if soap_type == 'simpleType':
_SoappySanityCheckSimpleType(obj, obj_type)
elif soap_type == 'complexType':
if (SoappyUtils.IsAnArrayType(obj_type, ns, soappy_service)
or not max_occurs.isdigit() or int(max_occurs) > 1):
_SoappySanityCheckArray(soappy_service, obj, ns, obj_type)
else:
_SoappySanityCheckComplexType(soappy_service, obj, ns,
obj_type)
else:
raise ValidationError(
'Unrecognized type definition tag in WSDL: \'%s\'' %
soap_type)
except KeyError:
raise ValidationError(
'This type is not defined in the WSDL: \'%s\'' % obj_type)
def DownloadMCCReport(self, report_definition_id, file_path=None,
return_micros=False, tries=50, sleep=30):
"""Blocking call to download a MCC report.
This method will try to successfully download the report to the specified
file_path, throwing an AdWordsApiError. If file_path is None or not
provided, will return as a string the downloaded report.
Args:
report_definition_id: str Id of the report definition to download.
file_path: str File path to download to. Optional, returns string if None.
return_micros: bool Whether to return currency in micros.
tries: int Optional number of times to retry.
sleep: int Optional number of seconds to sleep between retries.
Returns:
str Report data or a tuple of filename and bytes written if file_path is
not None.
Raises:
AdWordsApiError: When we encounter a server error
"""
response = self.GetMCCReportStatus(report_definition_id, return_micros,
'new')
while response['httpStatus'] != 301 and tries > 0:
if response['httpStatus'] != 200:
msg = []
if 'state' in response: msg.append(response['state'])
if 'failureReason' in response: msg.append(response['failureReason'])
raise AdWordsApiError({
'faultcode': '500',
'faultstring': ' '.join(msg)})
# Otherwise, it should be status == 200 which means try again later.
if Utils.BoolTypeConvert(self._config['debug']):
print 'Sleeping with %i tries left' % tries
tries -= 1
time.sleep(sleep)
response = self.GetMCCReportStatus(report_definition_id, return_micros,
response['queryToken'])
if tries <= 0:
raise AdWordsApiError({'faultstring': 'No more retries left.'})
# On success, get the download URL from the Location header
url = None
if 'Location' in response['headers']:
url = response['headers']['Location']
else:
url = response['headers']['location']
headers = self.__GenerateHeaders(return_micros)
return self.__DownloadFile(url, headers, file_path)
def DownloadReport(report_job_id, export_format, service):
"""Download and return report data.
Args:
report_job_id: str ID of the report job.
export_format: str Export format for the report file.
service: GenericDfpService A service pointing to the ReportService.
Returns:
str Report data or empty string if report failed.
"""
SanityCheck.ValidateTypes(((report_job_id, (str, unicode)), ))
# Wait for report to complete.
status = service.GetReportJob(report_job_id)[0]['reportJobStatus']
while status != 'COMPLETED' and status != 'FAILED':
if Utils.BoolTypeConvert(service._config['debug']):
print 'Report job status: %s' % status
time.sleep(30)
status = service.GetReportJob(report_job_id)[0]['reportJobStatus']
if status == 'FAILED':
if Utils.BoolTypeConvert(service._config['debug']):
print 'Report process failed'
return ''
else:
if Utils.BoolTypeConvert(service._config['debug']):
print 'Report has completed successfully'
# Get report download URL.
report_url = service.GetReportDownloadURL(report_job_id, export_format)[0]
# Download report.
data = urllib.urlopen(report_url).read()
data = gzip.GzipFile(fileobj=StringIO.StringIO(data)).read()
return data
def CreateTestCreative(client, server, version, advertiser_id):
"""Create a test creative.
Args:
client: DfpClient used for service creation.
server: str the API server.
version: str the API version.
advertiser_id: str the company ID for the creative's advertiser.
Returns:
The ID of the creative.
"""
creative_service = client.GetService('CreativeService', server, version)
# Create creative object.
image_data = Utils.ReadFile(
os.path.join(__file__[:__file__.rfind('/')], '..', 'data',
'medium_rectangle.jpg'))
image_data = base64.encodestring(image_data)
creative = {
'type': 'ImageCreative',
'name': 'Image Creative #%s' % Utils.GetUniqueName(),
'advertiserId': advertiser_id,
'destinationUrl': 'http://google.com',
'imageName': 'image.jpg',
'imageByteArray': image_data,
'size': {
'width': '300',
'height': '250'
}
}
# Add creatives.
creatives = creative_service.CreateCreatives([creative])
return creatives[0]['id']
def testAddConversion(self):
"""Test whether we can add a conversion."""
operations = [{
'operator': 'ADD',
'operand': {
'xsi_type': 'AdWordsConversionTracker',
'name': 'Mars cruise customers #%s' % Utils.GetUniqueName(),
'category': 'DEFAULT',
'markupLanguage': 'HTML',
'httpProtocol': 'HTTP',
'textFormat': 'HIDDEN'
}
}]
self.assert_(
isinstance(self.__class__.service.Mutate(operations), tuple))
def testSaveSpotlightActivityGroup(self):
"""Test whether we can save a spotlight activity group."""
if self.__class__.configuration_id == '0':
self.testSaveSpotlightConfiguration()
configuration_id = self.__class__.configuration_id
spotlight_activity_group = {
'name': 'SpotlightActivityGroup #%s' % Utils.GetUniqueName(),
'groupType': '1', # Counter Activity
'spotlightConfigurationId': configuration_id
}
spotlight_activity_group = \
self.__class__.service.SaveSpotlightActivityGroup(
spotlight_activity_group)
self.__class__.activity_group_id = spotlight_activity_group[0]['id']
self.assert_(isinstance(spotlight_activity_group, tuple))
def main(client, image_filename):
# Initialize appropriate service.
media_service = client.GetMediaService(version='v201406')
image_data = Utils.ReadFile(image_filename)
image_data = base64.encodestring(image_data)
# Construct media and upload image.
media = [{'xsi_type': 'Image', 'data': image_data, 'type': 'IMAGE'}]
media = media_service.Upload(media)[0]
# Display results.
if media:
dimensions = Utils.GetDictFromMap(media['dimensions'])
print(
'Image with id \'%s\', dimensions \'%sx%s\', and MimeType \'%s\' was'
' uploaded.' % (media['mediaId'], dimensions['FULL']['height'],
dimensions['FULL']['width'], media['mimeType']))
else:
print 'No images were uploaded.'
print
print('Usage: %s units, %s operations' %
(client.GetUnits(), client.GetOperations()))
def testAssignCreativesToPlacements(self):
"""Test whether we can assign creatives to placements."""
if self.__class__.creative_id == '0':
self.testSaveCreative()
creative_id = self.__class__.creative_id
placement_id = self.__class__.placement_id
creative_placement_assignments = [{
'adName': 'Ad #%s' % Utils.GetUniqueName(),
'creativeId': creative_id,
'placementId': placement_id,
'placementIds': [placement_id, placement_id]
}]
creative_placement_assignments = \
self.__class__.service.AssignCreativesToPlacements(
creative_placement_assignments)
self.assert_(isinstance(creative_placement_assignments, tuple))
def testCreateCreative(self):
"""Test whether we can create a creative."""
creative = {
'type': 'ImageCreative',
'name': 'Image Creative #%s' % Utils.GetUniqueName(),
'advertiserId': self.__class__.advertiser_id,
'destinationUrl': 'http://google.com',
'imageName': 'image.jpg',
'imageByteArray': self.__class__.IMAGE_DATA1,
'size': {
'width': '300',
'height': '250'
}
}
self.assert_(
isinstance(self.__class__.service.CreateCreative(creative), tuple))
def CreateCampaignWithBiddingStrategy(client, bidding_strategy_id, budget_id):
""" Create a Campaign with a Shared Bidding Strategy.
Args:
client: AdWordsClient the client to run the example with.
bidding_strategy_id: string the bidding strategy ID to use.
shared_budget_id: string the shared budget ID to use.
Returns:
dict An object representing a campaign.
"""
# Initialize appropriate service.
campaign_service = client.GetCampaignService(version='v201406')
# Create campaign.
campaign = {
'name': 'Interplanetary Cruise #%s' % Utils.GetUniqueName(),
'advertisingChannelType': 'SEARCH',
'budget': {
'budgetId': budget_id
},
'biddingStrategyConfiguration': {
'biddingStrategyId': bidding_strategy_id
},
'settings': [{
'xsi_type': 'KeywordMatchSetting',
'optIn': 'true'
}],
'networkSetting': {
'targetGoogleSearch': 'true',
'targetSearchNetwork': 'true',
'targetContentNetwork': 'true'
}
}
# Create operation.
operation = {'operator': 'ADD', 'operand': campaign}
response = campaign_service.mutate([operation])[0]
new_campaign = response['value'][0]
print('Campaign with name \'%s\', ID \'%s\' and bidding scheme ID \'%s\' '
'was created.' %
(new_campaign['name'], new_campaign['id'],
new_campaign['biddingStrategyConfiguration']['biddingStrategyId']))
return new_campaign
def __GenerateHeaders(self,
return_micros=None,
skip_report_header=None,
skip_report_summary=None):
"""Generates the headers to use for the report download.
Args:
return_micros: bool whether or not to use micros for money.
skip_report_header: A boolean indicating whether to include a header row
containing the report name and date range. If false or not specified,
report output will include the header row.
skip_report_summary: A boolean indicating whether to include a summary row
containing the report totals. If false or not specified, report output
will include the summary row.
Returns:
dict Dictionary containing all the headers for the request
"""
headers = {}
if 'clientCustomerId' in self._headers:
headers['clientCustomerId'] = self._headers['clientCustomerId']
# Apply OAuth2 headers
self._headers['oauth2credentials'].apply(headers)
if skip_report_header:
headers.update({'skipReportHeader': str(skip_report_header)})
if skip_report_summary:
headers.update({'skipReportSummary': str(skip_report_summary)})
if return_micros is not None:
if self._op_config[
'version'] == FINAL_RETURN_MONEY_IN_MICROS_VERSION:
headers['returnMoneyInMicros'] = str(return_micros)
else:
raise AdWordsError(
'returnMoneyInMicros isn\'t supported in this'
' version.')
headers['developerToken'] = self._headers['developerToken']
headers['User-Agent'] = self._headers['userAgent']
if Utils.BoolTypeConvert(self._config['compress']):
headers['Accept-Encoding'] = 'gzip'
headers['User-Agent'] += ',gzip'
headers['Content-Encoding'] = 'gzip'
return headers
def _SetHeaders(self):
"""Sets the SOAP headers for this service's requests."""
now = time.time()
if ((('authToken' not in self._headers
and 'auth_token_epoch' not in self._config) or
int(now - self._config['auth_token_epoch']) >= AUTH_TOKEN_EXPIRE)
and not self._headers.get('oauth2credentials')):
if ('email' not in self._headers or not self._headers['email']
or 'password' not in self._headers
or not self._headers['password']):
raise ValidationError(
'Required authentication headers, \'email\' and '
'\'password\', are missing. Unable to regenerate '
'authentication token.')
self._headers['authToken'] = Utils.GetAuthToken(
self._headers['email'], self._headers['password'],
AUTH_TOKEN_SERVICE, LIB_SIG, self._config['proxy'])
self._config['auth_token_epoch'] = time.time()
# Apply headers to the SOAPpy service.
soap_headers = SOAPpy.Types.headerType(
attrs={'xmlns': self._namespace})
request_header_data = {}
if 'authToken' in self._headers:
authentication_block = SOAPpy.Types.structType(
data={'token': self._headers['authToken']},
name='authentication',
typed=0,
attrs={(SOAPpy.NS.XSI3, 'type'): 'ClientLogin'})
request_header_data['authentication'] = authentication_block
for key in self._headers:
if (key in GenericDfpService._IGNORED_HEADER_VALUES
or not self._headers[key]):
continue
value = self._headers[key]
if key == 'applicationName':
value = ''.join([value, LIB_SIG])
request_header_data[key] = SOAPpy.Types.stringType(value)
request_header = SOAPpy.Types.structType(data=request_header_data,
name='RequestHeader',
typed=0)
soap_headers.RequestHeader = request_header
if 'authToken' in self._headers:
soap_headers.RequestHeader._keyord = [
'applicationName', 'authentication'
]
self._soappyservice.soapproxy.header = soap_headers
def __init__(self,
client_id,
client_secret,
refresh_token,
mcc_cid,
dev_token,
debug=False):
"""Initializes an APIHandler.
Args:
client_id:
client_secret:
refresh_token:
mcc_cid:
dev_token:
debug:
"""
credentials = OAuth2Credentials(None, client_id, client_secret,
refresh_token, None, self._REFRESH_URL,
self._USER_AGENT)
credentials.refresh(httplib2.Http())
headers = {
'clientCustomerId': mcc_cid,
'userAgent': self._USER_AGENT,
'developerToken': dev_token,
'validateOnly': 'n',
'partialFailure': 'n',
'oauth2credentials': credentials
}
# App Engine doesn't allow you to write to the disk. Thus, we need to
# explicitly turn off logging. Though, if debugging is enabled, the
# data from STDOUT will be redirected to app engine's debugging console.
# Note that we also specify that we want to use ElementTree here; see the
# README for more information if you would rather use PyXML.
config = {
'debug': Utils.BoolTypeConvert(debug),
'xml_log': 'n',
'request_log': 'n',
'pretty_xml': 'n',
'xml_parser': '2', # We're using ElementTree.
'compress': 'n'
}
self.client = AdWordsClient(headers, config)
self.client.use_mcc = True
def testSaveSpotlightActivity(self):
"""Test whether we can save a spotlight activity."""
if self.__class__.activity_group_id == '0':
self.testSaveSpotlightActivityGroup()
activity_group_id = self.__class__.activity_group_id
spotlight_activity = {
'name': 'SpotlightActivity #%s' % Utils.GetUniqueName(),
'activityGroupId': activity_group_id,
'activityTypeId': '1', # Counter Activity
'tagMethodTypeId': '1', # Standard
'expectedUrl': 'http://www.example.com',
'countryId': '256' #USA
}
spotlight_activity = self.__class__.service.SaveSpotlightActivity(
spotlight_activity)
self.__class__.activity_id = spotlight_activity[0]['id']
self.assert_(isinstance(spotlight_activity, tuple))
def testSaveUserRole(self):
"""Test whether we can save a user role"""
subnetwork_id = self.__class__.user_self['subnetworkId']
user_group_id = self.__class__.user_self['userGroupId']
user_role = {
'name': 'UserRole #%s' % Utils.GetUniqueName(),
'subnetworkId': subnetwork_id,
'parentUserRoleId': user_group_id,
'permissions': [{
'id': '2068'
}, {
'id': '2037'
}]
}
user_role = self.__class__.service.SaveUserRole(user_role)
self.__class__.user_role_id = user_role[0]['id']
self.assert_(isinstance(user_role, tuple))
def main(client, advertiser_id):
# Initialize appropriate service.
creative_service = client.GetService('CreativeService', version='v201411')
# Create creative objects.
creatives = []
with open(os.path.join(os.path.split(__file__)[0], '..', '..', 'data',
'medium_rectangle.jpg'), 'r') as image:
image_data = base64.encodestring(image.read())
for i in xrange(5):
# Create creative size.
size = {
'width': '300',
'height': '250'
}
# Create image asset.
creative_asset = {
'type': 'CreativeAsset',
'fileName': 'image.jpg',
'assetByteArray': image_data,
'size': size
}
# Create an image creative.
creative = {
'type': 'ImageCreative',
'name': 'Image Creative #%s' % Utils.GetUniqueName(),
'advertiserId': advertiser_id,
'destinationUrl': 'http://google.com',
'size': size,
'primaryImageAsset': creative_asset
}
creatives.append(creative)
# Add creatives.
creatives = creative_service.CreateCreatives(creatives)
# Display results.
for creative in creatives:
print ('Image creative with id \'%s\', name \'%s\', and type \'%s\' was '
'created and can be previewed at %s.'
% (creative['id'], creative['name'], creative['Creative_Type'],
creative['previewUrl']))
def setUp(self):
"""Prepare unittest."""
print self.id()
if not self.__class__.service:
self.__class__.service = client.GetCreativeService(
self.__class__.SERVER, self.__class__.VERSION, HTTP_PROXY)
if self.__class__.advertiser_id == '0':
company = {
'name': 'Company #%s' % Utils.GetUniqueName(),
'type': 'ADVERTISER'
}
company_service = client.GetCompanyService(self.__class__.SERVER,
self.__class__.VERSION,
HTTP_PROXY)
self.__class__.advertiser_id = company_service.CreateCompany(
company)[0]['id']
def _SanityCheckArray(wsdl_types, obj, xsi_type):
"""Validates a list representing an array type against its WSDL definition.
Args:
wsdl_types: dict WSDL-defined types in the same service as the given type.
obj: list List representing the given array type.
xsi_type: str The array type name defined in the WSDL.
"""
ValidateTypes(((obj, list), ))
if Utils.IsXsdOrSoapenc(wsdl_types[xsi_type]['base_type']):
for item in obj:
if item is None: continue
ValidateTypes(((item, (str, unicode)), ))
else:
for item in obj:
if item is None: continue
NewSanityCheck(wsdl_types, item, wsdl_types[xsi_type]['base_type'])
def __PrettyPrintXml(self, doc, level=0):
"""Return a pretty-printed version of the XML document.
Args:
doc: str XML document.
level: int Level of prettiness, defaults to 0. If -1, remove prettiness.
Returns:
str Pretty-printed version of the XML document.
"""
# Make sure we have a valid doc to work with.
if Utils.IsHtml(doc):
return doc
try:
if self.__xml_parser == PYXML:
dom = minidom.parseString(doc)
pretty_doc = dom.toprettyxml(indent=' ', encoding='UTF-8')
elif self.__xml_parser == ETREE:
tree = etree.fromstring(doc)
self.__Indent(tree)
pretty_doc = etree.tostring(tree, 'UTF-8')
except (ExpatError, SyntaxError):
# If there was a problem with loading XML message into a DOM, return
# original XML message.
return doc
# Adjust prettiness of data values in the XML document.
#
# Before: <operations>
# 0
# </operations>
#
# After: <operations>0</operations>
pattern = re.compile('\n\s+\n')
pretty_doc = pattern.sub('\n', pretty_doc)
groups = re.findall('>(\n\s+(.*?)\n\s+)</', pretty_doc, re.M)
for old, new in groups:
if old and new and (new.find('<') > -1 or new.find('>') > -1):
continue
pretty_doc = pretty_doc.replace(old, new)
if level == -1:
pattern = re.compile('>\s+<')
pretty_doc = pattern.sub('><', pretty_doc)
return pretty_doc.strip('\n')
def _SetHeaders(self):
"""Sets the SOAP headers for this service's requests."""
now = time.time()
if ((('authToken' not in self._headers
and 'auth_token_epoch' not in self._config) or
int(now - self._config['auth_token_epoch']) >= AUTH_TOKEN_EXPIRE)
and not self._headers.get('oauth2credentials')):
if ('email' not in self._headers or not self._headers['email']
or 'password' not in self._headers
or not self._headers['password']):
raise ValidationError(
'Required authentication headers, \'email\' and '
'\'password\', are missing. Unable to regenerate '
'authentication token.')
self._headers['authToken'] = Utils.GetAuthToken(
self._headers['email'], self._headers['password'],
AUTH_TOKEN_SERVICE, LIB_SIG, self._config['proxy'])
self._config['auth_token_epoch'] = time.time()
# Apply headers to the SOAPpy service.
header_attrs = {
'xmlns':
self._namespace,
'xmlns:cm': ('https://adwords.google.com/api/adwords/cm/' +
self._op_config['version'])
}
soap_headers = SOAPpy.Types.headerType(attrs=header_attrs)
request_header_data = {}
for key in GenericAdWordsService._POSSIBLE_ADWORDS_REQUEST_HEADERS:
if (key in GenericAdWordsService._OAUTH_IGNORE_HEADERS
and self._headers.get('oauth2credentials')):
continue
if key in self._headers and self._headers[key]:
value = self._headers[key]
if key in GenericAdWordsService._STR_CONVERT:
value = str(value)
elif key == 'userAgent':
value = ''.join([value, LIB_SIG])
request_header_data['cm:' +
key] = SOAPpy.Types.stringType(value)
request_header = SOAPpy.Types.structType(data=request_header_data,
name='RequestHeader',
typed=0)
soap_headers.RequestHeader = request_header
self._soappyservice.soapproxy.header = soap_headers
def _PackStringAsXml(obj, xml_tag_name):
"""Pack a Python string into an XML string.
Args:
obj: str Python string to pack.
xml_tag_name: str The name of the XML tag that will house this string.
Returns:
str An XML element representing the given string.
"""
if obj is None:
return '<%s xsi3:nil="true" />' % (xml_tag_name)
else:
obj = Utils.HtmlEscape(obj)
if xml_tag_name:
return '<%s>%s</%s>' % (xml_tag_name, obj, xml_tag_name)
else:
return obj
