def ValidateAction(action, web_services):
"""Validate Action object.
Args:
action: dict Action to perform.
web_services: module Web services.
Returns:
Action instance.
"""
if ZsiSanityCheck.IsPyClass(action): return action
SanityCheck.ValidateTypes(((action, dict), ))
if 'xsi_type' in action:
new_action = ZsiSanityCheck.GetPyClass(action['xsi_type'],
web_services)
elif 'type' in action:
new_action = ZsiSanityCheck.GetPyClass(action['type'], web_services)
else:
msg = 'The type of the action is missing.'
raise ValidationError(msg)
for key in action:
SanityCheck.ValidateTypes(((action[key], (str, unicode)), ))
new_action.__dict__.__setitem__('_%s' % key, action[key])
return new_action
def ValidateString_ValueMapEntry(value, web_services):
"""Validate String_ValueMapEntry object.
Args:
value: dict Value object.
web_services: module Web services.
Returns:
String_ValueMapEntry instance.
"""
if ZsiSanityCheck.IsPyClass(value):
return value
SanityCheck.ValidateTypes(((value, dict), ))
new_value = ZsiSanityCheck.GetPyClass('String_ValueMapEntry', web_services)
for key in value:
if key in ('value', ):
SanityCheck.ValidateTypes(((value[key], dict), ))
if 'xsi_type' in value[key]:
value_obj = ZsiSanityCheck.GetPyClass(value[key]['xsi_type'],
web_services)
else:
msg = ('The \'xsi_type\' of the value is missing.')
raise ValidationError(msg)
for sub_key in value[key]:
value_obj.__dict__.__setitem__('_%s' % sub_key,
value[key][sub_key])
data = value_obj
else:
SanityCheck.ValidateTypes(((value[key], (str, unicode)), ))
data = value[key]
new_value.__dict__.__setitem__('_%s' % key, data)
return new_value
def ValidateString_ParamMapEntry(param, web_services):
"""Validate String_ParamMapEntry object.
Args:
param: dict Param object.
web_services: module Web services.
Returns:
String_ParamMapEntry instance.
"""
if ZsiSanityCheck.IsPyClass(param):
return param
SanityCheck.ValidateTypes(((param, dict), ))
new_param = ZsiSanityCheck.GetPyClass('String_ParamMapEntry', web_services)
for key in param:
SanityCheck.ValidateTypes(((param[key], (str, unicode)), ))
if key in ('value', ):
if 'xsi_type' in param:
value = ZsiSanityCheck.GetPyClass(param['xsi_type'],
web_services)
elif 'type' in param:
value = ZsiSanityCheck.GetPyClass(param['type'], web_services)
else:
msg = ('The type of the param is missing.')
raise ValidationError(msg)
value.__dict__.__setitem__('_%s' % key, param[key])
data = value
else:
data = param[key]
new_param.__dict__.__setitem__('_%s' % key, data)
return new_param
def ZsiTransfomComplexType(wsdl_types, obj, xsi_type, web_service):
"""Transforms a python dictionary into a ZSI object.
Args:
wsdl_types: dict WSDL definitions of all types in the same service as the
given xsi_type.
obj: dict Dictionary to be made into a ZSI object.
xsi_type: str The name of the complex type this dictionary represents.
web_service: module The generated web service which uses this complex type.
Returns:
obj A ZSI object representing this complex type.
"""
obj_contained_type, contained_type_key = Utils.GetExplicitType(wsdl_types,
obj, xsi_type)
if obj_contained_type:
xsi_type = obj_contained_type
new_object = ZsiSanityCheck.GetPyClass(xsi_type, web_service)
parameters = Utils.GenParamOrder(wsdl_types, xsi_type)
for key in obj:
if not obj[key] or key == contained_type_key:
continue
for parameter, param_type in parameters:
if parameter == key:
new_object.__dict__.__setitem__(
'_%s' % key, MakeZsiCompatible(obj[key], param_type, wsdl_types,
web_service))
break
return new_object
def MakeZsiCompatible(obj, xsi_type, wsdl_types, web_service):
"""Ensures a given object is compatible with ZSI, possibly by transforming it.
Dictionaries with valid xsi_types are transformed into ZSI objects. Everything
else is returned in the same data type as it was given. List and dictionary
contents will be recursively checked/altered for compatibility.
Args:
obj: obj The python object to make ZSI compatible. Should be a dict,
list, or string depending on the xsi_type. May also already be a ZSI
object, in which case it is returned unaltered.
xsi_type: str The WSDL-defined type of the given object.
wsdl_types: dict A map of all WSDL-defined types in the same service as the
given type.
web_service: module The generated web service which uses this object.
Returns:
obj The python object passed in, compatible with ZSI.
"""
if (ZsiSanityCheck.IsPyClass(obj) or not xsi_type in wsdl_types or
wsdl_types[xsi_type]['soap_type'] == 'simple'):
return obj
elif wsdl_types[xsi_type]['soap_type'] == 'complex':
return ZsiTransfomComplexType(wsdl_types, obj, xsi_type, web_service)
elif wsdl_types[xsi_type]['soap_type'] == 'array':
return ZsiTransfomArray(wsdl_types, obj, xsi_type, web_service)
def ValidateStatement(statement, web_services):
"""Validate Statement object.
Args:
statement: dict Statement object.
web_services: module Web services.
Returns:
Statement instance.
"""
if ZsiSanityCheck.IsPyClass(statement):
return statement
SanityCheck.ValidateTypes(((statement, dict), ))
new_statement = ZsiSanityCheck.GetPyClass('Statement', web_services)
for key in statement:
if key in ('params', ):
SanityCheck.ValidateTypes(((statement[key], list), ))
if len(statement[key]) > 1:
msg = (
'Map \'params\' must contain a single element in the list.'
)
raise ValidationError(msg)
params = []
for param in statement[key]:
params.append(ValidateString_ParamMapEntry(
param, web_services))
data = params
elif key in ('values', ):
SanityCheck.ValidateTypes(((statement[key], list), ))
if len(statement[key]) > 1:
msg = (
'Map \'values\' must contain a single element in the list.'
)
raise ValidationError(msg)
values = []
for value in statement[key]:
values.append(ValidateString_ValueMapEntry(
value, web_services))
data = values
else:
SanityCheck.ValidateTypes(((statement[key], (str, unicode)), ))
data = statement[key]
new_statement.__dict__.__setitem__('_%s' % key, data)
return new_statement
def ValidateCustomCriteria(criteria, web_services):
"""Validate CustomCriteria object.
Args:
criteria: dict CustomCriteria object.
web_services: module Web services.
Returns:
CustomCriteria instance.
"""
if ZsiSanityCheck.IsPyClass(criteria): return criteria
SanityCheck.ValidateTypes(((criteria, dict), ))
new_criteria = ZsiSanityCheck.GetPyClass(criteria['xsi_type'],
web_services)
for key in criteria:
if key in ('values', ):
values = []
for item in criteria[key]:
SanityCheck.ValidateTypes(((item, dict), ))
value = ZsiSanityCheck.GetPyClass('CustomTargetingValue',
web_services)
for sub_key in item:
SanityCheck.ValidateTypes(
((item[sub_key], (str, unicode)), ))
value.__dict__.__setitem__('_%s' % sub_key, item[sub_key])
values.append(value)
data = values
elif key in ('valueIds', ):
SanityCheck.ValidateTypes(((criteria[key], list), ))
for item in criteria[key]:
SanityCheck.ValidateTypes(((item, (str, unicode)), ))
data = criteria[key]
else:
SanityCheck.ValidateTypes(((criteria[key], (str, unicode)), ))
data = criteria[key]
new_criteria.__dict__.__setitem__('_%s' % key, data)
return new_criteria
def ValidateCustomCriteriaSet(criteria_set, web_services):
"""Validate CustomCriteriaSet object.
Args:
criteria_set: dict CustomCriteriaSet object.
web_services: module Web services.
Returns:
CustomCriteriaSet instance.
"""
if ZsiSanityCheck.IsPyClass(criteria_set): return criteria_set
SanityCheck.ValidateTypes(((criteria_set, dict), ))
new_set = ZsiSanityCheck.GetPyClass(criteria_set['xsi_type'], web_services)
for key in criteria_set:
if key in ('children', ):
SanityCheck.ValidateTypes(((criteria_set[key], list), ))
children = []
for item in criteria_set[key]:
if 'xsi_type' in item:
if item['xsi_type'] in ('FreeFormCustomCriteria',
'PredefinedCustomCriteria'):
children.append(
ValidateCustomCriteria(item, web_services))
else:
children.append(
ValidateCustomCriteriaSet(item, web_services))
else:
msg = 'The \'xsi_type\' of node is missing.'
raise ValidationError(msg)
data = children
else:
SanityCheck.ValidateTypes(((criteria_set[key], (str, unicode)), ))
data = criteria_set[key]
new_set.__dict__.__setitem__('_%s' % key, data)
return new_set
def ValidateDefinedReportJobV13(job, web_services):
"""Validate DefinedReportJob object.
Args:
job: dict DefinedReportJob object.
web_services: module Web services.
Returns:
DefinedReportJob instance.
"""
report_type = ZsiSanityCheck.GetPyClass('DefinedReportJob', web_services)
new_job = report_type()
for key in job:
if job[key] == 'None': continue
if key in ('adGroups', 'adGroupStatuses', 'aggregationTypes',
'campaigns', 'campaignStatuses', 'clientEmails', 'keywords',
'keywordStatuses', 'selectedColumns'):
SanityCheck.ValidateTypes(((job[key], list), ))
for item in job[key]:
SanityCheck.ValidateTypes(((item, (str, unicode)), ))
else:
SanityCheck.ValidateTypes(((job[key], (str, unicode)), ))
new_job.__dict__.__setitem__('_%s' % key, job[key])
return new_job
def ValidateCreative(creative, web_services):
"""Validate Creative object.
Args:
creative: dict Creative object.
web_services: module Web services.
Returns:
Creative instance.
"""
if ZsiSanityCheck.IsPyClass(creative):
return creative
SanityCheck.ValidateTypes(((creative, dict), ))
if 'creativeType' in creative:
new_creative = ZsiSanityCheck.GetPyClass(creative['creativeType'],
web_services)
elif 'Creative_Type' in creative:
new_creative = ZsiSanityCheck.GetPyClass(creative['Creative_Type'],
web_services)
elif 'xsi_type' in creative:
new_creative = ZsiSanityCheck.GetPyClass(creative['xsi_type'],
web_services)
elif 'type' in creative:
new_creative = ZsiSanityCheck.GetPyClass(creative['type'],
web_services)
else:
msg = ('The type of the creative is missing.')
raise ValidationError(msg)
for key in creative:
if creative[key] == 'None': continue
if key in ('size', 'flashAssetSize', 'fallbackAssetSize', 'assetSize'):
ValidateSize(creative[key])
new_size = ZsiSanityCheck.GetPyClass('Size', web_services)
for sub_key in creative[key]:
new_size.__dict__.__setitem__('_%s' % sub_key,
creative[key][sub_key])
data = new_size
else:
SanityCheck.ValidateTypes(((creative[key], (str, unicode)), ))
data = creative[key]
new_creative.__dict__.__setitem__('_%s' % key, data)
return new_creative
def ValidateTargeting(targeting, web_services):
"""Validate Targeting object.
Args:
targeting: dict Targeting object.
web_services: module Web services.
Returns:
Targeting instance.
"""
if ZsiSanityCheck.IsPyClass(targeting): return targeting
SanityCheck.ValidateTypes(((targeting, dict), ))
for key in targeting:
if targeting[key] == 'None' or not targeting[key]: continue
if key in ('inventoryTargeting', 'geoTargeting'):
SanityCheck.ValidateTypes(((targeting[key], dict), ))
target = targeting[key]
for sub_key in target:
SanityCheck.ValidateTypes(((target[sub_key], list), ))
targets = []
for item in target[sub_key]:
if key in ('inventoryTargeting', ):
SanityCheck.ValidateTypes(((item, (str, unicode)), ))
targets.append(item)
elif key in ('geoTargeting', ):
SanityCheck.ValidateTypes(((item, dict), ))
if 'xsi_type' in item:
location = ZsiSanityCheck.GetPyClass(
item['xsi_type'], web_services)
else:
msg = 'The \'xsi_type\' of the geo targeting location is missing.'
raise ValidationError(msg)
for sub_sub_key in item:
SanityCheck.ValidateTypes(
((item[sub_sub_key], (str, unicode)), ))
location.__dict__.__setitem__(
'_%s' % sub_sub_key, item[sub_sub_key])
targets.append(location)
# If value is an empty list, remove key from the dictionary.
if not target[sub_key]:
target = Utils.UnLoadDictKeys(target, [sub_key])
target[sub_key] = targets
data = target
elif key in ('customTargeting', ):
data = ValidateCustomCriteriaSet(targeting[key], web_services)
elif key in ('dayPartTargeting', 'userDomainTargeting'):
SanityCheck.ValidateTypes(((targeting[key], dict), ))
target = targeting[key]
for sub_key in target:
if sub_key in ('dayParts', ):
SanityCheck.ValidateTypes(((target[sub_key], list), ))
targets = []
for item in target[sub_key]:
ValidateDayPart(item)
elif sub_key in ('domains', ):
SanityCheck.ValidateTypes(((target[sub_key], list), ))
for item in target[sub_key]:
SanityCheck.ValidateTypes(((item, (str, unicode)), ))
else:
SanityCheck.ValidateTypes(
((target[sub_key], (str, unicode)), ))
data = target
return data