def create_upload(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.productfeedupload import ProductFeedUpload
self.assure_call()
param_types = {
'file': 'file',
'id': 'string',
'password': '******',
'url': 'string',
'username': '******',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/uploads',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ProductFeedUpload,
api_type='EDGE',
response_parser=ObjectParser(target_class=ProductFeedUpload),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
return request if pending else request.execute()
def get_keyword_stats(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.adkeywordstats import AdKeywordStats
param_types = {
'date': 'datetime',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/keywordstats',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdKeywordStats,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdKeywordStats),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_targeting_sentence_lines(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.targetingsentenceline import TargetingSentenceLine
param_types = {}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/targetingsentencelines',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=TargetingSentenceLine,
api_type='EDGE',
response_parser=ObjectParser(target_class=TargetingSentenceLine),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_picture(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.profilepicturesource import ProfilePictureSource
param_types = {
'height': 'int',
'redirect': 'bool',
'type': 'type_enum',
'width': 'int',
}
enums = {
'type_enum': ProfilePictureSource.Type.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/picture',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ProfilePictureSource,
api_type='EDGE',
response_parser=ObjectParser(target_class=ProfilePictureSource),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_ad_label(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.adlabel import AdLabel
param_types = {
'adlabels': 'list<Object>',
'execution_options': 'list<execution_options_enum>',
}
enums = {
'execution_options_enum':
AdLabel.ExecutionOptions.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/adlabels',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdLabel,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdLabel),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def api_get(self, fields=None, params=None, batch=None, pending=False):
param_types = {
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ReachFrequencyPrediction,
api_type='NODE',
response_parser=ObjectParser(reuse_object=self),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_test_lead(self,
fields=None,
params=None,
batch=None,
pending=False):
param_types = {
'custom_disclaimer_responses': 'list<Object>',
'field_data': 'list<Object>',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/test_leads',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=LeadgenForm,
api_type='EDGE',
response_parser=ObjectParser(target_class=LeadgenForm,
api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_ad_account(self, fields=None, params=None, batch=None, pending=False):
param_types = {
'account_id': 'string',
'auto_track_for_ads': 'bool',
'business': 'string',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/adaccounts',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AbstractCrudObject,
api_type='EDGE',
response_parser=ObjectParser(target_class=AbstractCrudObject, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_stats(self, fields=None, params=None, batch=None, pending=False):
param_types = {
'aggr_time': 'aggr_time_enum',
'end': 'int',
'skip_empty_values': 'bool',
'start': 'int',
'user_timezone_id': 'unsigned int',
}
enums = {
'aggr_time_enum': [
'upload_time',
'event_time',
],
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/stats',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AbstractCrudObject,
api_type='EDGE',
response_parser=ObjectParser(target_class=AbstractCrudObject, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_offline_conversion_data_set(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.offlineconversiondataset import OfflineConversionDataSet
param_types = {
'auto_assign_to_new_accounts_only': 'bool',
'description': 'string',
'enable_auto_assign_to_accounts': 'bool',
'name': 'string',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/offline_conversion_data_sets',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=OfflineConversionDataSet,
api_type='EDGE',
response_parser=ObjectParser(target_class=OfflineConversionDataSet,
api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_ad_accounts(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.adaccount import AdAccount
param_types = {
'business': 'string',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/adaccounts',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdAccount,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdAccount, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_offline_conversion_data_sets(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.offlineconversiondataset import OfflineConversionDataSet
param_types = {}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/offline_conversion_data_sets',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=OfflineConversionDataSet,
api_type='EDGE',
response_parser=ObjectParser(target_class=OfflineConversionDataSet,
api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_grp_plans(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.reachfrequencyprediction import ReachFrequencyPrediction
param_types = {
'status': 'status_enum',
}
enums = {
'status_enum': ReachFrequencyPrediction.Status.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/grp_plans',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ReachFrequencyPrediction,
api_type='EDGE',
response_parser=ObjectParser(target_class=ReachFrequencyPrediction,
api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_event_source_group(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.eventsourcegroup import EventSourceGroup
param_types = {
'event_sources': 'list<string>',
'name': 'string',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/event_source_groups',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=EventSourceGroup,
api_type='EDGE',
response_parser=ObjectParser(target_class=EventSourceGroup,
api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def api_update(self, fields=None, params=None, batch=None, pending=False):
param_types = {
'variants': 'list<Object>',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ProductGroup,
api_type='NODE',
response_parser=ObjectParser(reuse_object=self),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_uploads(self, fields=None, params=None, batch=None, pending=False):
param_types = {
'upload_tag': 'string',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/uploads',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AbstractCrudObject,
api_type='EDGE',
response_parser=ObjectParser(target_class=AbstractCrudObject, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_requests(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.adasyncrequest import AdAsyncRequest
param_types = {
'statuses': 'list<statuses_enum>',
}
enums = {
'statuses_enum': AdAsyncRequest.Statuses.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/requests',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdAsyncRequest,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdAsyncRequest,
api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_products(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.productitem import ProductItem
param_types = {
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/products',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ProductItem,
api_type='EDGE',
response_parser=ObjectParser(target_class=ProductItem),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def api_update(self, fields=None, params=None, batch=None, pending=False):
self.assure_call()
param_types = {
'default_currency': 'string',
'deletion_enabled': 'bool',
'delimiter': 'delimiter_enum',
'encoding': 'encoding_enum',
'id': 'string',
'name': 'string',
'quoted_fields': 'bool',
'schedule': 'string',
}
enums = {
'delimiter_enum': ProductFeed.Delimiter.__dict__.values(),
'encoding_enum': ProductFeed.Encoding.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AbstractCrudObject,
api_type='NODE',
response_parser=ObjectParser(reuse_object=self),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
return request if pending else request.execute()
def get_insights_async(self, fields=None, params=None, batch=None, pending=False):
from facebookads.adobjects.adreportrun import AdReportRun
from facebookads.adobjects.adsinsights import AdsInsights
param_types = {
'action_attribution_windows': 'list<action_attribution_windows_enum>',
'action_breakdowns': 'list<action_breakdowns_enum>',
'action_report_time': 'action_report_time_enum',
'breakdowns': 'list<breakdowns_enum>',
'date_preset': 'date_preset_enum',
'default_summary': 'bool',
'export_columns': 'list<string>',
'export_format': 'string',
'export_name': 'string',
'fields': 'list<fields_enum>',
'filtering': 'list<Object>',
'level': 'level_enum',
'product_id_limit': 'int',
'sort': 'list<string>',
'summary': 'list<summary_enum>',
'summary_action_breakdowns': 'list<summary_action_breakdowns_enum>',
'time_increment': 'string',
'time_range': 'Object',
'time_ranges': 'list<Object>',
'use_account_attribution_setting': 'bool',
}
enums = {
'action_attribution_windows_enum': AdsInsights.ActionAttributionWindows.__dict__.values(),
'action_breakdowns_enum': AdsInsights.ActionBreakdowns.__dict__.values(),
'action_report_time_enum': AdsInsights.ActionReportTime.__dict__.values(),
'breakdowns_enum': AdsInsights.Breakdowns.__dict__.values(),
'date_preset_enum': AdsInsights.DatePreset.__dict__.values(),
'summary_enum': AdsInsights.Summary.__dict__.values(),
'level_enum': AdsInsights.Level.__dict__.values(),
'summary_action_breakdowns_enum': AdsInsights.SummaryActionBreakdowns.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/insights',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdReportRun,
api_type='EDGE',
response_parser=ObjectParser(
target_class=AdReportRun, api=self._api),
include_summary=False,
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def api_update(self, fields=None, params=None, batch=None, pending=False):
param_types = {
'account_id': 'string',
'adlabels': 'list<Object>',
'adset_schedule': 'list<Object>',
'attribution_spec': 'list<map>',
'bid_amount': 'int',
'billing_event': 'billing_event_enum',
'creative_sequence': 'list<string>',
'daily_budget': 'unsigned int',
'daily_imps': 'unsigned int',
'destination_type': 'destination_type_enum',
'end_time': 'datetime',
'execution_options': 'list<execution_options_enum>',
'is_autobid': 'bool',
'is_average_price_pacing': 'bool',
'lifetime_budget': 'unsigned int',
'lifetime_imps': 'unsigned int',
'name': 'string',
'optimization_goal': 'optimization_goal_enum',
'pacing_type': 'list<string>',
'promoted_object': 'Object',
'redownload': 'bool',
'rf_prediction_id': 'string',
'start_time': 'datetime',
'status': 'status_enum',
'targeting': 'Targeting',
'time_based_ad_rotation_id_blocks': 'list<list<unsigned int>>',
'time_based_ad_rotation_intervals': 'list<unsigned int>',
}
enums = {
'billing_event_enum': AdSet.BillingEvent.__dict__.values(),
'destination_type_enum': AdSet.DestinationType.__dict__.values(),
'execution_options_enum': AdSet.ExecutionOptions.__dict__.values(),
'optimization_goal_enum': AdSet.OptimizationGoal.__dict__.values(),
'status_enum': AdSet.Status.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdSet,
api_type='NODE',
response_parser=ObjectParser(reuse_object=self),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_activities(self,
fields=None,
params=None,
batch=None,
pending=False):
param_types = {
'business_id': 'string',
'end_time': 'datetime',
'event_type': 'event_type_enum',
'start_time': 'datetime',
}
enums = {
'event_type_enum': [
'dataset_assign_to_adacct',
'dataset_autotrack_on_adacct',
'dataset_disable_autotrack_on_adacct',
'dataset_unassign_from_adacct',
'add_dataset_to_business',
'add_user_to_dataset',
'remove_user_from_dataset',
'update_user_role_on_dataset',
'create_custom_conversion',
'update_custom_conversion',
'create_custom_audience',
'share_custom_audience',
'unshare_custom_audience',
],
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/activities',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AbstractCrudObject,
api_type='EDGE',
response_parser=ObjectParser(target_class=AbstractCrudObject,
api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_product_feed(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.productfeed import ProductFeed
param_types = {
'country': 'string',
'default_currency': 'string',
'deletion_enabled': 'bool',
'delimiter': 'delimiter_enum',
'encoding': 'encoding_enum',
'file_name': 'string',
'name': 'string',
'quoted_fields_mode': 'quoted_fields_mode_enum',
'rules': 'list<string>',
'schedule': 'string',
'update_schedule': 'string',
}
enums = {
'delimiter_enum':
ProductFeed.Delimiter.__dict__.values(),
'encoding_enum':
ProductFeed.Encoding.__dict__.values(),
'quoted_fields_mode_enum':
ProductFeed.QuotedFieldsMode.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/product_feeds',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ProductFeed,
api_type='EDGE',
response_parser=ObjectParser(target_class=ProductFeed,
api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def __init__(
self,
node_id,
method,
endpoint,
api=None,
param_checker=TypeChecker({}, {}),
target_class=None,
api_type=None,
allow_file_upload=False,
response_parser=None,
include_summary=True,
api_version=None,
):
"""
Args:
node_id: The node id to perform the api call.
method: The HTTP method of the call.
endpoint: The edge of the api call.
api (optional): The FacebookAdsApi object.
param_checker (optional): Parameter checker.
target_class (optional): The return class of the api call.
api_type (optional): NODE or EDGE type of the call.
allow_file_upload (optional): Whether the call allows upload.
response_parser (optional): An ObjectParser to parse response.
include_summary (optional): Include "summary".
api_version (optional): API version.
"""
self._api = api or FacebookAdsApi.get_default_api()
self._node_id = node_id
self._method = method
self._endpoint = endpoint.replace('/', '')
self._path = (node_id, endpoint.replace('/', ''))
self._param_checker = param_checker
self._target_class = target_class
self._api_type = api_type
self._allow_file_upload = allow_file_upload
self._response_parser = response_parser
self._include_summary = include_summary
self._api_version = api_version
self._params = {}
self._fields = []
self._response = None
self._file_params = {}
self._file_counter = 0
self._accepted_fields = []
if target_class is not None:
self._accepted_fields = target_class.Field.__dict__.values()
def create_home_listing(self,
fields=None,
params=None,
batch=None,
pending=False):
param_types = {
'address': 'Object',
'availability': 'string',
'currency': 'string',
'description': 'string',
'home_listing_id': 'string',
'images': 'list<Object>',
'listing_type': 'string',
'name': 'string',
'num_baths': 'float',
'num_beds': 'float',
'num_units': 'float',
'price': 'float',
'property_type': 'string',
'url': 'string',
'year_built': 'unsigned int',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/home_listings',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AbstractCrudObject,
api_type='EDGE',
response_parser=ObjectParser(target_class=AbstractCrudObject,
api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_ad_account_creation_request(self,
fields=None,
params=None,
batch=None,
pending=False):
param_types = {
'account_type': 'string',
'additional_comment': 'string',
'address_in_chinese': 'string',
'address_in_english': 'Object',
'billing_party_name': 'string',
'business_registration': 'file',
'business_registration_id': 'unsigned int',
'chinese_legal_entity_name': 'string',
'contact': 'Object',
'currency': 'string',
'english_legal_entity_name': 'string',
'fb_page_url': 'string',
'fb_sales_rep_email': 'string',
'has_planning_agency': 'bool',
'is_targeting_outside_china': 'bool',
'planning_agency_name': 'string',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/adaccountcreationrequests',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AbstractCrudObject,
api_type='EDGE',
response_parser=ObjectParser(target_class=AbstractCrudObject),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_user_permission(self,
fields=None,
params=None,
batch=None,
pending=False):
param_types = {
'email': 'string',
'id': 'string',
'role': 'role_enum',
'user': '******',
}
enums = {
'role_enum': [
'ADMIN',
'EMPLOYEE',
'SYSTEM_USER',
'ADMIN_SYSTEM_USER',
'INSTAGRAM_ADMIN',
'INSTAGRAM_EMPLOYEE',
'FB_EMPLOYEE_ACCOUNT_MANAGER',
'FB_EMPLOYEE_SALES_REP',
],
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/userpermissions',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AbstractCrudObject,
api_type='EDGE',
response_parser=ObjectParser(target_class=AbstractCrudObject),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_ad_study(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.adstudy import AdStudy
param_types = {
'cells': 'list<Object>',
'confidence_level': 'float',
'cooldown_start_time': 'int',
'description': 'string',
'end_time': 'int',
'name': 'string',
'objectives': 'list<Object>',
'observation_end_time': 'int',
'start_time': 'int',
'type': 'type_enum',
'viewers': 'list<int>',
}
enums = {
'type_enum': AdStudy.Type.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/ad_studies',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdStudy,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdStudy),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_previews(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.adpreview import AdPreview
param_types = {
'ad_format': 'ad_format_enum',
'dynamic_creative_spec': 'Object',
'end_date': 'datetime',
'height': 'unsigned int',
'locale': 'string',
'place_page_id': 'int',
'post': 'Object',
'product_item_ids': 'list<string>',
'start_date': 'datetime',
'width': 'unsigned int',
}
enums = {
'ad_format_enum': AdPreview.AdFormat.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/previews',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdPreview,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdPreview,
api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_businesse(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads.adobjects.business import Business
self.assure_call()
param_types = {
'id': 'int',
'name': 'string',
'primary_page': 'string',
'sales_rep_email': 'string',
'survey_business_type': 'survey_business_type_enum',
'survey_num_assets': 'unsigned int',
'survey_num_people': 'unsigned int',
'timezone_id': 'unsigned int',
'vertical': 'vertical_enum',
}
enums = {
'survey_business_type_enum':
Business.SurveyBusinessType.__dict__.values(),
'vertical_enum':
Business.Vertical.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/businesses',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AbstractCrudObject,
api_type='EDGE',
response_parser=ObjectParser(target_class=AbstractCrudObject),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch)
return request
return request if pending else request.execute()
